From fbfdbb0bea7e73b6ae40b953f9566ad025ed36a8 Mon Sep 17 00:00:00 2001 From: wanchengzhen Date: Thu, 17 Feb 2022 15:09:57 +0000 Subject: [PATCH] Check codeCheck Signed-off-by: wanchengzhen --- .../ability_runtime/include/ability_context.h | 8 + .../include/ability_context_impl.h | 10 + .../include/local_call_record.h | 2 + .../src/local_call_container.cpp | 25 ++ .../ability_runtime/src/local_call_record.cpp | 10 + .../AMS/mock_serviceability_manager_service.h | 4 +- .../kits/ability/native/src/ability.cpp | 2 +- .../ability/native/src/ability_thread.cpp | 21 +- .../include/mock_ability_manager_service.h | 4 +- .../appkit/native/app/src/main_thread.cpp | 8 + .../mock/AMS/mock_ability_manager_service.h | 4 +- .../AMS/mock_serviceability_manager_service.h | 4 +- .../include/ability_manager_client.h | 8 + .../include/ability_manager_errors.h | 5 + .../include/ability_manager_interface.h | 4 +- .../include/ability_manager_proxy.h | 4 +- .../include/ability_manager_service.h | 21 +- services/abilitymgr/include/ability_record.h | 6 +- services/abilitymgr/include/call_container.h | 130 +++--- .../abilitymgr/include/data_ability_manager.h | 1 + .../include/kernal_ability_manager.h | 2 + .../include/kernal_system_app_manager.h | 2 + .../abilitymgr/include/mission_list_manager.h | 2 + .../abilitymgr/include/pending_want_manager.h | 1 + .../abilitymgr/src/ability_manager_client.cpp | 8 + .../abilitymgr/src/ability_manager_proxy.cpp | 13 +- .../src/ability_manager_service.cpp | 86 +++- .../abilitymgr/src/ability_manager_stub.cpp | 4 +- services/abilitymgr/src/ability_record.cpp | 67 +++ services/abilitymgr/src/call_container.cpp | 384 +++++++++--------- services/abilitymgr/src/call_record.cpp | 378 +++++++++-------- .../abilitymgr/src/data_ability_manager.cpp | 42 ++ .../abilitymgr/src/kernal_ability_manager.cpp | 8 + .../src/kernal_system_app_manager.cpp | 7 + services/abilitymgr/src/mission_list.cpp | 6 +- .../abilitymgr/src/mission_list_manager.cpp | 83 +++- .../abilitymgr/src/pending_want_manager.cpp | 35 +- .../ability_manager_stub_mock.h | 4 +- .../ability_manager_stub_impl_mock.h | 4 +- .../test/mock/include/mock_ability_manager.h | 4 +- .../mock/include/mock_ability_mgr_service.h | 4 +- tools/aa/include/ability_command.h | 18 +- tools/aa/src/ability_command.cpp | 46 ++- tools/test/mock/mock_ability_manager_stub.h | 4 +- 44 files changed, 979 insertions(+), 514 deletions(-) diff --git a/frameworks/kits/ability/ability_runtime/include/ability_context.h b/frameworks/kits/ability/ability_runtime/include/ability_context.h index 3b84875a5fa..e64b138a20b 100644 --- a/frameworks/kits/ability/ability_runtime/include/ability_context.h +++ b/frameworks/kits/ability/ability_runtime/include/ability_context.h @@ -32,6 +32,7 @@ namespace OHOS { namespace AbilityRuntime { using RuntimeTask = std::function; using PermissionRequestTask = std::function&, const std::vector&)>; +class LocalCallContainer; class AbilityContext : public Context { public: virtual ~AbilityContext() = default; @@ -229,6 +230,13 @@ public: */ virtual ErrCode SetMissionLabel(const std::string &label) = 0; + /** + * @brief Get LocalCallContainer. + * + * @return Returns the LocalCallContainer. + */ + virtual sptr GetLocalCallContainer() = 0; + virtual void SetConfiguration(const std::shared_ptr &config) = 0; virtual std::shared_ptr GetConfiguration() const = 0; diff --git a/frameworks/kits/ability/ability_runtime/include/ability_context_impl.h b/frameworks/kits/ability/ability_runtime/include/ability_context_impl.h index 70f19c04e5b..a648d32b426 100644 --- a/frameworks/kits/ability/ability_runtime/include/ability_context_impl.h +++ b/frameworks/kits/ability/ability_runtime/include/ability_context_impl.h @@ -117,6 +117,16 @@ public: return contentStorage_; } + /** + * @brief Get LocalCallContainer. + * + * @return Returns the LocalCallContainer. + */ + sptr GetLocalCallContainer() override + { + return localCallContainer_; + } + void SetConfiguration(const std::shared_ptr &config) override; std::shared_ptr GetConfiguration() const override; diff --git a/frameworks/kits/ability/ability_runtime/include/local_call_record.h b/frameworks/kits/ability/ability_runtime/include/local_call_record.h index 4fb8ae25b23..331caec0131 100644 --- a/frameworks/kits/ability/ability_runtime/include/local_call_record.h +++ b/frameworks/kits/ability/ability_runtime/include/local_call_record.h @@ -39,6 +39,8 @@ public: void InvokeCallBack() const; AppExecFwk::ElementName GetElementName() const; bool IsExistCallBack() const; + int GetRecordId(); + std::vector> GetCallers(); private: static int64_t callRecordId; diff --git a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp index 13ed5205b1c..2a06359cb24 100644 --- a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp +++ b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp @@ -119,6 +119,31 @@ int LocalCallContainer::Release(const std::shared_ptr& callback) void LocalCallContainer::DumpCalls(std::vector &info) const { HILOG_DEBUG("LocalCallContainer::DumpCalls called."); + info.emplace_back(" caller connections:"); + for (auto iter = callProxyRecords_.begin(); iter != callProxyRecords_.end(); iter++) { + std::string tempstr = " LocalCallRecord"; + tempstr += " ID #" + std::to_string (iter->second->GetRecordId()) + "\n"; + tempstr += " callee"; + tempstr += " uri[" + iter->first + "]" + "\n"; + tempstr += " callers #" + std::to_string (iter->second->GetCallers().size()); + bool flag = true; + for (auto &callBack:iter->second->GetCallers()) { + if (callBack && !callBack->IsCallBack()) { + HILOG_INFO("%{public}s call back is not called.", __func__); + flag = false; + break; + } + } + if (flag) { + HILOG_INFO("%{public}s state is REQUESTEND.", __func__); + tempstr += " state #REQUESTEND"; + } else { + HILOG_INFO("%{public}s state is REQUESTING.", __func__); + tempstr += " state #REQUESTING"; + } + info.emplace_back(tempstr); + } + return; } void LocalCallContainer::OnAbilityConnectDone( diff --git a/frameworks/kits/ability/ability_runtime/src/local_call_record.cpp b/frameworks/kits/ability/ability_runtime/src/local_call_record.cpp index d2c30b86491..d0785f3d6d5 100644 --- a/frameworks/kits/ability/ability_runtime/src/local_call_record.cpp +++ b/frameworks/kits/ability/ability_runtime/src/local_call_record.cpp @@ -113,5 +113,15 @@ bool LocalCallRecord::IsExistCallBack() const { return (callers_.size() > 0); } + +int LocalCallRecord::GetRecordId() +{ + return recordId_; +} + +std::vector> LocalCallRecord::GetCallers() +{ + return callers_; +} } // namespace AbilityRuntime } // namespace OHOS \ No newline at end of file diff --git a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.h b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.h index 8dd975e7780..a028c817425 100644 --- a/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.h +++ b/frameworks/kits/ability/ability_runtime/test/mock/AMS/mock_serviceability_manager_service.h @@ -278,9 +278,9 @@ public: return true; } - bool SendANRProcessID(int pid) override + int SendANRProcessID(int pid) override { - return true; + return 0; } int RegisterSnapshotHandler(const sptr& handler) override diff --git a/frameworks/kits/ability/native/src/ability.cpp b/frameworks/kits/ability/native/src/ability.cpp index 93516922984..61772871a83 100755 --- a/frameworks/kits/ability/native/src/ability.cpp +++ b/frameworks/kits/ability/native/src/ability.cpp @@ -81,7 +81,7 @@ static std::mutex formLock; constexpr int64_t SEC_TO_MILLISEC = 1000; constexpr int64_t MILLISEC_TO_NANOSEC = 1000000; -constexpr int32_t DISTRIBUTED_OBJECT_TIMEOUT = 10000; +constexpr int32_t DISTRIBUTED_OBJECT_TIMEOUT = 3000; Ability* Ability::Create(const std::unique_ptr& runtime) { diff --git a/frameworks/kits/ability/native/src/ability_thread.cpp b/frameworks/kits/ability/native/src/ability_thread.cpp index f24d984b5ab..f9906fb19d4 100644 --- a/frameworks/kits/ability/native/src/ability_thread.cpp +++ b/frameworks/kits/ability/native/src/ability_thread.cpp @@ -1581,7 +1581,7 @@ void AbilityThread::DumpAbilityInfo(const std::vector ¶ms, std: return; } - std::string dumpInfo = " event:"; + std::string dumpInfo = " event:"; info.push_back(dumpInfo); if (!abilityHandler_) { @@ -1598,6 +1598,25 @@ void AbilityThread::DumpAbilityInfo(const std::vector ¶ms, std: runner->DumpRunnerInfo(dumpInfo); info.push_back(dumpInfo); + if (!currentAbility_) { + APP_LOGI("currentAbility is nullptr."); + return; + } + + const auto ablityContext = currentAbility_->GetAbilityContext(); + if (!ablityContext) { + APP_LOGI("current ability context is nullptr."); + return; + } + + const auto localCallContainer = ablityContext->GetLocalCallContainer(); + if (!localCallContainer) { + APP_LOGI("current ability context locall call container is nullptr."); + return; + } + + localCallContainer->DumpCalls(info); + APP_LOGI("localCallContainer need to get calls info."); } diff --git a/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h b/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h index bc54e39062e..8aad0460eee 100644 --- a/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h +++ b/frameworks/kits/ability/native/test/mock/include/mock_ability_manager_service.h @@ -276,9 +276,9 @@ public: return 0; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } virtual int StartUserTest(const Want &want, const sptr &observer) override diff --git a/frameworks/kits/appkit/native/app/src/main_thread.cpp b/frameworks/kits/appkit/native/app/src/main_thread.cpp index 0afeb329047..9198f3b77bd 100644 --- a/frameworks/kits/appkit/native/app/src/main_thread.cpp +++ b/frameworks/kits/appkit/native/app/src/main_thread.cpp @@ -1418,6 +1418,14 @@ void MainThread::Start() return; } + APP_LOGI("MainThread::main Register sig handle start"); + struct sigaction sigAct; + sigemptyset(&sigAct.sa_mask); + sigAct.sa_flags = 0; + sigAct.sa_handler = &MainThread::HandleANRProcess; + sigaction(SIGUSR1, &sigAct, NULL); + APP_LOGI("MainThread::main Register sig handle end"); + APP_LOGI("MainThread::main called start Init"); thread->Init(runner, runnerWatchDog); APP_LOGI("MainThread::main called end Init"); diff --git a/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h b/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h index 59d78629135..cd237cd566f 100644 --- a/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h +++ b/frameworks/kits/test/mock/AMS/mock_ability_manager_service.h @@ -239,9 +239,9 @@ public: { return true; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } virtual int StartUserTest(const Want &want, const sptr &observer) override diff --git a/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h b/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h index bab683317ad..e38951442a3 100644 --- a/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h +++ b/frameworks/kits/test/mock/AMS/mock_serviceability_manager_service.h @@ -260,9 +260,9 @@ public: { return true; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } virtual int StartUserTest(const Want &want, const sptr &observer) override diff --git a/interfaces/innerkits/ability_manager/include/ability_manager_client.h b/interfaces/innerkits/ability_manager/include/ability_manager_client.h index aa9e4a9d779..b25b35d743c 100644 --- a/interfaces/innerkits/ability_manager/include/ability_manager_client.h +++ b/interfaces/innerkits/ability_manager/include/ability_manager_client.h @@ -772,6 +772,14 @@ public: virtual int SetAbilityController(const sptr &abilityController, bool imAStabilityTest); + /** + * Send not response process ID to ability manager service. + * + * @param pid The not response process ID. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode SendANRProcessID(int pid); + private: static std::mutex mutex_; static std::shared_ptr instance_; diff --git a/interfaces/innerkits/ability_manager/include/ability_manager_errors.h b/interfaces/innerkits/ability_manager/include/ability_manager_errors.h index f2248c6d206..6e88a2900ce 100644 --- a/interfaces/innerkits/ability_manager/include/ability_manager_errors.h +++ b/interfaces/innerkits/ability_manager/include/ability_manager_errors.h @@ -375,6 +375,11 @@ enum { * Result() for start user test fail. */ START_USER_TEST_FAIL, + + /** + * Result(2097220) for send usr1 sig to anr process fail. + */ + SEND_USR1_SIG_FAIL, }; enum { diff --git a/interfaces/innerkits/ability_manager/include/ability_manager_interface.h b/interfaces/innerkits/ability_manager/include/ability_manager_interface.h index 7bc635de351..be7551c4d4d 100644 --- a/interfaces/innerkits/ability_manager/include/ability_manager_interface.h +++ b/interfaces/innerkits/ability_manager/include/ability_manager_interface.h @@ -703,9 +703,11 @@ public: /** * Send not response process ID to ability manager service. + * * @param pid The not response process ID. + * @return Returns ERR_OK on success, others on failure. */ - virtual bool SendANRProcessID(int pid) = 0; + virtual int SendANRProcessID(int pid) = 0; enum { // ipc id 1-1000 for kit diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index 6441c704a4e..34fe78915d9 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -665,9 +665,11 @@ public: /** * Send not response process ID to ability manager service. + * * @param pid The not response process ID. + * @return Returns ERR_OK on success, others on failure. */ - virtual bool SendANRProcessID(int pid) override; + virtual int SendANRProcessID(int pid) override; private: template diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index dd945a84ce8..ecce01b64cc 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -860,8 +860,9 @@ public: /** * Send not response process ID to ability manager service. * @param pid The not response process ID. + * @return Returns ERR_OK on success, others on failure. */ - virtual bool SendANRProcessID(int pid) override; + virtual int SendANRProcessID(int pid) override; // MSG 0 - 20 represents timeout message static constexpr uint32_t LOAD_TIMEOUT_MSG = 0; @@ -913,6 +914,8 @@ public: KEY_DUMPSYS_SERVICE, KEY_DUMPSYS_PENDING, KEY_DUMPSYS_PROCESS, + KEY_DUMPSYS_DATA, + KEY_DUMPSYS_SYSTEM_UI, }; friend class AbilityStackManager; @@ -1071,17 +1074,21 @@ private: */ void DumpSysFuncInit(); void DumpSysInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void DumpSysMissionListInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void DumpSysAbilityInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void DumpSysStateInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void DumpSysPendingInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void DumpSysProcess( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId); + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); + void DataDumpSysStateInner( + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); + void SystemDumpSysStateInner( + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId); void InitConnectManager(int32_t userId, bool switchUser); void InitDataAbilityManager(int32_t userId, bool switchUser); diff --git a/services/abilitymgr/include/ability_record.h b/services/abilitymgr/include/ability_record.h index 78633a38fd5..70310924947 100644 --- a/services/abilitymgr/include/ability_record.h +++ b/services/abilitymgr/include/ability_record.h @@ -666,6 +666,10 @@ public: */ void Dump(std::vector &info); + void DumpSys(std::vector &info, bool isClient = false); + + void DumpClientInfo(std::vector &info, bool isClient = false); + /** * dump ability state info. * @@ -866,7 +870,7 @@ private: std::weak_ptr mission_; int32_t missionId_ = -1; bool isSwitchingPause_ = false; - + // new version std::shared_ptr callContainer_ = nullptr; bool isStartedByCall_ = false; diff --git a/services/abilitymgr/include/call_container.h b/services/abilitymgr/include/call_container.h index 725d6552e09..84313aa1967 100644 --- a/services/abilitymgr/include/call_container.h +++ b/services/abilitymgr/include/call_container.h @@ -1,65 +1,65 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_AAFWK_CALL_CONTAINER_H -#define OHOS_AAFWK_CALL_CONTAINER_H - -#include -#include -#include - -#include "ability_connect_callback_interface.h" -#include "call_record.h" -#include "element_name.h" -#include "iremote_object.h" -#include "nocopyable.h" - -namespace OHOS { -namespace AAFwk { -class CallRecord; -/** - * @class CallContainer - * CallContainer provides a facility for managing the call records of ability. - */ -class CallContainer : public std::enable_shared_from_this { -public: - using CallMapType = std::map, std::shared_ptr>; - using RecipientMapType = std::map, sptr>; - - CallContainer(); - virtual ~CallContainer(); - - void AddCallRecord(const sptr & connect, const std::shared_ptr& callRecord); - std::shared_ptr GetCallRecord(const sptr & connect) const; - bool RemoveCallRecord(const sptr & connect); - bool CallRequestDone(const sptr & callStub); - void Dump(std::vector &info, const std::string &args = "") const; - bool IsNeedToCallRequest() const; - -private: - void RemoveConnectDeathRecipient(const sptr &connect); - void AddConnectDeathRecipient(const sptr &connect); - void OnConnectionDied(const wptr & remote); - -private: - CallMapType callRecordMap_; - RecipientMapType deathRecipientMap_; - - DISALLOW_COPY_AND_MOVE(CallContainer); -}; -} // namespace AAFwk -} // namespace OHOS -#endif // OHOS_AAFWK_CALL_CONTAINER_H - +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_AAFWK_CALL_CONTAINER_H +#define OHOS_AAFWK_CALL_CONTAINER_H + +#include +#include +#include + +#include "ability_connect_callback_interface.h" +#include "call_record.h" +#include "element_name.h" +#include "iremote_object.h" +#include "nocopyable.h" + +namespace OHOS { +namespace AAFwk { +class CallRecord; +/** + * @class CallContainer + * CallContainer provides a facility for managing the call records of ability. + */ +class CallContainer : public std::enable_shared_from_this { +public: + using CallMapType = std::map, std::shared_ptr>; + using RecipientMapType = std::map, sptr>; + + CallContainer(); + virtual ~CallContainer(); + + void AddCallRecord(const sptr & connect, const std::shared_ptr& callRecord); + std::shared_ptr GetCallRecord(const sptr & connect) const; + bool RemoveCallRecord(const sptr & connect); + bool CallRequestDone(const sptr & callStub); + void Dump(std::vector &info) const; + bool IsNeedToCallRequest() const; + +private: + void RemoveConnectDeathRecipient(const sptr &connect); + void AddConnectDeathRecipient(const sptr &connect); + void OnConnectionDied(const wptr & remote); + +private: + CallMapType callRecordMap_; + RecipientMapType deathRecipientMap_; + + DISALLOW_COPY_AND_MOVE(CallContainer); +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_AAFWK_CALL_CONTAINER_H + diff --git a/services/abilitymgr/include/data_ability_manager.h b/services/abilitymgr/include/data_ability_manager.h index 13b5a91517e..5d91f49a4fb 100644 --- a/services/abilitymgr/include/data_ability_manager.h +++ b/services/abilitymgr/include/data_ability_manager.h @@ -47,6 +47,7 @@ public: std::shared_ptr GetAbilityRecordByScheduler(const sptr &scheduler); void Dump(const char *func, int line); void DumpState(std::vector &info, const std::string &args = "") const; + void DumpSysState(std::vector &info, bool isClient = false, const std::string &args = "") const; void GetAbilityRunningInfos(std::vector &info); private: diff --git a/services/abilitymgr/include/kernal_ability_manager.h b/services/abilitymgr/include/kernal_ability_manager.h index dd1ec48af34..950e7ffbb6d 100644 --- a/services/abilitymgr/include/kernal_ability_manager.h +++ b/services/abilitymgr/include/kernal_ability_manager.h @@ -79,6 +79,8 @@ public: void DumpState(std::vector &info); + void DumpSysState(std::vector &info, bool isClient); + void OnAbilityDied(std::shared_ptr abilityRecord); void OnTimeOut(uint32_t msgId, int64_t eventId); diff --git a/services/abilitymgr/include/kernal_system_app_manager.h b/services/abilitymgr/include/kernal_system_app_manager.h index 55f2663ad99..eb30240281a 100644 --- a/services/abilitymgr/include/kernal_system_app_manager.h +++ b/services/abilitymgr/include/kernal_system_app_manager.h @@ -79,6 +79,8 @@ public: void DumpState(std::vector &info); + void DumpSysState(std::vector &info, bool isClient = false); + void OnAbilityDied(std::shared_ptr abilityRecord); void OnTimeOut(uint32_t msgId, int64_t eventId); diff --git a/services/abilitymgr/include/mission_list_manager.h b/services/abilitymgr/include/mission_list_manager.h index 31677e667cc..7c6a82afa40 100644 --- a/services/abilitymgr/include/mission_list_manager.h +++ b/services/abilitymgr/include/mission_list_manager.h @@ -81,6 +81,8 @@ public: */ void OnAbilityRequestDone(const sptr &token, const int32_t state); + void OnAppStateChanged(const AppInfo &info); + /** * attach ability thread ipc object. * diff --git a/services/abilitymgr/include/pending_want_manager.h b/services/abilitymgr/include/pending_want_manager.h index b12cbef86a8..55852046f41 100644 --- a/services/abilitymgr/include/pending_want_manager.h +++ b/services/abilitymgr/include/pending_want_manager.h @@ -159,6 +159,7 @@ public: void ClearPendingWantRecord(const std::string &bundleName); void Dump(std::vector &info); + void DumpByRecordId(std::vector &info, const std::string &args); private: sptr GetWantSenderLocked(const int32_t callingUid, const int32_t uid, const int32_t userId, diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index 65fd32a775e..f841e8e2c2e 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -948,5 +948,13 @@ ErrCode AbilityManagerClient::SetAbilityController(const sptr abms = iface_cast(remoteObject_); return abms->SetAbilityController(abilityController, imAStabilityTest); } + +ErrCode AbilityManagerClient::SendANRProcessID(int pid) +{ + CHECK_REMOTE_OBJECT_AND_RETURN(remoteObject_, ABILITY_SERVICE_NOT_CONNECTED); + + sptr abms = iface_cast(remoteObject_); + return abms->SendANRProcessID(pid); +} } // namespace AAFwk } // namespace AAFwk diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp index 9a12330bd93..7e5389e67e3 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -2596,25 +2596,24 @@ int AbilityManagerProxy::DoAbilityBackground(const sptr &token, u return reply.ReadInt32(); } -bool AbilityManagerProxy::SendANRProcessID(int pid) +int AbilityManagerProxy::SendANRProcessID(int pid) { - int error; MessageParcel data; MessageParcel reply; MessageOption option; if (!WriteInterfaceToken(data)) { - return false; + return INNER_ERR; } if (!data.WriteInt32(pid)) { HILOG_ERROR("pid WriteInt32 fail."); - return false; + return ERR_INVALID_VALUE; } - error = Remote()->SendRequest(IAbilityManager::SEND_APP_NOT_RESPONSE_PROCESS_ID, data, reply, option); + auto error = Remote()->SendRequest(IAbilityManager::SEND_APP_NOT_RESPONSE_PROCESS_ID, data, reply, option); if (error != NO_ERROR) { HILOG_ERROR("SendANRProcessID error: %d", error); - return false; + return error; } - return reply.ReadBool(); + return reply.ReadInt32(); } } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index 576a23a72be..f1bcce3aaa4 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -112,6 +112,10 @@ const std::map AbilityManagerSer std::map::value_type("-p", KEY_DUMPSYS_PENDING), std::map::value_type("--process", KEY_DUMPSYS_PROCESS), std::map::value_type("-r", KEY_DUMPSYS_PROCESS), + std::map::value_type("--data", KEY_DUMPSYS_DATA), + std::map::value_type("-d", KEY_DUMPSYS_DATA), + std::map::value_type("--ui", KEY_DUMPSYS_SYSTEM_UI), + std::map::value_type("-k", KEY_DUMPSYS_SYSTEM_UI), }; const bool REGISTER_RESULT = @@ -1657,6 +1661,8 @@ void AbilityManagerService::DumpSysFuncInit() dumpsysFuncMap_[KEY_DUMPSYS_SERVICE] = &AbilityManagerService::DumpSysStateInner; dumpsysFuncMap_[KEY_DUMPSYS_PENDING] = &AbilityManagerService::DumpSysPendingInner; dumpsysFuncMap_[KEY_DUMPSYS_PROCESS] = &AbilityManagerService::DumpSysProcess; + dumpsysFuncMap_[KEY_DUMPSYS_DATA] = &AbilityManagerService::DataDumpSysStateInner; + dumpsysFuncMap_[KEY_DUMPSYS_SYSTEM_UI] = &AbilityManagerService::SystemDumpSysStateInner; } void AbilityManagerService::DumpSysInner( @@ -1674,7 +1680,7 @@ void AbilityManagerService::DumpSysInner( } void AbilityManagerService::DumpSysMissionListInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId) + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId) { std::shared_ptr targetManager; if (isUserID) { @@ -1705,7 +1711,7 @@ void AbilityManagerService::DumpSysMissionListInner( } } void AbilityManagerService::DumpSysAbilityInner( - const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId) + const std::string &args, std::vector &info, bool isClient, bool isUserID, int userId) { std::shared_ptr targetManager; if (isUserID) { @@ -1771,18 +1777,33 @@ void AbilityManagerService::DumpSysStateInner( void AbilityManagerService::DumpSysPendingInner( const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId) { + std::shared_ptr targetManager; if (isUserID) { auto it = pendingWantManagers_.find(userId); - if (it != pendingWantManagers_.end()) { - it->second->Dump(info); + if (it == pendingWantManagers_.end()) { + info.push_back("error: No user found'."); return; } - info.push_back("error: No user found'."); + targetManager = it->second; + } else { + targetManager = pendingWantManager_; + } + + CHECK_POINTER(targetManager); + + std::vector argList; + SplitStr(args, " ", argList); + if (argList.empty()) { return; } - CHECK_POINTER(pendingWantManager_); - pendingWantManager_->Dump(info); + if (argList.size() == MIN_DUMP_ARGUMENT_NUM) { + targetManager->DumpByRecordId(info, argList[1]); + } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) { + targetManager->Dump(info); + } else { + info.emplace_back("error: invalid argument, please see 'ability dumpsys -h'."); + } } void AbilityManagerService::DumpSysProcess( @@ -1830,6 +1851,47 @@ void AbilityManagerService::DumpSysProcess( } } +void AbilityManagerService::DataDumpSysStateInner( + const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId) +{ + std::shared_ptr targetManager; + if (isUserID) { + auto it = dataAbilityManagers_.find(userId); + if (it == dataAbilityManagers_.end()) { + info.push_back("error: No user found'."); + return; + } + targetManager = it->second; + } else { + targetManager = dataAbilityManager_; + } + + CHECK_POINTER(targetManager); + + std::vector argList; + SplitStr(args, " ", argList); + if (argList.empty()) { + return; + } + if (argList.size() == MIN_DUMP_ARGUMENT_NUM) { + targetManager->DumpSysState(info, isClient, argList[1]); + } else if (argList.size() < MIN_DUMP_ARGUMENT_NUM) { + targetManager->DumpSysState(info, isClient); + } else { + info.emplace_back("error: invalid argument, please see 'ability dump -h'."); + } +} + +void AbilityManagerService::SystemDumpSysStateInner( + const std::string& args, std::vector& info, bool isClient, bool isUserID, int userId) +{ + if (useNewMission_) { + kernalAbilityManager_->DumpSysState(info, isClient); + } else { + systemAppManager_->DumpSysState(info, isClient); + } +} + void AbilityManagerService::DumpInner(const std::string &args, std::vector &info) { if (useNewMission_) { @@ -2227,11 +2289,12 @@ void AbilityManagerService::OnAbilityRequestDone(const sptr &toke void AbilityManagerService::OnAppStateChanged(const AppInfo &info) { HILOG_INFO("On app state changed."); - currentStackManager_->OnAppStateChanged(info); connectManager_->OnAppStateChanged(info); if (useNewMission_) { + currentMissionListManager_->OnAppStateChanged(info); kernalAbilityManager_->OnAppStateChanged(info); } else { + currentStackManager_->OnAppStateChanged(info); systemAppManager_->OnAppStateChanged(info); } dataAbilityManager_->OnAppStateChanged(info); @@ -3941,7 +4004,7 @@ int AbilityManagerService::SetAbilityController(const sptr & return ERR_OK; } -bool AbilityManagerService::SendANRProcessID(int pid) +int AbilityManagerService::SendANRProcessID(int pid) { int anrTimeOut = amsConfigResolver_->GetANRTimeOutTime(); auto timeoutTask = [pid]() { @@ -3949,11 +4012,12 @@ bool AbilityManagerService::SendANRProcessID(int pid) HILOG_ERROR("Kill app not response process failed"); } }; + handler_->PostTask(timeoutTask, "TIME_OUT_TASK", anrTimeOut); if (kill(pid, SIGUSR1) != ERR_OK) { HILOG_ERROR("Send sig to app not response process failed"); + return SEND_USR1_SIG_FAIL; } - handler_->PostTask(timeoutTask, "TIME_OUT_TASK", anrTimeOut); - return true; + return ERR_OK; } bool AbilityManagerService::IsRunningInStabilityTest() diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index a26f2142da7..c3377113091 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -1505,8 +1505,8 @@ int AbilityManagerStub::DoAbilityBackgroundInner(MessageParcel &data, MessagePar int AbilityManagerStub::SendANRProcessIDInner(MessageParcel &data, MessageParcel &reply) { int32_t pid = data.ReadInt32(); - bool result = SendANRProcessID(pid); - if (!reply.WriteBool(result)) { + int32_t result = SendANRProcessID(pid); + if (!reply.WriteInt32(result)) { HILOG_ERROR("reply write failed."); return ERR_INVALID_VALUE; } diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index 1c398aea0b9..a261d732405 100644 --- a/services/abilitymgr/src/ability_record.cpp +++ b/services/abilitymgr/src/ability_record.cpp @@ -947,6 +947,11 @@ void AbilityRecord::DumpAbilityState( dumpInfo = " ready #" + std::to_string(isReady_) + " window attached #" + std::to_string(isWindowAttached_) + " launcher #" + std::to_string(isLauncherAbility_); info.push_back(dumpInfo); + dumpInfo = " callee connections: "; + info.push_back(dumpInfo); + if (callContainer_) { + callContainer_->Dump(info); + } if (isLauncherRoot_ && IsNewVersion()) { dumpInfo = " can restart num #" + std::to_string(restartCount_); @@ -1562,5 +1567,67 @@ bool AbilityRecord::IsSwitchingPause() { return isSwitchingPause_; } + +void AbilityRecord::DumpSys(std::vector &info, bool isClient) +{ + std::string dumpInfo = " AbilityRecord ID #" + std::to_string(recordId_); + info.push_back(dumpInfo); + dumpInfo = " app name [" + GetAbilityInfo().applicationName + "]"; + info.push_back(dumpInfo); + dumpInfo = " main name [" + GetAbilityInfo().name + "]"; + info.push_back(dumpInfo); + dumpInfo = " bundle name [" + GetAbilityInfo().bundleName + "]"; + info.push_back(dumpInfo); + std::string typeStr; + GetAbilityTypeString(typeStr); + dumpInfo = " ability type [" + typeStr + "]"; + info.push_back(dumpInfo); + std::shared_ptr preAbility = GetPreAbilityRecord(); + if (preAbility == nullptr) { + dumpInfo = " previous ability app name [NULL]" + LINE_SEPARATOR; + dumpInfo += " previous ability file name [NULL]"; + } else { + dumpInfo = + " previous ability app name [" + preAbility->GetAbilityInfo().applicationName + "]" + LINE_SEPARATOR; + dumpInfo += " previous ability file name [" + preAbility->GetAbilityInfo().name + "]"; + } + info.push_back(dumpInfo); + std::shared_ptr nextAbility = GetNextAbilityRecord(); + if (nextAbility == nullptr) { + dumpInfo = " next ability app name [NULL]" + LINE_SEPARATOR; + dumpInfo += " next ability file name [NULL]"; + } else { + dumpInfo = + " next ability app name [" + nextAbility->GetAbilityInfo().applicationName + "]" + LINE_SEPARATOR; + dumpInfo += " next ability main name [" + nextAbility->GetAbilityInfo().name + "]"; + } + info.push_back(dumpInfo); + dumpInfo = " state #" + AbilityRecord::ConvertAbilityState(GetAbilityState()) + " start time [" + + std::to_string(startTime_) + "]"; + info.push_back(dumpInfo); + dumpInfo = " app state #" + AbilityRecord::ConvertAppState(appState_); + info.push_back(dumpInfo); + dumpInfo = " ready #" + std::to_string(isReady_) + " window attached #" + + std::to_string(isWindowAttached_) + " launcher #" + std::to_string(isLauncherAbility_); + info.push_back(dumpInfo); + + if (isLauncherRoot_ && IsNewVersion()) { + dumpInfo = " can restart num #" + std::to_string(restartCount_); + info.push_back(dumpInfo); + } + DumpClientInfo(info, isClient); +} + +void AbilityRecord::DumpClientInfo(std::vector &info, bool isClient) +{ + if (isClient && scheduler_ && isReady_) { + std::vector params; + scheduler_->DumpAbilityInfo(params, info); + AppExecFwk::Configuration config; + if (DelayedSingleton::GetInstance()->GetConfiguration(config) == ERR_OK) { + info.emplace_back(" configuration: " + config.GetName()); + } + } +} } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/call_container.cpp b/services/abilitymgr/src/call_container.cpp index 5782444019f..4657a6051f2 100644 --- a/services/abilitymgr/src/call_container.cpp +++ b/services/abilitymgr/src/call_container.cpp @@ -1,189 +1,195 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "call_container.h" - -#include "hilog_wrapper.h" -#include "ability_manager_errors.h" -#include "ability_connect_callback_stub.h" -#include "ability_util.h" -#include "ability_event_handler.h" -#include "ability_manager_service.h" - -namespace OHOS { -namespace AAFwk { -CallContainer::CallContainer() -{} - -CallContainer::~CallContainer() -{ - std::for_each(deathRecipientMap_.begin(), - deathRecipientMap_.end(), - [&](RecipientMapType::reference recipient) { - recipient.first->RemoveDeathRecipient(recipient.second); - }); - - deathRecipientMap_.clear(); - callRecordMap_.clear(); -} - -void CallContainer::AddCallRecord(const sptr & connect, - const std::shared_ptr& callRecord) -{ - CHECK_POINTER(callRecord); - CHECK_POINTER(connect); - CHECK_POINTER(connect->AsObject()); - - auto iter = callRecordMap_.find(connect->AsObject()); - if (iter != callRecordMap_.end()) { - RemoveConnectDeathRecipient(connect); - callRecordMap_.erase(callRecordMap_.find(connect->AsObject())); - } - - AddConnectDeathRecipient(connect); - callRecord->SetConCallBack(connect); - callRecordMap_.emplace(connect->AsObject(), callRecord); - - HILOG_DEBUG("Add call record to callcontainer, target: %{public}s", - callRecord->GetTargetServiceName().GetURI().c_str()); -} - -std::shared_ptr CallContainer::GetCallRecord(const sptr & connect) const -{ - CHECK_POINTER_AND_RETURN(connect, nullptr); - CHECK_POINTER_AND_RETURN(connect->AsObject(), nullptr); - - auto mapIter = callRecordMap_.find(connect->AsObject()); - if (mapIter != callRecordMap_.end()) { - return mapIter->second; - } - - return nullptr; -} - -bool CallContainer::RemoveCallRecord(const sptr & connect) -{ - HILOG_DEBUG("call container release call record by callback."); - CHECK_POINTER_AND_RETURN(connect, nullptr); - CHECK_POINTER_AND_RETURN(connect->AsObject(), nullptr); - - auto iter = callRecordMap_.find(connect->AsObject()); - if (iter != callRecordMap_.end()) { - auto callrecord = iter->second; - if (callrecord) { - callrecord->SchedulerDisConnectDone(); - } - RemoveConnectDeathRecipient(connect); - callRecordMap_.erase(callRecordMap_.find(connect->AsObject())); - HILOG_DEBUG("remove call record is success."); - return true; - } - - if (callRecordMap_.empty()) { - // notify soft resouce service. - HILOG_DEBUG("this ability has no callrecord."); - } - - HILOG_WARN("remove call record is not exist."); - return false; -} - -void CallContainer::OnConnectionDied(const wptr & remote) -{ - HILOG_WARN("Call back is died."); - auto object = remote.promote(); - CHECK_POINTER(object); - - std::shared_ptr callRecord = nullptr; - auto mapIter = callRecordMap_.find(object); - if (mapIter != callRecordMap_.end()) { - callRecord = mapIter->second; - } - - auto abilityManagerService = DelayedSingleton::GetInstance(); - CHECK_POINTER(abilityManagerService); - auto handler = abilityManagerService->GetEventHandler(); - CHECK_POINTER(handler); - auto task = [abilityManagerService, callRecord]() { - abilityManagerService->OnCallConnectDied(callRecord); - }; - handler->PostTask(task); -} - -bool CallContainer::CallRequestDone(const sptr & callStub) -{ - HILOG_INFO("Call Request Done start."); - - CHECK_POINTER_AND_RETURN(callStub, false); - - std::for_each(callRecordMap_.begin(), - callRecordMap_.end(), - [&callStub](CallMapType::reference service) { - std::shared_ptr callRecord = service.second; - if (callRecord && callRecord->IsCallState(CallState::REQUESTING)) { - callRecord->SetCallStub(callStub); - callRecord->SchedulerConnectDone(); - } - }); - - HILOG_INFO("Call Request Done end."); - return true; -} - -void CallContainer::Dump(std::vector &info, const std::string &args) const -{ - HILOG_INFO("Dump call records."); -} - -bool CallContainer::IsNeedToCallRequest() const -{ - for (auto &iter : callRecordMap_) { - auto callRecord = iter.second; - if (callRecord && !callRecord->IsCallState(CallState::REQUESTED)) { - return true; - } - } - return false; -} - -void CallContainer::AddConnectDeathRecipient(const sptr &connect) -{ - CHECK_POINTER(connect); - CHECK_POINTER(connect->AsObject()); - auto it = deathRecipientMap_.find(connect->AsObject()); - if (it != deathRecipientMap_.end()) { - HILOG_ERROR("This death recipient has been added."); - return; - } else { - sptr deathRecipient = new AbilityConnectCallbackRecipient( - std::bind(&CallContainer::OnConnectionDied, this, std::placeholders::_1)); - connect->AsObject()->AddDeathRecipient(deathRecipient); - deathRecipientMap_.emplace(connect->AsObject(), deathRecipient); - } -} - -void CallContainer::RemoveConnectDeathRecipient(const sptr &connect) -{ - CHECK_POINTER(connect); - CHECK_POINTER(connect->AsObject()); - auto it = deathRecipientMap_.find(connect->AsObject()); - if (it != deathRecipientMap_.end()) { - it->first->RemoveDeathRecipient(it->second); - deathRecipientMap_.erase(it); - return; - } -} -} // namespace AAFwk -} // namesspace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "call_container.h" + +#include "hilog_wrapper.h" +#include "ability_manager_errors.h" +#include "ability_connect_callback_stub.h" +#include "ability_util.h" +#include "ability_event_handler.h" +#include "ability_manager_service.h" + +namespace OHOS { +namespace AAFwk { +CallContainer::CallContainer() +{} + +CallContainer::~CallContainer() +{ + std::for_each(deathRecipientMap_.begin(), + deathRecipientMap_.end(), + [&](RecipientMapType::reference recipient) { + recipient.first->RemoveDeathRecipient(recipient.second); + }); + + deathRecipientMap_.clear(); + callRecordMap_.clear(); +} + +void CallContainer::AddCallRecord(const sptr & connect, + const std::shared_ptr& callRecord) +{ + CHECK_POINTER(callRecord); + CHECK_POINTER(connect); + CHECK_POINTER(connect->AsObject()); + + auto iter = callRecordMap_.find(connect->AsObject()); + if (iter != callRecordMap_.end()) { + RemoveConnectDeathRecipient(connect); + callRecordMap_.erase(callRecordMap_.find(connect->AsObject())); + } + + AddConnectDeathRecipient(connect); + callRecord->SetConCallBack(connect); + callRecordMap_.emplace(connect->AsObject(), callRecord); + + HILOG_DEBUG("Add call record to callcontainer, target: %{public}s", + callRecord->GetTargetServiceName().GetURI().c_str()); +} + +std::shared_ptr CallContainer::GetCallRecord(const sptr & connect) const +{ + CHECK_POINTER_AND_RETURN(connect, nullptr); + CHECK_POINTER_AND_RETURN(connect->AsObject(), nullptr); + + auto mapIter = callRecordMap_.find(connect->AsObject()); + if (mapIter != callRecordMap_.end()) { + return mapIter->second; + } + + return nullptr; +} + +bool CallContainer::RemoveCallRecord(const sptr & connect) +{ + HILOG_DEBUG("call container release call record by callback."); + CHECK_POINTER_AND_RETURN(connect, nullptr); + CHECK_POINTER_AND_RETURN(connect->AsObject(), nullptr); + + auto iter = callRecordMap_.find(connect->AsObject()); + if (iter != callRecordMap_.end()) { + auto callrecord = iter->second; + if (callrecord) { + callrecord->SchedulerDisConnectDone(); + } + RemoveConnectDeathRecipient(connect); + callRecordMap_.erase(callRecordMap_.find(connect->AsObject())); + HILOG_DEBUG("remove call record is success."); + return true; + } + + if (callRecordMap_.empty()) { + // notify soft resouce service. + HILOG_DEBUG("this ability has no callrecord."); + } + + HILOG_WARN("remove call record is not exist."); + return false; +} + +void CallContainer::OnConnectionDied(const wptr & remote) +{ + HILOG_WARN("Call back is died."); + auto object = remote.promote(); + CHECK_POINTER(object); + + std::shared_ptr callRecord = nullptr; + auto mapIter = callRecordMap_.find(object); + if (mapIter != callRecordMap_.end()) { + callRecord = mapIter->second; + } + + auto abilityManagerService = DelayedSingleton::GetInstance(); + CHECK_POINTER(abilityManagerService); + auto handler = abilityManagerService->GetEventHandler(); + CHECK_POINTER(handler); + auto task = [abilityManagerService, callRecord]() { + abilityManagerService->OnCallConnectDied(callRecord); + }; + handler->PostTask(task); +} + +bool CallContainer::CallRequestDone(const sptr & callStub) +{ + HILOG_INFO("Call Request Done start."); + + CHECK_POINTER_AND_RETURN(callStub, false); + + std::for_each(callRecordMap_.begin(), + callRecordMap_.end(), + [&callStub](CallMapType::reference service) { + std::shared_ptr callRecord = service.second; + if (callRecord && callRecord->IsCallState(CallState::REQUESTING)) { + callRecord->SetCallStub(callStub); + callRecord->SchedulerConnectDone(); + } + }); + + HILOG_INFO("Call Request Done end."); + return true; +} + +void CallContainer::Dump(std::vector &info) const +{ + HILOG_INFO("Dump call records."); + for (auto &iter : callRecordMap_) { + auto callRecord = iter.second; + if (callRecord) { + callRecord->Dump(info); + } + } +} + +bool CallContainer::IsNeedToCallRequest() const +{ + for (auto &iter : callRecordMap_) { + auto callRecord = iter.second; + if (callRecord && !callRecord->IsCallState(CallState::REQUESTED)) { + return true; + } + } + return false; +} + +void CallContainer::AddConnectDeathRecipient(const sptr &connect) +{ + CHECK_POINTER(connect); + CHECK_POINTER(connect->AsObject()); + auto it = deathRecipientMap_.find(connect->AsObject()); + if (it != deathRecipientMap_.end()) { + HILOG_ERROR("This death recipient has been added."); + return; + } else { + sptr deathRecipient = new AbilityConnectCallbackRecipient( + std::bind(&CallContainer::OnConnectionDied, this, std::placeholders::_1)); + connect->AsObject()->AddDeathRecipient(deathRecipient); + deathRecipientMap_.emplace(connect->AsObject(), deathRecipient); + } +} + +void CallContainer::RemoveConnectDeathRecipient(const sptr &connect) +{ + CHECK_POINTER(connect); + CHECK_POINTER(connect->AsObject()); + auto it = deathRecipientMap_.find(connect->AsObject()); + if (it != deathRecipientMap_.end()) { + it->first->RemoveDeathRecipient(it->second); + deathRecipientMap_.erase(it); + return; + } +} +} // namespace AAFwk +} // namesspace OHOS diff --git a/services/abilitymgr/src/call_record.cpp b/services/abilitymgr/src/call_record.cpp index 59098ac815b..c4f7ca30979 100644 --- a/services/abilitymgr/src/call_record.cpp +++ b/services/abilitymgr/src/call_record.cpp @@ -1,181 +1,199 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "call_record.h" - -#include "hilog_wrapper.h" -#include "ability_util.h" -#include "ability_event_handler.h" -#include "ability_manager_service.h" -#include "ability_record.h" -#include "element_name.h" - -namespace OHOS { -namespace AAFwk { -int64_t CallRecord::callRecordId = 0; - -CallRecord::CallRecord(const int32_t callerUid, const std::shared_ptr &targetService, - const sptr &connCallback, const sptr &callToken) - : callerUid_(callerUid), - state_(CallState::INIT), - service_(targetService), - connCallback_(connCallback), - callerToken_(callToken) -{ - recordId_ = callRecordId++; - startTime_ = AbilityUtil::SystemTimeMillis(); -} - -CallRecord::~CallRecord() -{ - if (callRemoteObject_ && callDeathRecipient_) { - callRemoteObject_->RemoveDeathRecipient(callDeathRecipient_); - } -} - -std::shared_ptr CallRecord::CreateCallRecord(const int32_t callerUid, - const std::shared_ptr &targetService, const sptr &connCallback, - const sptr &callToken) -{ - auto callRecord = std::make_shared(callerUid, targetService, connCallback, callToken); - CHECK_POINTER_AND_RETURN(callRecord, nullptr); - callRecord->SetCallState(CallState::INIT); - return callRecord; -} - -void CallRecord::SetCallStub(const sptr & call) -{ - CHECK_POINTER(call); - - callRemoteObject_ = call; - - HILOG_DEBUG("SetCallStub complete."); - - if (callDeathRecipient_ == nullptr) { - callDeathRecipient_ = - new AbilityCallRecipient(std::bind(&CallRecord::OnCallStubDied, this, std::placeholders::_1)); - } - - callRemoteObject_->AddDeathRecipient(callDeathRecipient_); -} - -sptr CallRecord::GetCallStub() -{ - return callRemoteObject_; -} - -void CallRecord::SetConCallBack(const sptr &connCallback) -{ - connCallback_ = connCallback; -} - -sptr CallRecord::GetConCallBack() const -{ - return connCallback_; -} - -AppExecFwk::ElementName CallRecord::GetTargetServiceName() const -{ - std::shared_ptr tmpService = service_.lock(); - if (tmpService) { - const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); - AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); - return element; - } - return AppExecFwk::ElementName(); -} - -sptr CallRecord::GetCallerToken() const -{ - return callerToken_; -} - -bool CallRecord::SchedulerConnectDone() -{ - HILOG_DEBUG("Scheduler Connect Done by callback. id:%{public}d", recordId_); - std::shared_ptr tmpService = service_.lock(); - if (!callRemoteObject_ || !connCallback_ || !tmpService) { - HILOG_ERROR("callstub or connCallback is nullptr, can't scheduler connect done."); - return false; - } - - const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); - AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); - connCallback_->OnAbilityConnectDone(element, callRemoteObject_, ERR_OK); - state_ = CallState::REQUESTED; - - HILOG_DEBUG("element: %{public}s, result: %{public}d. connectstate:%{public}d.", element.GetURI().c_str(), - ERR_OK, state_); - return true; -} - -bool CallRecord::SchedulerDisConnectDone() -{ - HILOG_DEBUG("Scheduler disconnect Done by callback. id:%{public}d", recordId_); - std::shared_ptr tmpService = service_.lock(); - if (!connCallback_ || !tmpService) { - HILOG_ERROR("callstub or connCallback is nullptr, can't scheduler connect done."); - return false; - } - - const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); - AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); - connCallback_->OnAbilityDisconnectDone(element, ERR_OK); - - return true; -} - -void CallRecord::OnCallStubDied(const wptr & remote) -{ - HILOG_WARN("callstub is died. id:%{public}d", recordId_); - auto object = remote.promote(); - CHECK_POINTER(object); - - auto abilityManagerService = DelayedSingleton::GetInstance(); - CHECK_POINTER(abilityManagerService); - auto handler = abilityManagerService->GetEventHandler(); - CHECK_POINTER(handler); - auto task = [abilityManagerService, callRecord = shared_from_this()]() { - abilityManagerService->OnCallConnectDied(callRecord); - }; - handler->PostTask(task); -} - -void CallRecord::Dump(std::vector &info) const -{ - HILOG_DEBUG("CallRecord::Dump is called"); -} - -int32_t CallRecord::GetCallerUid() const -{ - return callerUid_; -} - -bool CallRecord::IsCallState(const CallState& state) const -{ - return (state_ == state); -} - -void CallRecord::SetCallState(const CallState& state) -{ - state_ = state; -} - -int CallRecord::GetCallRecordId() const -{ - return recordId_; -} -} // namespace AAFwk +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "call_record.h" + +#include "hilog_wrapper.h" +#include "ability_util.h" +#include "ability_event_handler.h" +#include "ability_manager_service.h" +#include "ability_record.h" +#include "element_name.h" + +namespace OHOS { +namespace AAFwk { +int64_t CallRecord::callRecordId = 0; + +CallRecord::CallRecord(const int32_t callerUid, const std::shared_ptr &targetService, + const sptr &connCallback, const sptr &callToken) + : callerUid_(callerUid), + state_(CallState::INIT), + service_(targetService), + connCallback_(connCallback), + callerToken_(callToken) +{ + recordId_ = callRecordId++; + startTime_ = AbilityUtil::SystemTimeMillis(); +} + +CallRecord::~CallRecord() +{ + if (callRemoteObject_ && callDeathRecipient_) { + callRemoteObject_->RemoveDeathRecipient(callDeathRecipient_); + } +} + +std::shared_ptr CallRecord::CreateCallRecord(const int32_t callerUid, + const std::shared_ptr &targetService, const sptr &connCallback, + const sptr &callToken) +{ + auto callRecord = std::make_shared(callerUid, targetService, connCallback, callToken); + CHECK_POINTER_AND_RETURN(callRecord, nullptr); + callRecord->SetCallState(CallState::INIT); + return callRecord; +} + +void CallRecord::SetCallStub(const sptr & call) +{ + CHECK_POINTER(call); + + callRemoteObject_ = call; + + HILOG_DEBUG("SetCallStub complete."); + + if (callDeathRecipient_ == nullptr) { + callDeathRecipient_ = + new AbilityCallRecipient(std::bind(&CallRecord::OnCallStubDied, this, std::placeholders::_1)); + } + + callRemoteObject_->AddDeathRecipient(callDeathRecipient_); +} + +sptr CallRecord::GetCallStub() +{ + return callRemoteObject_; +} + +void CallRecord::SetConCallBack(const sptr &connCallback) +{ + connCallback_ = connCallback; +} + +sptr CallRecord::GetConCallBack() const +{ + return connCallback_; +} + +AppExecFwk::ElementName CallRecord::GetTargetServiceName() const +{ + std::shared_ptr tmpService = service_.lock(); + if (tmpService) { + const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); + AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); + return element; + } + return AppExecFwk::ElementName(); +} + +sptr CallRecord::GetCallerToken() const +{ + return callerToken_; +} + +bool CallRecord::SchedulerConnectDone() +{ + HILOG_DEBUG("Scheduler Connect Done by callback. id:%{public}d", recordId_); + std::shared_ptr tmpService = service_.lock(); + if (!callRemoteObject_ || !connCallback_ || !tmpService) { + HILOG_ERROR("callstub or connCallback is nullptr, can't scheduler connect done."); + return false; + } + + const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); + AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); + connCallback_->OnAbilityConnectDone(element, callRemoteObject_, ERR_OK); + state_ = CallState::REQUESTED; + + HILOG_DEBUG("element: %{public}s, result: %{public}d. connectstate:%{public}d.", element.GetURI().c_str(), + ERR_OK, state_); + return true; +} + +bool CallRecord::SchedulerDisConnectDone() +{ + HILOG_DEBUG("Scheduler disconnect Done by callback. id:%{public}d", recordId_); + std::shared_ptr tmpService = service_.lock(); + if (!connCallback_ || !tmpService) { + HILOG_ERROR("callstub or connCallback is nullptr, can't scheduler connect done."); + return false; + } + + const AppExecFwk::AbilityInfo &abilityInfo = tmpService->GetAbilityInfo(); + AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name); + connCallback_->OnAbilityDisconnectDone(element, ERR_OK); + + return true; +} + +void CallRecord::OnCallStubDied(const wptr & remote) +{ + HILOG_WARN("callstub is died. id:%{public}d", recordId_); + auto object = remote.promote(); + CHECK_POINTER(object); + + auto abilityManagerService = DelayedSingleton::GetInstance(); + CHECK_POINTER(abilityManagerService); + auto handler = abilityManagerService->GetEventHandler(); + CHECK_POINTER(handler); + auto task = [abilityManagerService, callRecord = shared_from_this()]() { + abilityManagerService->OnCallConnectDied(callRecord); + }; + handler->PostTask(task); +} + +void CallRecord::Dump(std::vector &info) const +{ + HILOG_DEBUG("CallRecord::Dump is called"); + + std::string tempstr = " CallRecord"; + tempstr += " ID #" + std::to_string (recordId_) + "\n"; + tempstr += " caller"; + auto abilityRecord = Token::GetAbilityRecordByToken(callerToken_); + if (abilityRecord) { + AppExecFwk::ElementName element( + abilityRecord->GetAbilityInfo().deviceId, abilityRecord->GetAbilityInfo().bundleName, + abilityRecord->GetAbilityInfo().name); + tempstr += " uri [" + element.GetURI() + "]" + "\n"; + } + + std::string state = (state_ == CallState::INIT ? "INIT" : + state_ == CallState::REQUESTING ? "REQUESTING" : "REQUESTED"); + tempstr += " state #" + state; + tempstr += " start time [" + std::to_string (startTime_) + "]"; + info.emplace_back(tempstr); + HILOG_DEBUG("CallRecord::Dump is called1"); +} + +int32_t CallRecord::GetCallerUid() const +{ + return callerUid_; +} + +bool CallRecord::IsCallState(const CallState& state) const +{ + return (state_ == state); +} + +void CallRecord::SetCallState(const CallState& state) +{ + state_ = state; +} + +int CallRecord::GetCallRecordId() const +{ + return recordId_; +} +} // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/services/abilitymgr/src/data_ability_manager.cpp b/services/abilitymgr/src/data_ability_manager.cpp index 898e3847432..1e4128d9793 100644 --- a/services/abilitymgr/src/data_ability_manager.cpp +++ b/services/abilitymgr/src/data_ability_manager.cpp @@ -495,6 +495,48 @@ void DataAbilityManager::DumpState(std::vector &info, const std::st return; } +void DataAbilityManager::DumpSysState(std::vector &info, bool isClient, const std::string &args) const +{ + if (!args.empty()) { + auto it = std::find_if(dataAbilityRecordsLoaded_.begin(), + dataAbilityRecordsLoaded_.end(), + [&args](const auto &dataAbilityRecord) { return dataAbilityRecord.first.compare(args) == 0; }); + if (it != dataAbilityRecordsLoaded_.end()) { + info.emplace_back("AbilityName [ " + it->first + " ]"); + it->second->Dump(info); + // add dump client info + if (isClient && it->second->GetScheduler() && it->second->GetAbilityRecord()->IsReady()) { + std::vector params; + it->second->GetScheduler()->DumpAbilityInfo(params, info); + AppExecFwk::Configuration config; + if (DelayedSingleton::GetInstance()->GetConfiguration(config) == ERR_OK) { + info.emplace_back(" configuration: " + config.GetName()); + } + } + } else { + info.emplace_back(args + ": Nothing to dump."); + } + } else { + info.emplace_back(" dataAbilityRecords:"); + for (auto &&dataAbilityRecord : dataAbilityRecordsLoaded_) { + info.emplace_back(" uri [" + dataAbilityRecord.first + "]"); + dataAbilityRecord.second->Dump(info); + dataAbilityRecord.second->GetScheduler(); + // add dump client info + if (isClient && dataAbilityRecord.second->GetScheduler() + && dataAbilityRecord.second->GetAbilityRecord()->IsReady()) { + std::vector params; + dataAbilityRecord.second->GetScheduler()->DumpAbilityInfo(params, info); + AppExecFwk::Configuration config; + if (DelayedSingleton::GetInstance()->GetConfiguration(config) == ERR_OK) { + info.emplace_back(" configuration: " + config.GetName()); + } + } + } + } + return; +} + void DataAbilityManager::GetAbilityRunningInfos(std::vector &info) { HILOG_INFO("Get ability running infos"); diff --git a/services/abilitymgr/src/kernal_ability_manager.cpp b/services/abilitymgr/src/kernal_ability_manager.cpp index 1667b8db46f..b7e65d4c93a 100644 --- a/services/abilitymgr/src/kernal_ability_manager.cpp +++ b/services/abilitymgr/src/kernal_ability_manager.cpp @@ -306,6 +306,14 @@ void KernalAbilityManager::DumpState(std::vector &info) } } +void KernalAbilityManager::DumpSysState(std::vector& info, bool isClient) +{ + info.emplace_back("SystemUIRecords:"); + for (auto &ability : abilities_) { + ability->DumpSys(info, isClient); + } +} + void KernalAbilityManager::OnAbilityDied(std::shared_ptr abilityRecord) { std::lock_guard guard(stackLock_); diff --git a/services/abilitymgr/src/kernal_system_app_manager.cpp b/services/abilitymgr/src/kernal_system_app_manager.cpp index a785eb6aca9..bf60d6d38db 100644 --- a/services/abilitymgr/src/kernal_system_app_manager.cpp +++ b/services/abilitymgr/src/kernal_system_app_manager.cpp @@ -321,6 +321,13 @@ void KernalSystemAppManager::DumpState(std::vector &info) ability->Dump(info); } } +void KernalSystemAppManager::DumpSysState(std::vector &info, bool isClient) +{ + info.emplace_back("SystemUIRecords:"); + for (auto &ability : abilities_) { + ability->DumpSys(info, isClient); + } +} void KernalSystemAppManager::OnAbilityDied(std::shared_ptr abilityRecord) { diff --git a/services/abilitymgr/src/mission_list.cpp b/services/abilitymgr/src/mission_list.cpp index 24e621a6808..3771dc7c029 100644 --- a/services/abilitymgr/src/mission_list.cpp +++ b/services/abilitymgr/src/mission_list.cpp @@ -239,7 +239,7 @@ std::string MissionList::GetTypeName() return "NORMAL"; } case MissionListType::DEFAULT_STANDARD: { - return "DEFAULT_STAND"; + return "DEFAULT_STANDARD"; } case MissionListType::DEFAULT_SINGLE: { return "DEFAULT_SINGLE"; @@ -282,12 +282,12 @@ void MissionList::DumpStateByRecordId( } void MissionList::DumpList(std::vector &info, bool isClient) { - std::string dumpInfo = " MissionList Type #" + GetTypeName(); + std::string dumpInfo = " MissionList Type #" + GetTypeName(); info.push_back(dumpInfo); for (const auto& mission : missions_) { if (mission) { - dumpInfo = " Mission ID #" + std::to_string(mission->GetMissionId()); + dumpInfo = " Mission ID #" + std::to_string(mission->GetMissionId()); dumpInfo += " mission name #[" + mission->GetMissionName() + "]" + " lockedState #" + std::to_string(mission->IsLockedState()); info.push_back(dumpInfo); diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index 22c15e65d9c..4d793d13ee5 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -592,6 +592,63 @@ void MissionListManager::OnAbilityRequestDone(const sptr &token, } } +void MissionListManager::OnAppStateChanged(const AppInfo &info) +{ + std::lock_guard guard(managerLock_); + + if (info.state == AppState::TERMINATED || info.state == AppState::END) { + for (const auto& abilityRecord : terminateAbilityList_) { + if (!abilityRecord) { + HILOG_ERROR("abilityRecord is nullptr."); + continue; + } + if (info.processName == abilityRecord->GetAbilityInfo().process || + info.processName == abilityRecord->GetApplicationInfo().bundleName) { + abilityRecord->SetAppState(info.state); + } + } + } else { + for (const auto& missionList : currentMissionLists_) { + auto missions = missionList->GetAllMissions(); + for (const auto& missionInfo : missions) { + if (!missionInfo) { + HILOG_ERROR("missionInfo is nullptr."); + continue; + } + auto abilityRecord = missionInfo->GetAbilityRecord(); + if (info.processName == abilityRecord->GetAbilityInfo().process || + info.processName == abilityRecord->GetApplicationInfo().bundleName) { + abilityRecord->SetAppState(info.state); + } + } + } + auto defaultStandardListmissions = defaultStandardList_->GetAllMissions(); + for (const auto& missionInfo : defaultStandardListmissions) { + if (!missionInfo) { + HILOG_ERROR("defaultStandardListmissions is nullptr."); + continue; + } + auto abilityRecord = missionInfo->GetAbilityRecord(); + if (info.processName == abilityRecord->GetAbilityInfo().process || + info.processName == abilityRecord->GetApplicationInfo().bundleName) { + abilityRecord->SetAppState(info.state); + } + } + auto defaultSingleListmissions = defaultSingleList_->GetAllMissions(); + for (const auto& missionInfo : defaultSingleListmissions) { + if (!missionInfo) { + HILOG_ERROR("defaultSingleListmissions is nullptr."); + continue; + } + auto abilityRecord = missionInfo->GetAbilityRecord(); + if (info.processName == abilityRecord->GetAbilityInfo().process || + info.processName == abilityRecord->GetApplicationInfo().bundleName) { + abilityRecord->SetAppState(info.state); + } + } + } +} + std::shared_ptr MissionListManager::GetAbilityRecordByToken( const sptr &token) const { @@ -1609,47 +1666,49 @@ void MissionListManager::DumpMissionListByRecordId( void MissionListManager::DumpMissionList(std::vector &info, bool isClient, const std::string &args) { std::lock_guard guard(managerLock_); + + if (args.size() != 0 && + args != "NORMAL" && + args != "DEFAULT_STANDARD" && + args != "DEFAULT_SINGLE" && + args != "LAUNCHER") { + info.emplace_back("MissionList Type NORMAL|DEFAULT_STANDARD|DEFAULT_SINGLE|LAUNCHER"); + return; + } + std::string dumpInfo = "User ID #" + std::to_string(userId_); info.push_back(dumpInfo); if (args.size() == 0 || args == "NORMAL") { - dumpInfo = " current mission lists:{"; + dumpInfo = " Current mission lists:"; info.push_back(dumpInfo); for (const auto& missionList : currentMissionLists_) { if (missionList) { missionList->DumpList(info, isClient); } } - dumpInfo = " }"; - info.push_back(dumpInfo); } if (args.size() == 0 || args == "DEFAULT_STANDARD") { - dumpInfo = " default stand mission list:{"; + dumpInfo = " default stand mission list:"; info.push_back(dumpInfo); if (defaultStandardList_) { defaultStandardList_->DumpList(info, isClient); } - dumpInfo = " }"; - info.push_back(dumpInfo); } if (args.size() == 0 || args == "DEFAULT_SINGLE") { - dumpInfo = " default single mission list:{"; + dumpInfo = " default single mission list:"; info.push_back(dumpInfo); if (defaultSingleList_) { defaultSingleList_->DumpList(info, isClient); } - dumpInfo = " }"; - info.push_back(dumpInfo); } if (args.size() == 0 || args == "LAUNCHER") { - dumpInfo = " launcher mission list:{"; + dumpInfo = " launcher mission list:"; info.push_back(dumpInfo); if (launcherList_) { launcherList_->DumpList(info, isClient); } - dumpInfo = " }"; - info.push_back(dumpInfo); } } diff --git a/services/abilitymgr/src/pending_want_manager.cpp b/services/abilitymgr/src/pending_want_manager.cpp index 22f19601b8c..53cde92bfb7 100644 --- a/services/abilitymgr/src/pending_want_manager.cpp +++ b/services/abilitymgr/src/pending_want_manager.cpp @@ -524,7 +524,7 @@ void PendingWantManager::Dump(std::vector &info) for (const auto &item : wantRecords_) { const auto &pendingKey = item.first; - dumpInfo = " PendWantRecord ID #" + std::to_string(pendingKey->GetUserId()) + + dumpInfo = " PendWantRecord ID #" + std::to_string(pendingKey->GetCode()) + " type #" + std::to_string(pendingKey->GetType()); info.push_back(dumpInfo); dumpInfo = " bundle name [" + pendingKey->GetBundleName() + "]"; @@ -548,5 +548,38 @@ void PendingWantManager::Dump(std::vector &info) } } } +void PendingWantManager::DumpByRecordId(std::vector &info, const std::string &args) +{ + std::string dumpInfo = " PendingWantRecords:"; + info.push_back(dumpInfo); + + for (const auto &item : wantRecords_) { + const auto &pendingKey = item.first; + if (args == std::to_string(pendingKey->GetCode())) { + dumpInfo = " PendWantRecord ID #" + std::to_string(pendingKey->GetCode()) + + " type #" + std::to_string(pendingKey->GetType()); + info.push_back(dumpInfo); + dumpInfo = " bundle name [" + pendingKey->GetBundleName() + "]"; + info.push_back(dumpInfo); + dumpInfo = " result who [" + pendingKey->GetRequestWho() + "]"; + info.push_back(dumpInfo); + dumpInfo = " request code #" + std::to_string(pendingKey->GetRequestCode()) + + " flags #" + std::to_string(pendingKey->GetFlags()); + info.push_back(dumpInfo); + dumpInfo = " resolved type [" + pendingKey->GetRequestResolvedType() + "]"; + info.push_back(dumpInfo); + dumpInfo = " Wants:"; + info.push_back(dumpInfo); + auto Wants = pendingKey->GetAllWantsInfos(); + for (const auto& Want : Wants) { + dumpInfo = " uri [" + Want.want.GetElement().GetDeviceID() + "//" + + Want.want.GetElement().GetBundleName() + "/" + Want.want.GetElement().GetAbilityName() + "]"; + info.push_back(dumpInfo); + dumpInfo = " resolved types [" + Want.resolvedTypes + "]"; + info.push_back(dumpInfo); + } + } + } +} } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h index 61bc3ac8ea0..b29bb10bcec 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h +++ b/services/abilitymgr/test/unittest/phone/ability_manager_proxy_test/ability_manager_stub_mock.h @@ -375,9 +375,9 @@ public: return true; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr &callerToken, int requestCode)); diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h index 224a3dfc6e7..970bd387adb 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h +++ b/services/abilitymgr/test/unittest/phone/ability_manager_stub_test/ability_manager_stub_impl_mock.h @@ -426,9 +426,9 @@ public: { return true; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } virtual int StartUserTest(const Want &want, const sptr &observer) override diff --git a/services/formmgr/test/mock/include/mock_ability_manager.h b/services/formmgr/test/mock/include/mock_ability_manager.h index d109939e55c..6edb24db9cc 100644 --- a/services/formmgr/test/mock/include/mock_ability_manager.h +++ b/services/formmgr/test/mock/include/mock_ability_manager.h @@ -865,9 +865,9 @@ public: { return 0; } - virtual bool SendANRProcessID(int pid) + virtual int SendANRProcessID(int pid) { - return true; + return 0; } virtual int StartAbilityByCall( const Want &want, const sptr &connect, const sptr &callerToken) override diff --git a/services/test/mock/include/mock_ability_mgr_service.h b/services/test/mock/include/mock_ability_mgr_service.h index d16763d5304..4a7448c6c71 100644 --- a/services/test/mock/include/mock_ability_mgr_service.h +++ b/services/test/mock/include/mock_ability_mgr_service.h @@ -192,9 +192,9 @@ public: return true; } - virtual bool SendANRProcessID(int pid) override + virtual int SendANRProcessID(int pid) override { - return true; + return 0; } virtual int StartUserTest(const Want &want, const sptr &observer) override diff --git a/tools/aa/include/ability_command.h b/tools/aa/include/ability_command.h index 7fde0445cb4..2a0fa63bf6a 100644 --- a/tools/aa/include/ability_command.h +++ b/tools/aa/include/ability_command.h @@ -29,8 +29,7 @@ const std::string HELP_MSG = "usage: aa \n" " help list available commands\n" " start start ability with options\n" " stop-service stop service with options\n" - " dump dump the ability stack info\n" - " dumpsys dump the ability info\n" + " dump dump the ability info\n" " force-stop force stop the process with bundle name\n" " test start the test framework with options\n"; @@ -63,17 +62,24 @@ const std::string HELP_MSG_DUMP = "usage: aa dump \n" " -e, --serv dump the service abilities\n" " -d, --data dump the data abilities\n"; -const std::string HELP_MSG_DUMPSYS = "usage: aa dumpsys \n" +const std::string HELP_MSG_DUMPSYS = "usage: aa dump \n" "options list:\n" " -h, --help list available commands\n" " -a, --all dump all abilities\n" " -l, --mission-list dump mission list\n" " -i, --ability dump abilityRecordId\n" - " -e, --extension dump elementName\n" + " -e, --extension dump elementName (API7 ExtensionRecords," + "API8 serviceAbilityRecords)\n" " -p, --pending dump pendingWantRecordId\n" " -r, --process dump process\n" + " -d, --data dump the data abilities\n" + " -k, --ui dump the kenarl ability list ui stack\n" " -u, --userId userId\n" - " -c, --client client\n"; + " -c, --client client\n" + " -c, -u are auxiliary parameters and cannot be used alone\n" + " The original -s parameter is invalid\n" + " The original -m parameter is invalid\n"; + const std::string HELP_MSG_TEST = "usage: aa test \n" @@ -133,8 +139,6 @@ private: ErrCode RunAsDumpCommandOptopt(); ErrCode MakeWantFromCmd(Want &want, std::string &windowMode); - ErrCode RunAsDumpSysCommandOptopt(); - ErrCode RunAsTestCommand(); bool IsTestCommandIntegrity(const std::map ¶ms); ErrCode TestCommandError(const std::string &info); diff --git a/tools/aa/src/ability_command.cpp b/tools/aa/src/ability_command.cpp index c95050bd1d0..849f595f4c4 100644 --- a/tools/aa/src/ability_command.cpp +++ b/tools/aa/src/ability_command.cpp @@ -53,7 +53,7 @@ const struct option LONG_OPTIONS_DUMP[] = { {"mission-infos", no_argument, nullptr, 'S'}, {nullptr, 0, nullptr, 0}, }; -const std::string SHORT_OPTIONS_DUMPSYS = "hal::i:e::p::r::u:c"; +const std::string SHORT_OPTIONS_DUMPSYS = "hal::i:e::p::r::kd::u:c"; const struct option LONG_OPTIONS_DUMPSYS[] = { {"help", no_argument, nullptr, 'h'}, {"all", no_argument, nullptr, 'a'}, @@ -62,6 +62,8 @@ const struct option LONG_OPTIONS_DUMPSYS[] = { {"extension", no_argument, nullptr, 'e'}, {"pending", no_argument, nullptr, 'p'}, {"process", no_argument, nullptr, 'r'}, + {"data", no_argument, nullptr, 'd'}, + {"ui", no_argument, nullptr, 'k'}, {"userId", required_argument, nullptr, 'u'}, {"client", no_argument, nullptr, 'c'}, {nullptr, 0, nullptr, 0}, @@ -82,8 +84,7 @@ ErrCode AbilityManagerShellCommand::CreateCommandMap() {"screen", std::bind(&AbilityManagerShellCommand::RunAsScreenCommand, this)}, {"start", std::bind(&AbilityManagerShellCommand::RunAsStartAbility, this)}, {"stop-service", std::bind(&AbilityManagerShellCommand::RunAsStopService, this)}, - {"dump", std::bind(&AbilityManagerShellCommand::RunAsDumpCommand, this)}, - {"dumpsys", std::bind(&AbilityManagerShellCommand::RunAsDumpsysCommand, this)}, + {"dump", std::bind(&AbilityManagerShellCommand::RunAsDumpsysCommand, this)}, {"force-stop", std::bind(&AbilityManagerShellCommand::RunAsForceStop, this)}, {"test", std::bind(&AbilityManagerShellCommand::RunAsTestCommand, this)}, }; @@ -626,7 +627,7 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() break; } case 'l': { - if (isfirstCommand == false) { + if (isfirstCommand == false && optarg == nullptr) { isfirstCommand = true; } else { // 'aa dumpsys -i 10 -element -lastpage' @@ -664,7 +665,7 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() break; } case 'e': { - if (isfirstCommand == false) { + if (isfirstCommand == false && optarg == nullptr) { isfirstCommand = true; } else { // 'aa dumpsys -i 10 -element' @@ -679,7 +680,7 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() break; } case 'p': { - if (isfirstCommand == false) { + if (isfirstCommand == false && optarg == nullptr) { isfirstCommand = true; } else { result = OHOS::ERR_INVALID_VALUE; @@ -691,7 +692,7 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() break; } case 'r': { - if (isfirstCommand == false) { + if (isfirstCommand == false && optarg == nullptr) { isfirstCommand = true; } else { // 'aa dumpsys -i 10 -render' @@ -705,6 +706,36 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() // 'aa dumpsys --process' break; } + case 'd': { + if (isfirstCommand == false && optarg == nullptr) { + isfirstCommand = true; + } else { + result = OHOS::ERR_INVALID_VALUE; + resultReceiver_.append(HELP_MSG_DUMPSYS); + return result; + } + // 'aa dumpsys -d' + // 'aa dumpsys --data' + break; + } + case 'k': { + if (isfirstCommand == false) { + isfirstCommand = true; + if (isUserID == true) { + result = OHOS::ERR_INVALID_VALUE; + resultReceiver_.append("-k is no userID option\n"); + resultReceiver_.append(HELP_MSG_DUMPSYS); + return result; + } + } else { + result = OHOS::ERR_INVALID_VALUE; + resultReceiver_.append(HELP_MSG_DUMPSYS); + return result; + } + // 'aa dumpsys -k' + // 'aa dumpsys --UI' + break; + } case 'u': { // 'aa dumpsys -u' // 'aa dumpsys --userId' @@ -740,6 +771,7 @@ ErrCode AbilityManagerShellCommand::RunAsDumpsysCommand() } else { if (isfirstCommand != true) { result = OHOS::ERR_INVALID_VALUE; + resultReceiver_.append(HELP_MSG_NO_OPTION); resultReceiver_.append(HELP_MSG_DUMPSYS); return result; } diff --git a/tools/test/mock/mock_ability_manager_stub.h b/tools/test/mock/mock_ability_manager_stub.h index 10a5692a201..68c86d0e0d5 100644 --- a/tools/test/mock/mock_ability_manager_stub.h +++ b/tools/test/mock/mock_ability_manager_stub.h @@ -207,9 +207,9 @@ public: { return 0; } - virtual bool SendANRProcessID(int pid) + virtual int SendANRProcessID(int pid) { - return true; + return 0; } virtual int SetAbilityController(const sptr &abilityController, bool imAStabilityTest) override -- Gitee