From 461f704c0365ccdee8d9340a73d332f3df1e1052 Mon Sep 17 00:00:00 2001 From: zhaoyrr Date: Thu, 7 Aug 2025 15:52:48 +0800 Subject: [PATCH 1/5] =?UTF-8?q?=E5=91=8A=E8=AD=A6=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhaoyrr --- frameworks/native/runtime/js_worker.cpp | 3 ++ .../abilitymgr/src/pending_want_record.cpp | 5 ++- .../ui_ability_lifecycle_manager.cpp | 2 +- services/common/include/hilog_tag_wrapper.h | 3 ++ .../pending_want_record_test.cpp | 26 +++++++++++++ test/unittest/runtime_test/js_worker_test.cpp | 39 +++++++++++++++++++ 6 files changed, 76 insertions(+), 2 deletions(-) diff --git a/frameworks/native/runtime/js_worker.cpp b/frameworks/native/runtime/js_worker.cpp index 97153c4636a..f755382bd5d 100644 --- a/frameworks/native/runtime/js_worker.cpp +++ b/frameworks/native/runtime/js_worker.cpp @@ -395,6 +395,9 @@ bool AssetHelper::ReadFilePathData(const std::string& filePath, uint8_t** buff, std::string newHapPath; size_t pos = filePath.find('/'); + if (pos == std::string::npos) { + return false; + } if (!GetIsStageModel()) { newHapPath = (workerInfo_->hapPath).GetOriginString(); } else { diff --git a/services/abilitymgr/src/pending_want_record.cpp b/services/abilitymgr/src/pending_want_record.cpp index dbdf53c834b..941a3f0b798 100644 --- a/services/abilitymgr/src/pending_want_record.cpp +++ b/services/abilitymgr/src/pending_want_record.cpp @@ -118,7 +118,10 @@ int32_t PendingWantRecord::ExecuteOperation( senderInfo.callerToken, -1, callerUid_, callerTokenId_); break; case static_cast(OperationType::START_ABILITIES): { - std::vector allWantsInfos = key_->GetAllWantsInfos(); + std::vector allWantsInfos; + if (allWantsInfos.size() == 0) { + return ERR_INVALID_VALUE; + } allWantsInfos.back().want = want; res = pendingWantManager->PendingWantStartAbilitys( allWantsInfos, senderInfo.startOptions, senderInfo.callerToken, -1, callerUid_, callerTokenId_); diff --git a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp index 0ba5efd9120..1d2c358422b 100644 --- a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp +++ b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp @@ -1871,7 +1871,7 @@ int32_t UIAbilityLifecycleManager::BackToCallerAbilityWithResultLocked(sptrwant.GetBundle(); std::string currentName = callerAbilityRecord->GetApplicationInfo().bundleName; - EventInfo eventInfo = { .callerBundleName = callerBundleName, .bundleName = currentName, .uri = "backToCaller"}; + EventInfo eventInfo = { .bundleName = currentName, .callerBundleName = callerBundleName, .uri = "backToCaller"}; EventReport::SendGrantUriPermissionEvent(EventName::GRANT_URI_PERMISSION, eventInfo); auto currentSession = iface_cast(currentSessionInfo->sessionToken); diff --git a/services/common/include/hilog_tag_wrapper.h b/services/common/include/hilog_tag_wrapper.h index 5aaa6001aa8..391b3e70252 100644 --- a/services/common/include/hilog_tag_wrapper.h +++ b/services/common/include/hilog_tag_wrapper.h @@ -106,6 +106,9 @@ enum class AAFwkLogTag : uint32_t { inline uint32_t GetOffset(AAFwkLogTag tag, AAFwkLogTag base) { + if (static_cast(tag) <= static_cast(base)) { + return 0; + } return static_cast(tag) - static_cast(base); } diff --git a/test/unittest/pending_want_record_test/pending_want_record_test.cpp b/test/unittest/pending_want_record_test/pending_want_record_test.cpp index 918d97cff3f..dfdf8fee8cc 100644 --- a/test/unittest/pending_want_record_test/pending_want_record_test.cpp +++ b/test/unittest/pending_want_record_test/pending_want_record_test.cpp @@ -790,5 +790,31 @@ HWTEST_F(PendingWantRecordTest, ExecuteOperation_0200, TestSize.Level1) auto params = pendingWantRecord->ExecuteOperation(pendingManager_, info, want); EXPECT_EQ(params, NO_ERROR); } + +/* + * @tc.number : PendingWantRecordTest_0300 + * @tc.name : ExecuteOperation + * @tc.desc : Check START_ABILITIES with empty WantsInfo list + */ +HWTEST_F(PendingWantRecordTest, ExecuteOperation_0300, TestSize.Level1) +{ + TAG_LOGD(AAFwkTag::TEST, "ExecuteOperation_0300 start."); + Want want; + ElementName element("device", "com.ix.hiMusic", "MusicSAbility"); + want.SetElement(element); + WantSenderInfo wantSenderInfo = MakeWantSenderInfo(want, 0, 0); + pendingManager_ = std::make_shared(); + EXPECT_NE(pendingManager_, nullptr); + std::shared_ptr key = MakeWantKey(wantSenderInfo); + WantSenderInfo emptyInfo; + emptyInfo.type = static_cast(OperationType::START_ABILITIES); + emptyInfo.allWants.clear(); + key = MakeWantKey(emptyInfo); + SenderInfo info; + std::shared_ptr pendingWantRecord = + std::make_shared(pendingManager_, 1, 0, nullptr, key); + auto result = pendingWantRecord->ExecuteOperation(pendingManager_, info, want); + EXPECT_NE(result, ERR_INVALID_VALUE); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/runtime_test/js_worker_test.cpp b/test/unittest/runtime_test/js_worker_test.cpp index f58311735ed..7dd4d767bda 100644 --- a/test/unittest/runtime_test/js_worker_test.cpp +++ b/test/unittest/runtime_test/js_worker_test.cpp @@ -27,12 +27,15 @@ #undef protected #include "native_engine.h" #include "worker_info.h" +#include "bundle_mgr_helper.h" using namespace testing; using namespace testing::ext; namespace OHOS { namespace AbilityRuntime { +using namespace AppExecFwk; +using namespace AAFwk; class JsWorkerTest : public testing::Test { public: static void SetUpTestCase(); @@ -124,5 +127,41 @@ HWTEST_F(JsWorkerTest, AssetHelper_0200, TestSize.Level1) auto ret = helper.GetSafeData("test.txt", &buff, &buffSize, &mapper); EXPECT_EQ(ret, false); } + +/** + * @tc.name: AssetHelper_0300 + * @tc.desc: Asset helper ReadFilePathData. + * @tc.type: FUNC + * @tc.require: issue#I948D4 + */ +HWTEST_F(JsWorkerTest, AssetHelper_0300, TestSize.Level1) +{ + std::shared_ptr workerInfo = std::make_shared(); + workerInfo->codePath = panda::panda_file::StringPacProtect("/data/test/codePath"); + workerInfo->packagePathStr = "/data/test/packagePath"; + workerInfo->hapPath = panda::panda_file::StringPacProtect("/data/test/hapPath"); + workerInfo->moduleName = "moduleName"; + AssetHelper helper = AssetHelper(workerInfo); + + auto bundleMgrHelper = DelayedSingleton::GetInstance(); + AppExecFwk::BundleInfo bundleInfo; + int32_t result = bundleMgrHelper->GetBundleInfoForSelf(0, bundleInfo); + if (result != 0 || bundleInfo.hapModuleInfos.empty()) { + bundleInfo.hapModuleInfos.clear(); + auto& hapModule = bundleInfo.hapModuleInfos.emplace_back(); + hapModule.moduleName = workerInfo->moduleName; + hapModule.hapPath = workerInfo->hapPath.GetOriginString(); + result = 0; + } + uint8_t *buff = nullptr; + size_t buffSize; + std::vector content; + bool useSecureMem = false; + bool isRestricted = false; + std::unique_ptr fileMapper = std::make_unique(); + void* mapper = static_cast(fileMapper.get()); + auto ret = helper.ReadFilePathData("test.txt", &buff, &buffSize, content, useSecureMem, isRestricted, &mapper); + EXPECT_FALSE(ret); +} } // namespace AbilityRuntime } // namespace OHOS -- Gitee From a20fa4ab004fabf83ef11acc2d4e30cafbb36823 Mon Sep 17 00:00:00 2001 From: zhaoyrr Date: Tue, 12 Aug 2025 01:56:09 +0000 Subject: [PATCH 2/5] update services/abilitymgr/src/pending_want_record.cpp. Signed-off-by: zhaoyrr --- services/abilitymgr/src/pending_want_record.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/services/abilitymgr/src/pending_want_record.cpp b/services/abilitymgr/src/pending_want_record.cpp index 941a3f0b798..3454dcda9d2 100644 --- a/services/abilitymgr/src/pending_want_record.cpp +++ b/services/abilitymgr/src/pending_want_record.cpp @@ -118,9 +118,10 @@ int32_t PendingWantRecord::ExecuteOperation( senderInfo.callerToken, -1, callerUid_, callerTokenId_); break; case static_cast(OperationType::START_ABILITIES): { - std::vector allWantsInfos; + std::vector allWantsInfos = key_->GetAllWantsInfos(); if (allWantsInfos.size() == 0) { - return ERR_INVALID_VALUE; + TAG_LOGI(AAFwkTag::WANTAGENT, "no want info"); + return ERR_OK; } allWantsInfos.back().want = want; res = pendingWantManager->PendingWantStartAbilitys( -- Gitee From 5c1e869d5185915bdb9afc2613864e5d6de0fa68 Mon Sep 17 00:00:00 2001 From: zhaoyrr Date: Tue, 12 Aug 2025 01:58:38 +0000 Subject: [PATCH 3/5] update frameworks/native/runtime/js_worker.cpp. Signed-off-by: zhaoyrr --- frameworks/native/runtime/js_worker.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/frameworks/native/runtime/js_worker.cpp b/frameworks/native/runtime/js_worker.cpp index f755382bd5d..6b1187b11cd 100644 --- a/frameworks/native/runtime/js_worker.cpp +++ b/frameworks/native/runtime/js_worker.cpp @@ -395,9 +395,6 @@ bool AssetHelper::ReadFilePathData(const std::string& filePath, uint8_t** buff, std::string newHapPath; size_t pos = filePath.find('/'); - if (pos == std::string::npos) { - return false; - } if (!GetIsStageModel()) { newHapPath = (workerInfo_->hapPath).GetOriginString(); } else { @@ -434,7 +431,10 @@ bool AssetHelper::ReadFilePathData(const std::string& filePath, uint8_t** buff, return flag; } } else { - realfilePath = filePath.substr(pos + 1); + if (pos != std::string::npos) { + pos = pos + 1; + } + realfilePath = filePath.substr(pos); TAG_LOGD(AAFwkTag::JSRUNTIME, "realfilePath: %{private}s", realfilePath.c_str()); int32_t apiTargetVersion = static_cast(workerInfo_->apiTargetVersion.GetOriginPointer()); bool apiSatisfy = apiTargetVersion == 0 || apiTargetVersion > API8; -- Gitee From d4e5b986358af3536d01dfafa56d85f36072859c Mon Sep 17 00:00:00 2001 From: zhaoyrr Date: Tue, 12 Aug 2025 01:59:03 +0000 Subject: [PATCH 4/5] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20serv?= =?UTF-8?q?ices/common/include/hilog=5Ftag=5Fwrapper.h?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- services/common/include/hilog_tag_wrapper.h | 231 -------------------- 1 file changed, 231 deletions(-) delete mode 100644 services/common/include/hilog_tag_wrapper.h diff --git a/services/common/include/hilog_tag_wrapper.h b/services/common/include/hilog_tag_wrapper.h deleted file mode 100644 index 391b3e70252..00000000000 --- a/services/common/include/hilog_tag_wrapper.h +++ /dev/null @@ -1,231 +0,0 @@ -/* - * Copyright (c) 2024-2025 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_HILOG_TAG_WRAPPER_H -#define OHOS_AAFWK_HILOG_TAG_WRAPPER_H - -#include -#include - -#include "hilog/log.h" - -#ifndef AAFWK_FUNC_FMT -#define AAFWK_FUNC_FMT "[%{public}s:%{public}d]" -#endif - -#ifndef AAFWK_FILE_NAME -#define AAFWK_FILE_NAME \ - (__builtin_strrchr(__FILE_NAME__, '/') ? __builtin_strrchr(__FILE_NAME__, '/') + 1 : __FILE_NAME__) -#endif - -#ifndef AAFWK_FUNC_INFO -#define AAFWK_FUNC_INFO AAFWK_FILE_NAME, __LINE__ -#endif - - -namespace OHOS::AAFwk { -enum class AAFwkLogTag : uint32_t { - DEFAULT = 0xD001300, // 0XD001300 - ABILITY, - TEST, - AA_TOOL, - ABILITY_SIM, - - APPDFR = DEFAULT + 0x10, // 0xD001310 - APPMGR, - DBOBSMGR, - DIALOG, - QUICKFIX, - URIPERMMGR, - BUNDLEMGRHELPER, - APPKIT, - - JSENV = DEFAULT + 0x20, // 0xD001320 - JSRUNTIME, - FA, - INTENT, - JSNAPI, - CJRUNTIME, - ETSRUNTIME, - ANI, - - DELEGATOR = DEFAULT + 0x30, // 0xD001330 - CONTEXT, - UIABILITY, - WANT, - MISSION, - CONNECTION, - ABILITYMGR, - ECOLOGICAL_RULE, - DATA_ABILITY, - - EXT = DEFAULT + 0x40, // 0xD001340 - AUTOFILL_EXT, - SERVICE_EXT, - FORM_EXT, - SHARE_EXT, - UI_EXT, - ACTION_EXT, - EMBEDDED_EXT, - UISERVC_EXT, - FORM_EDIT_EXT, - - WANTAGENT = DEFAULT + 0x50, // 0xD001350 - AUTOFILLMGR, - EXTMGR, - SER_ROUTER, - AUTO_STARTUP, - STARTUP, - RECOVERY, - PROCESSMGR, - CONTINUATION, - DISTRIBUTED, - FREE_INSTALL, - KEEP_ALIVE, - QUERY_ERMS, - - LOCAL_CALL = DEFAULT + 0x60, // 0xD001360 - SA_INTERCEPTOR, - - APP_SERVICE_EXT = DEFAULT + 0x70, // 0xD001370 - - END = 256, // N.B. never use it -}; - -inline uint32_t GetOffset(AAFwkLogTag tag, AAFwkLogTag base) -{ - if (static_cast(tag) <= static_cast(base)) { - return 0; - } - return static_cast(tag) - static_cast(base); -} - -inline const char* GetDomainName0(AAFwkLogTag tag) -{ - const char* tagNames[] = { "AAFwk", "Ability", "Test", "AATool", "Simulator" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::DEFAULT); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName1(AAFwkLogTag tag) -{ - const char* tagNames[] = { "AppDfr", "AppMS", "DbObsMgr", "Dialog", "Quickfix", - "UriPermMgr", "BMSHelper", "AppKit" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::APPDFR); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName2(AAFwkLogTag tag) -{ - const char* tagNames[] = { "JsEnv", "JsRuntime", "FA", "Intent", "JsNapi", - "CjRuntime", "EtsRuntime", "Ani"}; - uint32_t offset = GetOffset(tag, AAFwkLogTag::JSENV); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName3(AAFwkLogTag tag) -{ - const char* tagNames[] = { "Delegator", "Context", "UIAbility", "Want", "Mission", - "Connection", "AMS", "EcologicalRule", "DataAbility" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::DELEGATOR); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName4(AAFwkLogTag tag) -{ - const char* tagNames[] = { "Ext", "AutoFillExt", "ServiceExt", "FormExt", "ShareExt", - "UIExt", "ActionExt", "EmbeddedExt", "UIServiceExt" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::EXT); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName5(AAFwkLogTag tag) -{ - const char* tagNames[] = { "WantAgent", "AutoFillMgr", "ExtMgr", "ServiceRouter", - "AutoStartup", "Startup", "Recovery", "ProcessMgr", "Continuation", - "Distributed", "FreeInstall", "KeepAlive", "QueryERMS" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::WANTAGENT); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -inline const char* GetDomainName6(AAFwkLogTag tag) -{ - const char* tagNames[] = { "LocalCall" }; - uint32_t offset = GetOffset(tag, AAFwkLogTag::LOCAL_CALL); - if (offset >= sizeof(tagNames) / sizeof(const char*)) { - return "UN"; - } - return tagNames[offset]; -} - -constexpr uint32_t BASE_DEFAULT = 0; -constexpr uint32_t BASE_APPDFR = 1; -constexpr uint32_t BASE_JSENV = 2; -constexpr uint32_t BASE_DELEGATOR = 3; -constexpr uint32_t BASE_EXT = 4; -constexpr uint32_t BASE_WANTAGENT = 5; -constexpr uint32_t BASE_LOCAL_CALL = 6; - -static inline const char* GetTagInfoFromDomainId(AAFwkLogTag tag) -{ - uint32_t offset = GetOffset(tag, AAFwkLogTag::DEFAULT); - uint32_t base = offset >> 4; - switch (base) { - case BASE_DEFAULT: return GetDomainName0(tag); - case BASE_APPDFR: return GetDomainName1(tag); - case BASE_JSENV: return GetDomainName2(tag); - case BASE_DELEGATOR: return GetDomainName3(tag); - case BASE_EXT: return GetDomainName4(tag); - case BASE_WANTAGENT: return GetDomainName5(tag); - case BASE_LOCAL_CALL: return GetDomainName6(tag); - default: return "UN"; - } -} -} // OHOS::AAFwk - -using AAFwkTag = OHOS::AAFwk::AAFwkLogTag; - -#define AAFWK_PRINT_LOG(level, tag, fmt, ...) \ - do { \ - AAFwkTag logTag = tag; \ - ((void)HILOG_IMPL(LOG_CORE, level, static_cast(logTag), \ - OHOS::AAFwk::GetTagInfoFromDomainId(logTag), AAFWK_FUNC_FMT fmt, AAFWK_FUNC_INFO, ##__VA_ARGS__)); \ - } while (0) - -#define TAG_LOGD(tag, fmt, ...) AAFWK_PRINT_LOG(LOG_DEBUG, tag, fmt, ##__VA_ARGS__) -#define TAG_LOGI(tag, fmt, ...) AAFWK_PRINT_LOG(LOG_INFO, tag, fmt, ##__VA_ARGS__) -#define TAG_LOGW(tag, fmt, ...) AAFWK_PRINT_LOG(LOG_WARN, tag, fmt, ##__VA_ARGS__) -#define TAG_LOGE(tag, fmt, ...) AAFWK_PRINT_LOG(LOG_ERROR, tag, fmt, ##__VA_ARGS__) -#define TAG_LOGF(tag, fmt, ...) AAFWK_PRINT_LOG(LOG_FATAL, tag, fmt, ##__VA_ARGS__) - -#endif // OHOS_AAFWK_HILOG_TAG_WRAPPER_H -- Gitee From 33531d4e323fa47802850f5841dc6a085eee01c9 Mon Sep 17 00:00:00 2001 From: zhaoyrr Date: Tue, 12 Aug 2025 02:03:20 +0000 Subject: [PATCH 5/5] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20serv?= =?UTF-8?q?ices/abilitymgr/src/scene=5Fboard/ui=5Fability=5Flifecycle=5Fma?= =?UTF-8?q?nager.cpp?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ui_ability_lifecycle_manager.cpp | 4122 ----------------- 1 file changed, 4122 deletions(-) delete mode 100644 services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp diff --git a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp deleted file mode 100644 index 1d2c358422b..00000000000 --- a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp +++ /dev/null @@ -1,4122 +0,0 @@ -/* - * Copyright (c) 2023-2025 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 "scene_board/ui_ability_lifecycle_manager.h" - -#include "ability_manager_service.h" -#include "ability_permission_util.h" -#include "ability_start_with_wait_observer_manager.h" -#include "ability_start_with_wait_observer_utils.h" -#include "appfreeze_manager.h" -#include "app_exit_reason_data_manager.h" -#include "app_mgr_util.h" -#include "app_utils.h" -#include "display_util.h" -#include "ffrt.h" -#include "global_constant.h" -#include "hitrace_meter.h" -#include "permission_constants.h" -#include "process_options.h" -#include "server_constant.h" -#include "start_window_option.h" -#include "scene_board/status_bar_delegate_manager.h" -#include "session_manager_lite.h" -#include "session/host/include/zidl/session_interface.h" -#include "startup_util.h" -#include "timeout_state_utils.h" -#include "ui_extension_utils.h" -#include "ability_stage_constant.h" -#ifdef SUPPORT_GRAPHICS -#include "ability_first_frame_state_observer_manager.h" -#endif -#include "hidden_start_observer_manager.h" -#include "request_id_util.h" - -namespace OHOS { -using AbilityRuntime::FreezeUtil; -using namespace AbilityRuntime::ServerConstant; -namespace AAFwk { -namespace { -constexpr const char* SEPARATOR = ":"; -constexpr const char* PARAM_MISSION_AFFINITY_KEY = "ohos.anco.param.missionAffinity"; -constexpr const char* DMS_SRC_NETWORK_ID = "dmsSrcNetworkId"; -constexpr const char* DMS_MISSION_ID = "dmsMissionId"; -constexpr int DEFAULT_DMS_MISSION_ID = -1; -constexpr const char* PARAM_SPECIFIED_PROCESS_FLAG = "ohoSpecifiedProcessFlag"; -constexpr const char* DMS_PROCESS_NAME = "distributedsched"; -constexpr const char* DMS_PERSISTENT_ID = "ohos.dms.persistentId"; -constexpr const char* IS_SHELL_CALL = "isShellCall"; -constexpr const char* SPECIFED_PROCESS_CALLER_PROCESS = "ohoSpecifiedProcessCallerProcess"; -#ifdef SUPPORT_ASAN -constexpr int KILL_TIMEOUT_MULTIPLE = 45; -#else -constexpr int KILL_TIMEOUT_MULTIPLE = 3; -#endif -constexpr int32_t DEFAULT_USER_ID = 0; -constexpr int32_t MAX_FIND_UIEXTENSION_CALLER_TIMES = 10; -constexpr int32_t START_UI_ABILITY_PER_SECOND_UPPER_LIMIT = 20; -constexpr int32_t API20 = 20; -constexpr int32_t API_VERSION_MOD = 100; -constexpr int32_t REQUEST_LIST_ID_INIT = -1; -constexpr const char* IS_CALLING_FROM_DMS = "supportCollaborativeCallingFromDmsInAAFwk"; -constexpr int REMOVE_STARTING_BUNDLE_TIMEOUT_MICRO_SECONDS = 5000000; // 5s - -auto g_deleteLifecycleEventTask = [](const sptr &token) { - CHECK_POINTER_LOG(token, "token is nullptr."); - FreezeUtil::GetInstance().DeleteLifecycleEvent(token->AsObject()); -}; - -bool CompareTwoRequest(const AbilityRequest &left, const AbilityRequest &right) -{ - int32_t leftIndex = 0; - (void)AbilityRuntime::StartupUtil::GetAppIndex(left.want, leftIndex); - int32_t rightIndex = 0; - (void)AbilityRuntime::StartupUtil::GetAppIndex(right.want, rightIndex); - - auto LeftInstanceKey = left.want.GetStringParam(Want::APP_INSTANCE_KEY); - auto RightInstanceKey = right.want.GetStringParam(Want::APP_INSTANCE_KEY); - - return leftIndex == rightIndex && LeftInstanceKey == RightInstanceKey && - left.abilityInfo.name == right.abilityInfo.name && - left.abilityInfo.bundleName == right.abilityInfo.bundleName && - left.abilityInfo.moduleName == right.abilityInfo.moduleName; -} -} - -UIAbilityLifecycleManager::UIAbilityLifecycleManager(int32_t userId): userId_(userId) {} - -bool UIAbilityLifecycleManager::ProcessColdStartBranch(AbilityRequest &abilityRequest, sptr sessionInfo, - std::shared_ptr uiAbilityRecord, bool isColdStart) -{ - if (isColdStart && uiAbilityRecord->IsHook()) { - auto nextRequest = PopAndGetNextSpecified(sessionInfo->requestId); - if (nextRequest) { - ffrt::submit([nextRequest, pThis = shared_from_this()]() { - std::lock_guard lock(pThis->sessionLock_); - pThis->StartSpecifiedRequest(*nextRequest); - }, ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); - } - return false; - } - DelayedSingleton::GetInstance()->StartSpecifiedAbility(abilityRequest.want, - abilityRequest.abilityInfo, sessionInfo->requestId); - AddCallerRecord(abilityRequest, sessionInfo, uiAbilityRecord); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - return true; -} - -bool UIAbilityLifecycleManager::IsBundleStarting(pid_t pid) -{ - std::lock_guard guard(startingPidsMutex_); - for (auto iter = startingPids_.begin(); iter != startingPids_.end(); iter++) { - if (*iter == pid) { - return true; - } - } - TAG_LOGW(AAFwkTag::ABILITYMGR, "not found"); - return false; -} - -void UIAbilityLifecycleManager::AddStartingPid(pid_t pid) -{ - if (IsBundleStarting(pid)) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}d already exists", pid); - return; - } - { - std::lock_guard guard(startingPidsMutex_); - startingPids_.push_back(pid); - } - ffrt::task_attr attr; - attr.delay(REMOVE_STARTING_BUNDLE_TIMEOUT_MICRO_SECONDS); - std::weak_ptr weakPtr = shared_from_this(); - ffrt::submit([weakPtr, pid]() { - auto uiAbilityManager = weakPtr.lock(); - if (uiAbilityManager == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null uiAbilityManager"); - return; - } - uiAbilityManager->RemoveStartingPid(pid); - }, attr); -} - -void UIAbilityLifecycleManager::RemoveStartingPid(pid_t pid) -{ - std::lock_guard guard(startingPidsMutex_); - for (auto iter = startingPids_.begin(); iter != startingPids_.end(); iter++) { - if (*iter == pid) { - startingPids_.erase(iter); - return; - } - } - TAG_LOGW(AAFwkTag::ABILITYMGR, "%{public}d not found", pid); -} - -void UIAbilityLifecycleManager::RecordPidKilling(pid_t pid, const std::string &reason, bool isKillPrecedeStart) -{ - std::lock_guard guard(sessionLock_); - for (const auto& [first, second] : sessionAbilityMap_) { - if (second && pid == second->GetPid()) { - second->SetKillReason(reason); - second->SetIsKillPrecedeStart(isKillPrecedeStart); - } - } -} - -void UIAbilityLifecycleManager::MarkStartingFlag(const AbilityRequest &abilityRequest) -{ - for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) { - if (iter->second == nullptr || iter->second->GetPid() <= 0 || - iter->second->GetAbilityInfo().bundleName != abilityRequest.abilityInfo.bundleName) { - continue; - } - AddStartingPid(iter->second->GetPid()); - } -} - -int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sptr sessionInfo, - uint32_t sceneFlag, bool &isColdStart) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (!CheckSessionInfo(sessionInfo)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo invalid"); - return ERR_INVALID_VALUE; - } - bool preloadStartCheck = sessionInfo->processOptions != nullptr && sessionInfo->processOptions->isPreloadStart; - auto iter = sessionAbilityMap_.find(sessionInfo->persistentId); - if (iter != sessionAbilityMap_.end() && preloadStartCheck && iter->second != nullptr && - !iter->second->IsPreloaded()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "preload check: already has record"); - return ERR_OK; - } - - if (preloadStartCheck) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, preload start"); - abilityRequest.processOptions = sessionInfo->processOptions; - } - auto isCallBySCB = sessionInfo->want.GetBoolParam(ServerConstant::IS_CALL_BY_SCB, true); - sessionInfo->want.RemoveParam(ServerConstant::IS_CALL_BY_SCB); - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartUIAbility session:%{public}d. bundle:%{public}s, ability:%{public}s, " - "instanceKey:%{public}s, requestId: %{public}d, isCallBySCB: %{public}d, reuseDelegator: %{public}d, " - "scenarios:%{public}d", sessionInfo->persistentId, abilityRequest.abilityInfo.bundleName.c_str(), - abilityRequest.abilityInfo.name.c_str(), sessionInfo->instanceKey.c_str(), - sessionInfo->requestId, isCallBySCB, sessionInfo->reuseDelegatorWindow, sessionInfo->scenarios); - abilityRequest.sessionInfo = sessionInfo; - auto uiAbilityRecord = GenerateAbilityRecord(abilityRequest, sessionInfo, isColdStart); - CHECK_POINTER_AND_RETURN(uiAbilityRecord, ERR_INVALID_VALUE); - MarkStartingFlag(abilityRequest); - if (sessionInfo->reuseDelegatorWindow) { - uiAbilityRecord->lifeCycleStateInfo_.sceneFlagBak = sceneFlag; - return ERR_OK; - } - auto want = uiAbilityRecord->GetWant(); - if (want.GetBoolParam(IS_CALLING_FROM_DMS, false) && !(sessionInfo->isNewWant)) { - want.RemoveParam(IS_CALLING_FROM_DMS); - uiAbilityRecord->SetWant(want); - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "StartUIAbility"); - uiAbilityRecord->SetSpecifyTokenId(abilityRequest.specifyTokenId); - UpdateAbilityRecordLaunchReason(abilityRequest, uiAbilityRecord); - NotifyAbilityToken(uiAbilityRecord->GetToken(), abilityRequest); - if (HandleStartSpecifiedCold(abilityRequest, sessionInfo, sceneFlag) && - ProcessColdStartBranch(abilityRequest, sessionInfo, uiAbilityRecord, isColdStart)) { - return ERR_OK; - } - auto scenarios = static_cast(uiAbilityRecord->GetOnNewWantSkipScenarios()) & - static_cast(sessionInfo->scenarios); - if (uiAbilityRecord->GetPendingState() != AbilityState::INITIAL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "pending state: FOREGROUND/ BACKGROUND, dropped"); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - if (scenarios == 0 && sessionInfo->isNewWant) { - uiAbilityRecord->SetLastWant(std::make_shared(abilityRequest.want)); - } - return ERR_OK; - } else { - TAG_LOGD(AAFwkTag::ABILITYMGR, "pending state is not FOREGROUND or BACKGROUND."); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - } - if (!isColdStart && scenarios == 0) { - uiAbilityRecord->SetIsNewWant(sessionInfo->isNewWant); - if (sessionInfo->isNewWant) { - uiAbilityRecord->SetWant(abilityRequest.want); - uiAbilityRecord->GetSessionInfo()->want.RemoveAllFd(); - } else { - sessionInfo->want.CloseAllFd(); - } - } - - if (!uiAbilityRecord->IsReady() || sessionInfo->isNewWant) { - AddCallerRecord(abilityRequest, sessionInfo, uiAbilityRecord); - } - auto isShellCall = abilityRequest.want.GetBoolParam(IS_SHELL_CALL, false); - uint32_t callerTokenId = static_cast(abilityRequest.want.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN, 0)); - uiAbilityRecord->ProcessForegroundAbility(callerTokenId, sceneFlag, isShellCall); - if (uiAbilityRecord->GetSpecifiedFlag().empty() && !sessionInfo->specifiedFlag.empty()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "update specified: %{public}d--%{public}s", sessionInfo->requestId, - sessionInfo->specifiedFlag.c_str()); - uiAbilityRecord->SetSpecifiedFlag(sessionInfo->specifiedFlag); - } - SendKeyEvent(abilityRequest); - return ERR_OK; -} - -std::shared_ptr UIAbilityLifecycleManager::GenerateAbilityRecord(AbilityRequest &abilityRequest, - sptr sessionInfo, bool &isColdStart) -{ - std::shared_ptr uiAbilityRecord = nullptr; - auto iter = sessionAbilityMap_.find(sessionInfo->persistentId); - bool isLowMemKill = (iter != sessionAbilityMap_.end()) && - (iter->second != nullptr) && (iter->second->IsKillPrecedeStart()); - if (iter == sessionAbilityMap_.end() || isLowMemKill) { - uiAbilityRecord = FindRecordFromTmpMap(abilityRequest); - auto abilityInfo = abilityRequest.abilityInfo; - if (uiAbilityRecord == nullptr) { - uiAbilityRecord = CreateAbilityRecord(abilityRequest, sessionInfo); - bool isUIAbility = (abilityInfo.type == AppExecFwk::AbilityType::PAGE && abilityInfo.isStageBasedModel); - abilityRequest.want.SetParam(Want::APP_INSTANCE_KEY, sessionInfo->instanceKey); - auto abilityRecord = FindRecordFromSessionMap(abilityRequest); - if (isUIAbility && IsHookModule(abilityRequest) && abilityRecord == nullptr && - (sessionInfo->processOptions == nullptr || - sessionInfo->processOptions->startupVisibility == StartupVisibility::STARTUP_SHOW)) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "only first need call SetIsHook"); - uiAbilityRecord->SetIsHook(true); - uiAbilityRecord->SetLaunchWant(std::make_shared(abilityRequest.want)); - } - } else { - uiAbilityRecord->SetInstanceKey(sessionInfo->instanceKey); - uiAbilityRecord->SetSessionInfo(sessionInfo); - } - isColdStart = true; - AbilityStartWithWaitObserverManager::GetInstance().SetColdStartForShellCall(uiAbilityRecord); - UpdateProcessName(abilityRequest, uiAbilityRecord); - if (isSCBRecovery_) { - coldStartInSCBRecovery_.insert(sessionInfo->persistentId); - } - if (abilityInfo.applicationInfo.multiAppMode.multiAppModeType == AppExecFwk::MultiAppModeType::MULTI_INSTANCE && - abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { - auto appMgr = AppMgrUtil::GetAppMgr(); - if (appMgr == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "AppMgrUtil::GetAppMgr failed"); - return uiAbilityRecord; - } - IN_PROCESS_CALL_WITHOUT_RET( - appMgr->UpdateInstanceKeyBySpecifiedId(sessionInfo->requestId, sessionInfo->instanceKey)); - } - MoreAbilityNumbersSendEventInfo( - abilityRequest.userId, abilityInfo.bundleName, abilityInfo.name, abilityInfo.moduleName); - if (isLowMemKill) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "killed by low-mem, created a new record, " - "replacing old record id=%{public}s, new record id=%{public}s", - std::to_string(sessionAbilityMap_[sessionInfo->persistentId]->GetAbilityRecordId()).c_str(), - std::to_string(uiAbilityRecord->GetAbilityRecordId()).c_str()); - lowMemKillAbilityMap_.emplace(sessionInfo->persistentId, sessionAbilityMap_[sessionInfo->persistentId]); - sessionAbilityMap_[sessionInfo->persistentId] = uiAbilityRecord; - } else { - sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord); - } - } else { - TAG_LOGI(AAFwkTag::ABILITYMGR, "NewWant:%{public}d", sessionInfo->isNewWant); - uiAbilityRecord = iter->second; - if (uiAbilityRecord == nullptr || uiAbilityRecord->GetSessionInfo() == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "uiAbilityRecord invalid"); - return nullptr; - } - if (sessionInfo->sessionToken != uiAbilityRecord->GetSessionInfo()->sessionToken) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionToken invalid"); - return nullptr; - } - abilityRequest.want.RemoveParam(Want::PARAMS_REAL_CALLER_KEY); - auto appMgr = AppMgrUtil::GetAppMgr(); - if (appMgr != nullptr && sessionInfo->reuseDelegatorWindow) { - auto ret = IN_PROCESS_CALL(appMgr->LaunchAbility(uiAbilityRecord->GetToken())); - sessionInfo->want.CloseAllFd(); - if (ret == ERR_OK) { - uiAbilityRecord->SetIsNewWant(false); - return uiAbilityRecord; - } - return nullptr; - } - } - return uiAbilityRecord; -} - -std::shared_ptr UIAbilityLifecycleManager::FindRecordFromTmpMap( - const AbilityRequest &abilityRequest) -{ - int32_t appIndex = 0; - (void)AbilityRuntime::StartupUtil::GetAppIndex(abilityRequest.want, appIndex); - auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - for (const auto &[requestId, abilityRecord] : tmpAbilityMap_) { - if (abilityRecord) { - const auto &info = abilityRecord->GetAbilityInfo(); - if (info.name == abilityRequest.abilityInfo.name && - info.bundleName == abilityRequest.abilityInfo.bundleName && - info.moduleName == abilityRequest.abilityInfo.moduleName && - appIndex == abilityRecord->GetAppIndex() && instanceKey == abilityRecord->GetInstanceKey()) { - return abilityRecord; - } - } - } - return nullptr; -} - -bool UIAbilityLifecycleManager::CheckSessionInfo(sptr sessionInfo) const -{ - if (sessionInfo == nullptr || sessionInfo->sessionToken == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo invalid"); - return false; - } - auto sessionToken = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER_AND_RETURN(sessionToken, false); - auto descriptor = Str16ToStr8(sessionToken->GetDescriptor()); - if (descriptor != "OHOS.ISession") { - TAG_LOGE(AAFwkTag::ABILITYMGR, "token's Descriptor: %{public}s", descriptor.c_str()); - return false; - } - std::string callerKey = sessionInfo->want.GetStringParam(Want::PARAMS_REAL_CALLER_KEY); - bool isCallerKilling = IN_PROCESS_CALL(DelayedSingleton::GetInstance()->IsCallerKilling(callerKey)); - if (isCallerKilling) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller is killing"); - return false; - } - return true; -} - -std::shared_ptr UIAbilityLifecycleManager::CreateAbilityRecord(AbilityRequest &abilityRequest, - sptr sessionInfo) const -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Create ability record."); - if (sessionInfo->startSetting != nullptr) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "startSetting is valid."); - abilityRequest.startSetting = sessionInfo->startSetting; - } - auto uiAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); - if (uiAbilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "uiAbilityRecord invalid"); - return nullptr; - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "user id: %{public}d.", userId_); - uiAbilityRecord->SetOwnerMissionUserId(userId_); - SetReceiverInfo(abilityRequest, uiAbilityRecord); - return uiAbilityRecord; -} - -void UIAbilityLifecycleManager::AddCallerRecord(AbilityRequest &abilityRequest, sptr sessionInfo, - std::shared_ptr uiAbilityRecord) const -{ - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo invalid"); - return; - } - CHECK_POINTER(uiAbilityRecord); - std::string srcAbilityId = ""; - if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_FOR_RESULT, false)) { - std::string srcDeviceId = abilityRequest.want.GetStringParam(DMS_SRC_NETWORK_ID); - int missionId = abilityRequest.want.GetIntParam(DMS_MISSION_ID, DEFAULT_DMS_MISSION_ID); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Get srcNetWorkId = %{public}s, missionId = %{public}d", srcDeviceId.c_str(), - missionId); - Want *newWant = const_cast(&abilityRequest.want); - newWant->RemoveParam(DMS_SRC_NETWORK_ID); - newWant->RemoveParam(DMS_MISSION_ID); - newWant->RemoveParam(Want::PARAM_RESV_FOR_RESULT); - srcAbilityId = srcDeviceId + "_" + std::to_string(missionId); - } - uiAbilityRecord->AddCallerRecord(sessionInfo->callerToken, - sessionInfo->requestCode, abilityRequest.want, srcAbilityId, sessionInfo->callingTokenId); -} - -void UIAbilityLifecycleManager::SendKeyEvent(const AbilityRequest &abilityRequest) const -{ - if (abilityRequest.abilityInfo.visible == false) { - EventInfo eventInfo; - eventInfo.abilityName = abilityRequest.abilityInfo.name; - eventInfo.bundleName = abilityRequest.abilityInfo.bundleName; - eventInfo.moduleName = abilityRequest.abilityInfo.moduleName; - EventReport::SendKeyEvent(EventName::START_PRIVATE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo); - } -} - -int UIAbilityLifecycleManager::AttachAbilityThread(const sptr &scheduler, - const sptr &token) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (!IsContainsAbility(token)) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "Not in running list"); - return ERR_INVALID_VALUE; - } - auto&& abilityRecord = Token::GetAbilityRecordByToken(token); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - abilityRecord->SetPid(IPCSkeleton::GetCallingPid()); - int32_t processAttachResult = DoProcessAttachment(abilityRecord); - - std::lock_guard guard(sessionLock_); - TAG_LOGI(AAFwkTag::ABILITYMGR, "lifecycle name: %{public}s", abilityRecord->GetAbilityInfo().name.c_str()); - SetLastExitReason(abilityRecord); - - auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); - CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler."); - abilityRecord->RemoveLoadTimeoutTask(); - abilityRecord->SetLoading(false); - FreezeUtil::GetInstance().DeleteLifecycleEvent(token); - - abilityRecord->SetScheduler(scheduler); - if (processAttachResult != ERR_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "process attachment failed, close ability"); - TerminateSession(abilityRecord); - return ERR_INVALID_VALUE; - } - if (abilityRecord->IsStartedByCall()) { - if (abilityRecord->GetWant().GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) { - abilityRecord->SetStartToForeground(true); - abilityRecord->PostForegroundTimeoutTask(); - abilityRecord->SetAbilityState(AbilityState::FOREGROUNDING); - DelayedSingleton::GetInstance()->MoveToForeground(token); - } else { - abilityRecord->SetStartToBackground(true); - MoveToBackground(abilityRecord); - } - return ERR_OK; - } - if (abilityRecord->IsNeedToCallRequest()) { - abilityRecord->CallRequest(); - } - abilityRecord->PostForegroundTimeoutTask(); - abilityRecord->SetAbilityState(AbilityState::FOREGROUNDING); - DelayedSingleton::GetInstance()->MoveToForeground(token); - return ERR_OK; -} - -void UIAbilityLifecycleManager::OnAbilityRequestDone(const sptr &token, int32_t state) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Ability request state %{public}d done.", state); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - AppAbilityState abilityState = DelayedSingleton::GetInstance()->ConvertToAppAbilityState(state); - if (abilityState == AppAbilityState::ABILITY_STATE_FOREGROUND) { - std::lock_guard guard(sessionLock_); - auto abilityRecord = GetAbilityRecordByToken(token); - CHECK_POINTER(abilityRecord); - if (abilityRecord->IsTerminating()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "ability on terminating"); - auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); - CHECK_POINTER(handler); - abilityRecord->RemoveForegroundTimeoutTask(); - DelayedSingleton::GetInstance()->MoveToBackground(abilityRecord->GetToken()); - abilityRecord->SetPendingState(AbilityState::INITIAL); - CompleteTerminateLocked(abilityRecord); - return; - } - std::string element = abilityRecord->GetElementName().GetURI(); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Ability is %{public}s, start to foreground.", element.c_str()); - bool hasLastWant = abilityRecord->IsLastWantBackgroundDriven(); - abilityRecord->ForegroundAbility(abilityRecord->lifeCycleStateInfo_.sceneFlagBak, hasLastWant); - } -} - -int UIAbilityLifecycleManager::AbilityTransactionDone(const sptr &token, int state, - const PacMap &saveData) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - int targetState = AbilityRecord::ConvertLifeCycleToAbilityState(static_cast(state)); - std::string abilityState = AbilityRecord::ConvertAbilityState(static_cast(targetState)); - TAG_LOGD(AAFwkTag::ABILITYMGR, "AbilityTransactionDone, state: %{public}s.", abilityState.c_str()); - - std::lock_guard guard(sessionLock_); - auto abilityRecord = GetAbilityRecordByToken(token); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - if (state == AbilityLifeCycleState::ABILITY_STATE_FOREGROUND_NEW && - abilityRecord->IsPreloadStart() && !abilityRecord->IsPreloaded()) { - abilityRecord->SetPreloaded(); - abilityRecord->SetFrozenByPreload(true); - auto ret = DelayedSingleton::GetInstance()->NotifyPreloadAbilityStateChanged(token, true); - TAG_LOGI(AAFwkTag::ABILITYMGR, "NotifyPreloadAbilityStateChanged ret: %{public}d", ret); - } - abilityRecord->RemoveSignatureInfo(); - std::string element = abilityRecord->GetElementName().GetURI(); - TAG_LOGD(AAFwkTag::ABILITYMGR, "ability: %{public}s, state: %{public}s", element.c_str(), abilityState.c_str()); - - if (targetState == AbilityState::BACKGROUND) { - abilityRecord->SaveAbilityState(saveData); - } - - return DispatchState(abilityRecord, targetState); -} - -int UIAbilityLifecycleManager::AbilityWindowConfigTransactionDone(const sptr &token, - const WindowConfig &windowConfig) -{ - std::lock_guard guard(sessionLock_); - auto abilityRecord = GetAbilityRecordByToken(token); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - abilityRecord->SaveAbilityWindowConfig(windowConfig); - return ERR_OK; -} - -bool UIAbilityLifecycleManager::AddStartCallerTimestamp(int32_t callerUid) -{ - int64_t curTimeNs = AbilityUtil::GetSysTimeNs(); - int64_t aSecondEarlier = curTimeNs - AbilityUtil::NANOSECONDS; - if (callerUid < 0) { - callerUid = IPCSkeleton::GetCallingUid(); - } - std::lock_guard guard(startUIAbilityCallerTimestampsLock_); - if (startUIAbilityCallerTimestamps_.find(callerUid) == startUIAbilityCallerTimestamps_.end()) { - startUIAbilityCallerTimestamps_[callerUid] = { curTimeNs }; - return true; - } - std::vector &callerTimestamps = startUIAbilityCallerTimestamps_[callerUid]; - auto it = callerTimestamps.begin(); - while (it != callerTimestamps.end() && *it < aSecondEarlier) { - it = callerTimestamps.erase(it); - } - if (callerTimestamps.size() >= START_UI_ABILITY_PER_SECOND_UPPER_LIMIT) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller %{public}d exceeds limit", callerUid); - return false; - } - callerTimestamps.emplace_back(curTimeNs); - return true; -} - -int UIAbilityLifecycleManager::NotifySCBToStartUIAbility(AbilityRequest &abilityRequest) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (!AddStartCallerTimestamp(abilityRequest.want.GetIntParam(Want::PARAM_RESV_CALLER_UID, -1))) { - return ERR_FREQ_START_ABILITY; - } - abilityRequest.want.SetParam(IS_SHELL_CALL, AAFwk::PermissionVerification::GetInstance()->IsShellCall()); - std::string callerKey = std::to_string(IPCSkeleton::GetCallingPid()) + ":" + - std::to_string(IPCSkeleton::GetCallingUid()); - bool isCallerKilling = IN_PROCESS_CALL(DelayedSingleton::GetInstance()->IsCallerKilling(callerKey)); - if (isCallerKilling) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller is killing"); - return ERR_CALLER_IS_KILLING; - } - abilityRequest.want.SetParam(Want::PARAMS_REAL_CALLER_KEY, callerKey); - std::lock_guard guard(sessionLock_); - // start ability with persistentId by dms - int32_t persistentId = abilityRequest.want.GetIntParam(DMS_PERSISTENT_ID, 0); - TAG_LOGD(AAFwkTag::ABILITYMGR, "NotifySCBToStartUIAbility, want with persistentId: %{public}d.", persistentId); - if (persistentId != 0 && - AAFwk::PermissionVerification::GetInstance()->CheckSpecificSystemAbilityAccessPermission(DMS_PROCESS_NAME)) { - return StartWithPersistentIdByDistributed(abilityRequest, persistentId); - } - if (IsStartSpecifiedProcessRequest(abilityRequest)) { - return StartSpecifiedProcessRequest(abilityRequest, nullptr); - } - const auto &abilityInfo = abilityRequest.abilityInfo; - auto requestId = RequestIdUtil::GetRequestId(); - auto isPlugin = StartupUtil::IsStartPlugin(abilityRequest.want); - auto isSpecified = (abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED); - if (isSpecified && !isPlugin) { - auto specifiedRequest = std::make_shared(requestId, abilityRequest); - specifiedRequest->preCreateProcessName = true; - AddSpecifiedRequest(specifiedRequest); - return ERR_OK; - } - - if (IsHookModule(abilityRequest)) { - auto abilityRecord = FindRecordFromSessionMap(abilityRequest); - if (abilityRecord != nullptr && abilityRecord->IsHook() && !abilityRecord->GetHookOff()) { - AbilityRequest request; - request.callerToken = abilityRequest.callerToken; - sptr hookSessionInfo = abilityRecord->GetSessionInfo(); - if (hookSessionInfo != nullptr) { - hookSessionInfo->want = abilityRequest.want; - } - std::string errMsg; - int ret = NotifySCBPendingActivation(hookSessionInfo, request, errMsg); - if (hookSessionInfo != nullptr) { - hookSessionInfo->want.RemoveAllFd(); - } - if (ret == ERR_INVALID_VALUE) { - ret = ERR_NOTIFY_SCB_PENDING_ACTIVATION_FAILED; - } - return ret; - } - } - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->requestId = requestId; - auto isCreating = abilityRequest.want.GetBoolParam(Want::CREATE_APP_INSTANCE_KEY, false); - if (abilityInfo.applicationInfo.multiAppMode.multiAppModeType != AppExecFwk::MultiAppModeType::MULTI_INSTANCE || - !isCreating) { - sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse); - } - sessionInfo->userId = userId_; - sessionInfo->isAtomicService = (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - TAG_LOGI(AAFwkTag::ABILITYMGR, "Reused sessionId: %{public}d, userId: %{public}d, requestId: %{public}d", - sessionInfo->persistentId, userId_, requestId); - std::string errMsg; - int ret = NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); - if (ret == ERR_INVALID_VALUE) { - ret = ERR_NOTIFY_SCB_PENDING_ACTIVATION_FAILED; - } - sessionInfo->want.RemoveAllFd(); - return ret; -} - -int UIAbilityLifecycleManager::NotifySCBToStartUIAbilities(std::vector &abilityRequestList, - const std::string &requestKey) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call NotifySCBToStartUIAbilities"); - - int32_t ret = HandleUIAbilityRequestList(abilityRequestList); - if (ret != ERR_OK) { - return ret; - } - - std::lock_guard guard(sessionLock_); - auto abilitiesRequest = std::make_shared(); - int32_t requestListId = RequestIdUtil::GetRequestId(); - abilitiesRequest->requestListId = requestListId; - abilitiesRequestMap_.emplace(requestListId, abilitiesRequest); - abilitiesRequest->requestKey = requestKey; - for (AbilityRequest &abilityRequest : abilityRequestList) { - abilitiesRequest->callerToken = abilityRequest.callerToken; - if (IsStartSpecifiedProcessRequest(abilityRequest)) { - ret = StartSpecifiedProcessRequest(abilityRequest, abilitiesRequest); - if (ret != ERR_OK) { - return ret; - } - continue; - } - const auto &abilityInfo = abilityRequest.abilityInfo; - auto requestId = RequestIdUtil::GetRequestId(); - if (abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { - auto specifiedRequest = std::make_shared(requestId, abilityRequest); - specifiedRequest->preCreateProcessName = true; - specifiedRequest->requestListId = abilitiesRequest->requestListId; - abilitiesRequest->sessionInfoList.emplace_back(requestId, nullptr); - AddSpecifiedRequest(specifiedRequest); - continue; - } - HandleAbilitiesNormalSessionInfo(abilityRequest, abilitiesRequest, requestId); - } - - if (abilitiesRequest->doneCount < abilityRequestList.size()) { - return START_UI_ABILITIES_WAITING_SPECIFIED_CODE; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartUIAbilities normal, size: %{public}zu", abilityRequestList.size()); - ret = BatchNotifySCBPendingActivations(*abilitiesRequest); - for (auto &[id, sessionInfo] : abilitiesRequest->sessionInfoList) { - sessionInfo->want.RemoveAllFd(); - } - abilitiesRequestMap_.erase(requestListId); - return ret; -} - -int32_t UIAbilityLifecycleManager::HandleUIAbilityRequestList(std::vector &abilityRequestList) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call HandleUIAbilityRequestList"); - for (AbilityRequest &abilityRequest : abilityRequestList) { - if (!AddStartCallerTimestamp(abilityRequest.want.GetIntParam(Want::PARAM_RESV_CALLER_UID, -1))) { - return ERR_INVALID_VALUE; - } - abilityRequest.want.SetParam(IS_SHELL_CALL, AAFwk::PermissionVerification::GetInstance()->IsShellCall()); - std::string callerKey = std::to_string(IPCSkeleton::GetCallingPid()) + ":" + - std::to_string(IPCSkeleton::GetCallingUid()); - bool isCallerKilling = IN_PROCESS_CALL( - DelayedSingleton::GetInstance()->IsCallerKilling(callerKey)); - if (isCallerKilling) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "StartUIAbilities caller is killing"); - return ERR_INVALID_VALUE; - } - abilityRequest.want.SetParam(Want::PARAMS_REAL_CALLER_KEY, callerKey); - } - return ERR_OK; -} - -void UIAbilityLifecycleManager::HandleAbilitiesNormalSessionInfo(AbilityRequest &abilityRequest, - std::shared_ptr abilitiesRequest, int32_t requestId) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call HandleAbilitiesNormalSessionInfo"); - const auto &abilityInfo = abilityRequest.abilityInfo; - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->requestId = requestId; - sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse); - sessionInfo->userId = userId_; - sessionInfo->isAtomicService = (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - TAG_LOGI(AAFwkTag::ABILITYMGR, "Reused sessionId: %{public}d, userId: %{public}d, requestId: %{public}d", - sessionInfo->persistentId, userId_, requestId); - - abilitiesRequest->sessionInfoList.emplace_back(requestId, sessionInfo); - abilitiesRequest->doneCount++; -} - -int32_t UIAbilityLifecycleManager::BatchNotifySCBPendingActivations(const AbilitiesRequest &abilitiesRequest) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call BatchNotifySCBPendingActivations"); - std::vector> sessionInfoList; - for (const auto &[id, sessionInfo] : abilitiesRequest.sessionInfoList) { - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo nullptr"); - continue; - } - sessionInfoList.push_back(sessionInfo); - bool hasStartWindowOption = (sessionInfo->startWindowOption != nullptr); - bool hasStartWindow = hasStartWindowOption ? sessionInfo->startWindowOption->hasStartWindow : false; - std::string backgroundColor = - hasStartWindowOption ? sessionInfo->startWindowOption->startWindowBackgroundColor : ""; - TAG_LOGI(AAFwkTag::ABILITYMGR, "appCloneIndex:%{public}d, instanceKey:%{public}s, " - "hasStartWindow:%{public}d, backgroundColor:%{public}s", - (sessionInfo->want).GetIntParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0), sessionInfo->instanceKey.c_str(), - hasStartWindow, backgroundColor.c_str()); - } - - auto callerAbilityRecord = GetAbilityRecordByToken(abilitiesRequest.callerToken); - if (callerAbilityRecord == nullptr || callerAbilityRecord->GetRestartAppFlag()) { - auto tmpSceneSession = iface_cast(rootSceneSession_); - if (tmpSceneSession == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null tmpSceneSession, scb does not exist"); - return ERR_INVALID_VALUE; - } - for (auto sessionInfo : sessionInfoList) { - sessionInfo->canStartAbilityFromBackground = true; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, - "scb call, StartUIAbilities BatchPendingSessionsActivation for rootSceneSession"); - return static_cast(tmpSceneSession->BatchPendingSessionsActivation(sessionInfoList)); - } - auto callerSessionInfo = callerAbilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(callerSessionInfo, ERR_INVALID_VALUE); - CHECK_POINTER_AND_RETURN(callerSessionInfo->sessionToken, ERR_INVALID_VALUE); - auto callerSession = iface_cast(callerSessionInfo->sessionToken); - CHECK_POINTER_AND_RETURN(callerSession, ERR_INVALID_VALUE); - for (auto sessionInfo : sessionInfoList) { - CheckCallerFromBackground(callerAbilityRecord, sessionInfo); - auto requestId = sessionInfo->want.GetStringParam(KEY_REQUEST_ID); - if (!requestId.empty()) { - callerAbilityRecord->NotifyAbilityRequestSuccess(requestId, sessionInfo->want.GetElement()); - } - sessionInfo->want.RemoveParam(KEY_REQUEST_ID); - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, StartUIAbilities BatchPendingSessionsActivation for callerSession"); - return static_cast(callerSession->BatchPendingSessionsActivation(sessionInfoList)); -} - -void UIAbilityLifecycleManager::HandleAbilitiesRequestDone(int32_t requestId, int32_t requestListId, - sptr sessionInfo) -{ - auto it = abilitiesRequestMap_.find(requestListId); - if (it == abilitiesRequestMap_.end()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "requestListId: %{public}d not found", requestListId); - return; - } - auto abilitiesRequest = it->second; - CHECK_POINTER_LOG(abilitiesRequest, "abilitiesUIRequest nullptr"); - - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "startUIAbilities sessionInfo not exist."); - abilitiesRequestMap_.erase(it); - auto callerRecord = Token::GetAbilityRecordByToken(abilitiesRequest->callerToken); - if (callerRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "startUIAbilities callerRecord not exist."); - return; - } - callerRecord->NotifyAbilitiesRequestDone(abilitiesRequest->requestKey, - START_UI_ABILITIES_SPECIFIED_FAILED_ERROR); - return; - } - - abilitiesRequest->doneCount++; - auto &sessionInfoList = abilitiesRequest->sessionInfoList; - for (auto &item : sessionInfoList) { - if (item.first == requestId) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "requestdone %{public}d", requestId); - item.second = sessionInfo; - break; - } - } - if (abilitiesRequest->doneCount == sessionInfoList.size()) { - int32_t ret = BatchNotifySCBPendingActivations(*abilitiesRequest); - abilitiesRequestMap_.erase(it); - auto callerRecord = Token::GetAbilityRecordByToken(abilitiesRequest->callerToken); - if (callerRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "startUIAbilities callerRecord not exist."); - return; - } - callerRecord->NotifyAbilitiesRequestDone(abilitiesRequest->requestKey, ret); - } -} - -int32_t UIAbilityLifecycleManager::NotifySCBToRecoveryAfterInterception(const AbilityRequest &abilityRequest) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (IsStartSpecifiedProcessRequest(abilityRequest)) { - return StartSpecifiedProcessRequest(abilityRequest, nullptr); - } - const auto &abilityInfo = abilityRequest.abilityInfo; - auto isPlugin = StartupUtil::IsStartPlugin(abilityRequest.want); - auto isSpecified = (abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED); - if (isSpecified && !isPlugin) { - auto specifiedRequest = std::make_shared(RequestIdUtil::GetRequestId(), abilityRequest); - specifiedRequest->preCreateProcessName = true; - AddSpecifiedRequest(specifiedRequest); - return ERR_OK; - } - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse); - sessionInfo->userId = userId_; - sessionInfo->isAtomicService = (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - sessionInfo->want.SetParam("ohos.ability.params.isSkipErmsFromSCB", true); - TAG_LOGI( - AAFwkTag::ABILITYMGR, "Reused sessionId: %{public}d, userId: %{public}d.", sessionInfo->persistentId, userId_); - std::string errMsg; - int ret = NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); - sessionInfo->want.CloseAllFd(); - return ret; -} - -int UIAbilityLifecycleManager::NotifySCBToPreStartUIAbility(const AbilityRequest &abilityRequest, - sptr &sessionInfo) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - - std::lock_guard guard(sessionLock_); - sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->isAtomicService = true; - std::string errMsg; - return NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); -} - -int UIAbilityLifecycleManager::DispatchState(const std::shared_ptr &abilityRecord, int state) -{ - switch (state) { - case AbilityState::INITIAL: { - return DispatchTerminate(abilityRecord); - } - case AbilityState::BACKGROUND: - case AbilityState::BACKGROUND_FAILED: { - return DispatchBackground(abilityRecord); - } - case AbilityState::FOREGROUND: { - return DispatchForeground(abilityRecord, true); - } - case AbilityState::FOREGROUND_FAILED: - case AbilityState::FOREGROUND_INVALID_MODE: - case AbilityState::FOREGROUND_WINDOW_FREEZED: { - return DispatchForeground(abilityRecord, false, static_cast(state)); - } - default: { - TAG_LOGW(AAFwkTag::ABILITYMGR, "no support transiting state: %{public}d", state); - return ERR_INVALID_VALUE; - } - } -} - -int UIAbilityLifecycleManager::DispatchForeground(const std::shared_ptr &abilityRecord, bool success, - AbilityState state) -{ - auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); - CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler."); - auto taskHandler = DelayedSingleton::GetInstance()->GetTaskHandler(); - CHECK_POINTER_AND_RETURN_LOG(taskHandler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler."); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - - RemoveStartingPid(abilityRecord->GetPid()); - - if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, - "dispatchForeground ability transition error, expect %{public}d, actual %{public}d", - AbilityState::FOREGROUNDING, abilityRecord->GetAbilityState()); - return ERR_INVALID_VALUE; - } - - TAG_LOGD(AAFwkTag::ABILITYMGR, "ForegroundLifecycle: end."); - abilityRecord->RemoveForegroundTimeoutTask(); - g_deleteLifecycleEventTask(abilityRecord->GetToken()); - FreezeUtil::GetInstance().DeleteAppLifecycleEvent(abilityRecord->GetPid()); - auto self(weak_from_this()); - if (success) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "foreground succeeded."); - auto task = [self, abilityRecord]() { - auto selfObj = self.lock(); - if (!selfObj) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "mgr invalid"); - return; - } - selfObj->CompleteForegroundSuccess(abilityRecord); - }; - taskHandler->SubmitTask(task, TaskQoS::USER_INTERACTIVE); - } else { - auto task = [self, abilityRecord, state]() { - auto selfObj = self.lock(); - if (!selfObj) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "mission list mgr invalid"); - return; - } - if (state == AbilityState::FOREGROUND_WINDOW_FREEZED) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "window freezed"); - if (abilityRecord != nullptr) { - abilityRecord->SetAbilityState(AbilityState::BACKGROUND); - DelayedSingleton::GetInstance()->MoveToBackground(abilityRecord->GetToken()); - } - return; - } - selfObj->HandleForegroundFailed(abilityRecord, state); - }; - taskHandler->SubmitTask(task, TaskQoS::USER_INTERACTIVE); - } - return ERR_OK; -} - -int UIAbilityLifecycleManager::DispatchBackground(const std::shared_ptr &abilityRecord) -{ - auto handler = DelayedSingleton::GetInstance()->GetTaskHandler(); - CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler."); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - - if (!abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability transition error, actual %{public}d", - abilityRecord->GetAbilityState()); - return ERR_INVALID_VALUE; - } - - TAG_LOGD(AAFwkTag::ABILITYMGR, "end."); - // remove background timeout task. - handler->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId())); - g_deleteLifecycleEventTask(abilityRecord->GetToken()); - FreezeUtil::GetInstance().DeleteAppLifecycleEvent(abilityRecord->GetPid()); - auto self(shared_from_this()); - auto task = [self, abilityRecord]() { self->CompleteBackground(abilityRecord); }; - handler->SubmitTask(task, TaskQoS::USER_INTERACTIVE); - - return ERR_OK; -} - -int UIAbilityLifecycleManager::DispatchTerminate(const std::shared_ptr &abilityRecord) -{ - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - if (abilityRecord->GetAbilityState() != AbilityState::TERMINATING) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "error, abilityState: %{public}d", - abilityRecord->GetAbilityState()); - return INNER_ERR; - } - - // remove terminate timeout task. - auto handler = DelayedSingleton::GetInstance()->GetTaskHandler(); - CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler."); - handler->CancelTask("terminate_" + std::to_string(abilityRecord->GetAbilityRecordId())); - auto self(shared_from_this()); - auto task = [self, abilityRecord]() { self->CompleteTerminate(abilityRecord); }; - handler->SubmitTask(task, TaskQoS::USER_INTERACTIVE); - - return ERR_OK; -} - -void UIAbilityLifecycleManager::CompleteForegroundSuccess(const std::shared_ptr &abilityRecord) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - - CHECK_POINTER(abilityRecord); - // ability do not save window mode - abilityRecord->RemoveWindowMode(); - std::string element = abilityRecord->GetElementName().GetURI(); - TAG_LOGD(AAFwkTag::ABILITYMGR, "ability: %{public}s", element.c_str()); - abilityRecord->SetAbilityState(AbilityState::FOREGROUND); - abilityRecord->UpdateAbilityVisibilityState(); - AbilityStartWithWaitObserverManager::GetInstance().NotifyAATerminateWait(abilityRecord); - - // new version. started by caller, scheduler call request - if (abilityRecord->IsStartedByCall() && abilityRecord->IsStartToForeground() && abilityRecord->IsReady()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "call request after completing foreground state"); - abilityRecord->CallRequest(); - abilityRecord->SetStartToForeground(false); - } - - if (abilityRecord->HasLastWant()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "has last want"); - abilityRecord->ForegroundAbility(0, true); - } else if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) { - abilityRecord->SetMinimizeReason(true); - MoveToBackground(abilityRecord); - } else if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "not continuous startup."); - abilityRecord->SetPendingState(AbilityState::INITIAL); - } - if (handler_ != nullptr && abilityRecord->GetSessionInfo() != nullptr) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "OnSessionMovedToFront() called"); - handler_->OnSessionMovedToFront(abilityRecord->GetSessionInfo()->persistentId); - } -} - -void UIAbilityLifecycleManager::HandleForegroundFailed(const std::shared_ptr &ability, - AbilityState state) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "state: %{public}d.", static_cast(state)); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (ability == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - - if (!ability->IsAbilityState(AbilityState::FOREGROUNDING)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not foregrounding"); - return; - } - std::shared_ptr abilityRecord = ability; - AbilityStartWithWaitObserverManager::GetInstance().NotifyAATerminateWait( - abilityRecord, TerminateReason::TERMINATE_FOR_UI_ABILITY_FOREGROUND_FAILED); - - NotifySCBToHandleException(ability, - static_cast(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleForegroundTimeout"); - PrepareCloseUIAbility(ability, 0, nullptr, false); - CloseUIAbilityInner(ability); -} - -std::shared_ptr UIAbilityLifecycleManager::GetAbilityRecordByToken(const sptr &token) - const -{ - if (token == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null"); - return nullptr; - } - - for (auto ability : terminateAbilityList_) { - if (ability && token == ability->GetToken()->AsObject()) { - return ability; - } - } - - for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) { - if (iter->second != nullptr && iter->second->GetToken()->AsObject() == token) { - return iter->second; - } - } - return nullptr; -} - -#ifdef SUPPORT_SCREEN -void UIAbilityLifecycleManager::CompleteFirstFrameDrawing(const sptr &token) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (token == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null"); - return; - } - std::lock_guard guard(sessionLock_); - if (!IsContainsAbilityInner(token)) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "Not in running list"); - return; - } - auto abilityRecord = GetAbilityRecordByToken(token); - CHECK_POINTER(abilityRecord); - if (abilityRecord->IsCompleteFirstFrameDrawing()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "First frame drawing has completed."); - return; - } - abilityRecord->ReportAtomicServiceDrawnCompleteEvent(); - abilityRecord->SetCompleteFirstFrameDrawing(true); - AbilityStartWithWaitObserverManager::GetInstance().NotifyAATerminateWait(abilityRecord); - AppExecFwk::AbilityFirstFrameStateObserverManager::GetInstance(). - HandleOnFirstFrameState(abilityRecord); -} -#endif - -bool UIAbilityLifecycleManager::IsContainsAbility(const sptr &token) const -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - return IsContainsAbilityInner(token); -} - -bool UIAbilityLifecycleManager::IsContainsAbilityInner(const sptr &token) const -{ - for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) { - if (iter->second != nullptr && iter->second->GetToken()->AsObject() == token) { - return true; - } - } - return false; -} - -void UIAbilityLifecycleManager::EraseAbilityRecord(const std::shared_ptr &abilityRecord) -{ - if (abilityRecord == nullptr) { - return; - } - - for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) { - if (iter->second != nullptr && iter->second->GetToken()->AsObject() == abilityRecord->GetToken()->AsObject()) { - sessionAbilityMap_.erase(iter); - break; - } - } - for (auto iter = lowMemKillAbilityMap_.begin(); iter != lowMemKillAbilityMap_.end(); iter++) { - if (iter->second != nullptr && iter->second->GetToken()->AsObject() == abilityRecord->GetToken()->AsObject()) { - lowMemKillAbilityMap_.erase(iter); - break; - } - } - callRequestCache_.erase(abilityRecord); -} - -std::string UIAbilityLifecycleManager::GenerateProcessNameForNewProcessMode(const AppExecFwk::AbilityInfo& abilityInfo) -{ - static uint32_t index = 0; - std::string processName = abilityInfo.bundleName + SEPARATOR + abilityInfo.moduleName + SEPARATOR + - abilityInfo.name + SEPARATOR + std::to_string(index++); - TAG_LOGI(AAFwkTag::ABILITYMGR, "processName: %{public}s", processName.c_str()); - return processName; -} - -void UIAbilityLifecycleManager::PreCreateProcessName(AbilityRequest &abilityRequest) -{ - if (abilityRequest.processOptions == nullptr || - !ProcessOptions::IsNewProcessMode(abilityRequest.processOptions->processMode)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "No need to pre create process name."); - return; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "create process name in advance"); - std::string processName = GenerateProcessNameForNewProcessMode(abilityRequest.abilityInfo); - abilityRequest.processOptions->processName = processName; - abilityRequest.abilityInfo.process = processName; -} - -void UIAbilityLifecycleManager::UpdateProcessName(const AbilityRequest &abilityRequest, - std::shared_ptr &abilityRecord) -{ - if (abilityRecord == nullptr || abilityRequest.sessionInfo == nullptr || - abilityRequest.sessionInfo->processOptions == nullptr || - !ProcessOptions::IsNewProcessMode(abilityRequest.sessionInfo->processOptions->processMode)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "No need to update process name."); - return; - } - std::string processName; - if (!abilityRequest.sessionInfo->processOptions->processName.empty()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "The process name has been generated in advance."); - processName = abilityRequest.sessionInfo->processOptions->processName; - } else { - processName = GenerateProcessNameForNewProcessMode(abilityRequest.abilityInfo); - } - abilityRecord->SetProcessName(processName); - abilityRecord->SetCallerSetProcess(true); -} - -void UIAbilityLifecycleManager::UpdateAbilityRecordLaunchReason( - const AbilityRequest &abilityRequest, std::shared_ptr &abilityRecord) const -{ - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null input record"); - return; - } - - std::string value = abilityRequest.want.GetStringParam(Want::PARM_LAUNCH_REASON_MESSAGE); - if (!value.empty()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "set launchReasonMessage:%{public}s", value.c_str()); - abilityRecord->SetLaunchReasonMessage(value); - } - if (abilityRequest.IsAppRecovery() || abilityRecord->GetRecoveryInfo()) { - abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_APP_RECOVERY); - return; - } - - auto res = abilityRequest.IsContinuation(); - if (res.first) { - abilityRecord->SetLaunchReason(res.second); - return; - } - - if (abilityRequest.IsAcquireShareData()) { - abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_SHARE); - return; - } - - if (abilityRequest.processOptions != nullptr && abilityRequest.processOptions->isPreloadStart) { - abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_PRELOAD); - return; - } - - abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_START_ABILITY); - return; -} - -std::shared_ptr UIAbilityLifecycleManager::GetUIAbilityRecordBySessionInfo( - const sptr &sessionInfo) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - CHECK_POINTER_AND_RETURN(sessionInfo, nullptr); - CHECK_POINTER_AND_RETURN(sessionInfo->sessionToken, nullptr); - auto sessionToken = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER_AND_RETURN(sessionToken, nullptr); - std::string descriptor = Str16ToStr8(sessionToken->GetDescriptor()); - if (descriptor != "OHOS.ISession") { - TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, descriptor: %{public}s", - descriptor.c_str()); - return nullptr; - } - - auto iter = sessionAbilityMap_.find(sessionInfo->persistentId); - if (iter != sessionAbilityMap_.end()) { - return iter->second; - } - return nullptr; -} - -int32_t UIAbilityLifecycleManager::NotifySCBToMinimizeUIAbility(const sptr token) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "notifySCBToMinimizeUIAbility"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - auto sceneSessionManager = Rosen::SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); - CHECK_POINTER_AND_RETURN(sceneSessionManager, ERR_NULL_OBJECT); - Rosen::WSError ret = sceneSessionManager->PendingSessionToBackgroundForDelegator(token); - if (ret != Rosen::WSError::WS_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "call error:%{public}d", ret); - } - return static_cast(ret); -} - -int UIAbilityLifecycleManager::MinimizeUIAbility(const std::shared_ptr &abilityRecord, bool fromUser, - uint32_t sceneFlag) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return ERR_INVALID_VALUE; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "infoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str()); - abilityRecord->SetMinimizeReason(fromUser); - abilityRecord->SetSceneFlag(sceneFlag); - if (abilityRecord->GetPendingState() != AbilityState::INITIAL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "pending state: FOREGROUND/ BACKGROUND, dropped"); - abilityRecord->SetPendingState(AbilityState::BACKGROUND); - return ERR_OK; - } - if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not foreground: %{public}d", - abilityRecord->GetAbilityState()); - return ERR_OK; - } - abilityRecord->SetPendingState(AbilityState::BACKGROUND); - MoveToBackground(abilityRecord); - abilityRecord->SetSceneFlag(0); - return ERR_OK; -} - -void UIAbilityLifecycleManager::MoveToBackground(const std::shared_ptr &abilityRecord) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - abilityRecord->SetIsNewWant(false); - auto self(weak_from_this()); - auto task = [abilityRecord, self]() { - auto selfObj = self.lock(); - if (selfObj == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "UIAbilityLifecycleManager invalid"); - return; - } - TAG_LOGE(AAFwkTag::ABILITYMGR, "move to background timeout"); - selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG); - selfObj->CompleteBackground(abilityRecord); - }; - abilityRecord->BackgroundAbility(task); -} - -int UIAbilityLifecycleManager::ResolveLocked(const AbilityRequest &abilityRequest, std::string &errMsg) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "ByCall, ability:%{public}s", abilityRequest.want.GetElement().GetURI().c_str()); - - if (!abilityRequest.IsCallType(AbilityCallType::CALL_REQUEST_TYPE)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s, resolve ability_name:", __func__); - errMsg = "ability type error"; - return RESOLVE_CALL_ABILITY_INNER_ERR; - } - - return CallAbilityLocked(abilityRequest, errMsg); -} - -bool UIAbilityLifecycleManager::IsAbilityStarted(AbilityRequest &abilityRequest, - std::shared_ptr &targetRecord) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - std::lock_guard guard(sessionLock_); - bool reuse = false; - auto persistentId = GetPersistentIdByAbilityRequest(abilityRequest, reuse); - if (persistentId == 0) { - return false; - } - targetRecord = sessionAbilityMap_.at(persistentId); - if (targetRecord && targetRecord->GetScheduler() != nullptr) { - targetRecord->AddCallerRecord(abilityRequest.callerToken, abilityRequest.requestCode, abilityRequest.want); - targetRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CALL); - return true; - } - - return false; -} - -int UIAbilityLifecycleManager::CallAbilityLocked(const AbilityRequest &abilityRequest, std::string &errMsg) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "CallAbilityLocked"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - - // Get target uiAbility record. - std::shared_ptr uiAbilityRecord; - bool reuse = false; - auto persistentId = GetPersistentIdByAbilityRequest(abilityRequest, reuse); - if (persistentId == 0) { - uiAbilityRecord = FindRecordFromTmpMap(abilityRequest); - if (uiAbilityRecord != nullptr) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "cache call request"); - callRequestCache_[uiAbilityRecord].push_back(abilityRequest); - return ERR_OK; - } - uiAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); - uiAbilityRecord->SetOwnerMissionUserId(userId_); - SetReceiverInfo(abilityRequest, uiAbilityRecord); - } else { - uiAbilityRecord = sessionAbilityMap_.at(persistentId); - } - uiAbilityRecord->AddCallerRecord(abilityRequest.callerToken, abilityRequest.requestCode, abilityRequest.want); - uiAbilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CALL); - -#ifdef SUPPORT_UPMS - if (InsightIntentExecuteParam::IsInsightIntentExecute(abilityRequest.want)) { - uiAbilityRecord->GrantUriPermission(); - } -#endif // SUPPORT_UPMS - - std::string value = abilityRequest.want.GetStringParam(Want::PARM_LAUNCH_REASON_MESSAGE); - if (!value.empty()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "set launchReasonMessage:%{public}s", value.c_str()); - uiAbilityRecord->SetLaunchReasonMessage(value); - } - NotifyAbilityToken(uiAbilityRecord->GetToken(), abilityRequest); - - // new version started by call type - const auto& abilityInfo = abilityRequest.abilityInfo; - auto ret = ResolveAbility(uiAbilityRecord, abilityRequest); - if (ret == ResolveResultType::OK_HAS_REMOTE_OBJ || (ret == ResolveResultType::OK_NO_REMOTE_OBJ && - persistentId != 0)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "target ability has been resolved: %{public}d", ret); - if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "target ability needs to be switched to foreground."); - auto sessionInfo = CreateSessionInfo(abilityRequest); - if ((persistentId != 0) && abilityRequest.want.GetBoolParam(IS_CALLING_FROM_DMS, false)) { - HandleForegroundCollaborate(abilityRequest, uiAbilityRecord); - } - sessionInfo->persistentId = persistentId; - sessionInfo->state = CallToState::FOREGROUND; - sessionInfo->reuse = reuse; - sessionInfo->uiAbilityId = uiAbilityRecord->GetAbilityRecordId(); - sessionInfo->isAtomicService = - (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - if (uiAbilityRecord->GetPendingState() != AbilityState::INITIAL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "pending state: FOREGROUND/ BACKGROUND, dropped"); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - return NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); - } - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - uiAbilityRecord->ProcessForegroundAbility(sessionInfo->callingTokenId); - return NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); - } else { - if ((persistentId != 0) && abilityRequest.want.GetBoolParam(IS_CALLING_FROM_DMS, false)) { - uiAbilityRecord->ScheduleCollaborate(abilityRequest.want); - } - } - return ERR_OK; - } else if (ret == ResolveResultType::NG_INNER_ERROR) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "resolve failed, error: %{public}d", RESOLVE_CALL_ABILITY_INNER_ERR); - return RESOLVE_CALL_ABILITY_INNER_ERR; - } - - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->persistentId = persistentId; - sessionInfo->reuse = reuse; - sessionInfo->uiAbilityId = uiAbilityRecord->GetAbilityRecordId(); - sessionInfo->isAtomicService = (abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - sessionInfo->requestId = RequestIdUtil::GetRequestId(); - if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) { - sessionInfo->state = CallToState::FOREGROUND; - } else { - sessionInfo->state = CallToState::BACKGROUND; - sessionInfo->needClearInNotShowRecent = true; - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "Notify scb's abilityId is %{public}" PRIu64 ".", sessionInfo->uiAbilityId); - tmpAbilityMap_.emplace(sessionInfo->requestId, uiAbilityRecord); - PostCallTimeoutTask(sessionInfo->requestId); - return NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); -} - -void UIAbilityLifecycleManager::PostCallTimeoutTask(int32_t requestId) -{ - auto timeoutTask = [wThis = weak_from_this(), requestId]() { - auto pThis = wThis.lock(); - if (pThis != nullptr) { - std::string reason = "Timeout cleanup"; - pThis->NotifyStartupExceptionBySCB(requestId, reason); - } - }; - - int timeout = AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * - GlobalConstant::COLDSTART_TIMEOUT_MULTIPLE * GlobalConstant::TIMEOUT_UNIT_TIME; - ffrt::submit(std::move(timeoutTask), ffrt::task_attr().delay(timeout) - .timeout(GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); -} - -void UIAbilityLifecycleManager::CallUIAbilityBySCB(const sptr &sessionInfo, bool &isColdStart) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, CallUIAbilityBySCB"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - CHECK_POINTER_LOG(sessionInfo, "sessionInfo is invalid."); - CHECK_POINTER_LOG(sessionInfo->sessionToken, "sessionToken is nullptr."); - auto sessionToken = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER_LOG(sessionToken, "sessionToken is nullptr."); - auto descriptor = Str16ToStr8(sessionToken->GetDescriptor()); - if (descriptor != "OHOS.ISession") { - TAG_LOGE(AAFwkTag::ABILITYMGR, "token's Descriptor: %{public}s", descriptor.c_str()); - return; - } - - TAG_LOGD(AAFwkTag::ABILITYMGR, "SCB output abilityId is %{public}" PRIu64 ".", sessionInfo->uiAbilityId); - auto search = tmpAbilityMap_.find(sessionInfo->requestId); - if (search == tmpAbilityMap_.end()) { - if (sessionInfo->uiAbilityId == 0 && tmpAbilityMap_.size() == 1) { - search = tmpAbilityMap_.begin(); - } else { - TAG_LOGW(AAFwkTag::ABILITYMGR, "not find UIAbility"); - return; - } - } - auto uiAbilityRecord = search->second; - tmpAbilityMap_.erase(search); - CHECK_POINTER_LOG(uiAbilityRecord, "UIAbility not exist."); - auto sessionSearch = sessionAbilityMap_.find(sessionInfo->persistentId); - if (sessionSearch != sessionAbilityMap_.end()) { - // ability could be in loading state, waiting for callback - TAG_LOGI(AAFwkTag::ABILITYMGR, "session exist"); - return; - } - isColdStart = true; - uiAbilityRecord->SetInstanceKey(sessionInfo->instanceKey); - - MoreAbilityNumbersSendEventInfo(sessionInfo->userId, sessionInfo->want.GetElement().GetBundleName(), - sessionInfo->want.GetElement().GetAbilityName(), sessionInfo->want.GetElement().GetModuleName()); - - sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord); - uiAbilityRecord->SetSessionInfo(sessionInfo); - if (sessionInfo->state == CallToState::BACKGROUND) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "set pending BACKGROUND"); - uiAbilityRecord->SetPendingState(AbilityState::BACKGROUND); - } else { - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - } - uiAbilityRecord->LoadAbility(); -} - -sptr UIAbilityLifecycleManager::CreateSessionInfo(const AbilityRequest &abilityRequest) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Create session."); - sptr sessionInfo = new SessionInfo(); - sessionInfo->callerToken = abilityRequest.callerToken; - sessionInfo->want = abilityRequest.want; - sessionInfo->processOptions = abilityRequest.processOptions; - sessionInfo->startWindowOption = abilityRequest.startWindowOption; - sessionInfo->supportWindowModes = abilityRequest.supportWindowModes; - if (abilityRequest.startSetting != nullptr) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "Assign start setting to session."); - sessionInfo->startSetting = abilityRequest.startSetting; - } - sessionInfo->callingTokenId = static_cast(abilityRequest.want.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN, - IPCSkeleton::GetCallingTokenID())); - sessionInfo->instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - return sessionInfo; -} - -int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr &sessionInfo, - const AbilityRequest &abilityRequest, std::string &errMsg) -{ - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is nullptr"); - errMsg = "sessionInfo is nullptr"; - return ERR_INVALID_VALUE; - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "windowTop=%{public}d,windowHeight=%{public}d," - "windowMode=%{public}d,supportWindowModes.size=%{public}zu,specifiedFlag=%{public}s", - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_TOP, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_HEIGHT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_MODE, 0), - (sessionInfo->supportWindowModes).size(), sessionInfo->specifiedFlag.c_str()); - bool hasStartWindowOption = (sessionInfo->startWindowOption != nullptr); - bool hasStartWindow = hasStartWindowOption ? sessionInfo->startWindowOption->hasStartWindow : false; - std::string backgroundColor = - hasStartWindowOption ? sessionInfo->startWindowOption->startWindowBackgroundColor : ""; - sessionInfo->hideStartWindow = abilityRequest.hideStartWindow; - sessionInfo->windowCreateParams = abilityRequest.startOptions.windowCreateParams_; - TAG_LOGI(AAFwkTag::ABILITYMGR, "appCloneIndex:%{public}d, instanceKey:%{public}s, " - "hasStartWindow:%{public}d, backgroundColor:%{public}s, hideStartWindow: %{public}d", - (sessionInfo->want).GetIntParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0), sessionInfo->instanceKey.c_str(), - hasStartWindow, backgroundColor.c_str(), sessionInfo->hideStartWindow); - auto abilityRecord = GetAbilityRecordByToken(abilityRequest.callerToken); - if (abilityRecord != nullptr && !abilityRecord->GetRestartAppFlag()) { - auto callerSessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(callerSessionInfo, ERR_INVALID_VALUE); - CHECK_POINTER_AND_RETURN(callerSessionInfo->sessionToken, ERR_INVALID_VALUE); - auto callerSession = iface_cast(callerSessionInfo->sessionToken); - CHECK_POINTER_AND_RETURN(callerSession, ERR_INVALID_VALUE); - CheckCallerFromBackground(abilityRecord, sessionInfo); - auto requestId = abilityRequest.want.GetStringParam(KEY_REQUEST_ID); - if (!requestId.empty()) { - abilityRecord->NotifyAbilityRequestSuccess(requestId, abilityRequest.want.GetElement()); - } - const_cast(abilityRequest).want.RemoveParam(KEY_REQUEST_ID); - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for callerSession, target: %{public}s" - "requestId:%{public}s", sessionInfo->want.GetElement().GetAbilityName().c_str(), requestId.c_str()); - auto ret = static_cast(callerSession->PendingSessionActivation(sessionInfo)); - if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "PendingSessionActivation failed:%{public}d", ret); - } - return ret; - } - auto tmpSceneSession = iface_cast(rootSceneSession_); - if (tmpSceneSession == nullptr) { - errMsg = "null tmpSceneSession, scb does not exist"; - TAG_LOGE(AAFwkTag::ABILITYMGR, "%{public}s", errMsg.c_str()); - return ERR_INVALID_VALUE; - } - abilityRecord = Token::GetAbilityRecordByToken(abilityRequest.callerToken); - if (abilityRecord != nullptr) { - auto requestId = abilityRequest.want.GetStringParam(KEY_REQUEST_ID); - if (!requestId.empty()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "notify request success, requestId:%{public}s", requestId.c_str()); - abilityRecord->NotifyAbilityRequestSuccess(requestId, abilityRequest.want.GetElement()); - } - const_cast(abilityRequest).want.RemoveParam(KEY_REQUEST_ID); - } - sessionInfo->canStartAbilityFromBackground = true; - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for rootSceneSession, target: %{public}s", - sessionInfo->want.GetElement().GetAbilityName().c_str()); - auto ret = static_cast(tmpSceneSession->PendingSessionActivation(sessionInfo)); - if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "PendingSessionActivation failed:%{public}d", ret); - } - return ret; -} - -bool UIAbilityLifecycleManager::IsHookModule(const AbilityRequest &abilityRequest) const -{ - AppExecFwk::HapModuleInfo hapModuleInfo; - if (DelayedSingleton::GetInstance()->GetHapModuleInfo( - abilityRequest.abilityInfo, hapModuleInfo)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "module:%{public}s, ability:%{public}s", - hapModuleInfo.abilityStageSrcEntryDelegator.c_str(), hapModuleInfo.abilitySrcEntryDelegator.c_str()); - if (hapModuleInfo.abilitySrcEntryDelegator.empty() || hapModuleInfo.abilityStageSrcEntryDelegator.empty()) { - return false; - } - if (hapModuleInfo.abilityStageSrcEntryDelegator == hapModuleInfo.moduleName) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "not support"); - return false; - } - Want want; - want.SetElementName("", hapModuleInfo.bundleName, hapModuleInfo.abilitySrcEntryDelegator, - hapModuleInfo.abilityStageSrcEntryDelegator); - AppExecFwk::AbilityInfo abilityInfo; - if (!IN_PROCESS_CALL(DelayedSingleton::GetInstance()->QueryAbilityInfo( - want, AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION, userId_, abilityInfo))) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "Query hookAbilityInfo fail"); - return false; - } - return true; - } - return false; -} - -int UIAbilityLifecycleManager::ResolveAbility( - const std::shared_ptr &targetAbility, const AbilityRequest &abilityRequest) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "targetAbilityRecord resolve call record."); - CHECK_POINTER_AND_RETURN(targetAbility, ResolveResultType::NG_INNER_ERROR); - - ResolveResultType result = targetAbility->Resolve(abilityRequest); - switch (result) { - case ResolveResultType::NG_INNER_ERROR: - case ResolveResultType::OK_HAS_REMOTE_OBJ: - return result; - default: - break; - } - - if (targetAbility->IsReady()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "targetAbility is ready, directly scheduler call request."); - targetAbility->CallRequest(); - return ResolveResultType::OK_HAS_REMOTE_OBJ; - } - - TAG_LOGD(AAFwkTag::ABILITYMGR, "targetAbility need to call request after lifecycle."); - return result; -} - -void UIAbilityLifecycleManager::NotifyAbilityToken(const sptr &token, - const AbilityRequest &abilityRequest) const -{ - auto abilityInfoCallback = iface_cast(abilityRequest.abilityInfoCallback); - if (abilityInfoCallback != nullptr) { - abilityInfoCallback->NotifyAbilityToken(token, abilityRequest.want); - } -} - -void UIAbilityLifecycleManager::PrintTimeOutLog(std::shared_ptr ability, uint32_t msgId, bool isHalf) -{ - CHECK_POINTER_LOG(ability, "null ability"); - AppExecFwk::RunningProcessInfo processInfo = {}; - DelayedSingleton::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo); - if (processInfo.pid_ == 0) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability:%{public}s, app fork fail/ not run", - ability->GetAbilityInfo().name.data()); - return; - } - int typeId = AppExecFwk::AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT; - std::string msgContent = "ability:" + ability->GetAbilityInfo().name + " "; - if (!GetContentAndTypeId(msgId, msgContent, typeId)) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "msgId invalid"); - return; - } - - std::string eventName = isHalf ? - AppExecFwk::AppFreezeType::LIFECYCLE_HALF_TIMEOUT : AppExecFwk::AppFreezeType::LIFECYCLE_TIMEOUT; - TAG_LOGW(AAFwkTag::ABILITYMGR, "%{public}s: uid: %{public}d, pid: %{public}d, bundleName: %{public}s, " - "abilityName: %{public}s, msg: %{public}s", - eventName.c_str(), processInfo.uid_, processInfo.pid_, ability->GetAbilityInfo().bundleName.c_str(), - ability->GetAbilityInfo().name.c_str(), msgContent.c_str()); - - AppExecFwk::AppfreezeManager::ParamInfo info = { - .typeId = typeId, - .pid = processInfo.pid_, - .eventName = eventName, - .bundleName = ability->GetAbilityInfo().bundleName, - }; - FreezeUtil::TimeoutState state = TimeoutStateUtils::MsgId2FreezeTimeOutState(msgId); - FreezeUtil::LifecycleFlow flow; - if (state != FreezeUtil::TimeoutState::UNKNOWN) { - if (ability->GetToken() != nullptr) { - flow.token = ability->GetToken()->AsObject(); - flow.state = state; - } - info.msg = msgContent + "\nserver actions for ability:\n" + - FreezeUtil::GetInstance().GetLifecycleEvent(flow.token) - + "\nserver actions for app:\n" + FreezeUtil::GetInstance().GetAppLifecycleEvent(processInfo.pid_); - if (!isHalf) { - FreezeUtil::GetInstance().DeleteLifecycleEvent(flow.token); - FreezeUtil::GetInstance().DeleteAppLifecycleEvent(processInfo.pid_); - } - } else { - info.msg = msgContent; - } - AppExecFwk::AppfreezeManager::GetInstance()->LifecycleTimeoutHandle(info, flow); -} - -bool UIAbilityLifecycleManager::GetContentAndTypeId(uint32_t msgId, std::string &msgContent, int &typeId) const -{ - switch (msgId) { - case AbilityManagerService::LOAD_TIMEOUT_MSG: - msgContent += "load timeout."; - typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT; - break; - case AbilityManagerService::FOREGROUND_TIMEOUT_MSG: - msgContent += "foreground timeout."; - typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT; - break; - case AbilityManagerService::BACKGROUND_TIMEOUT_MSG: - msgContent += "background timeout."; - break; - case AbilityManagerService::TERMINATE_TIMEOUT_MSG: - msgContent += "terminate timeout."; - break; - default: - return false; - } - return true; -} - -void UIAbilityLifecycleManager::CompleteBackground(const std::shared_ptr &abilityRecord) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - CHECK_POINTER(abilityRecord); - if (abilityRecord->GetAbilityState() != AbilityState::BACKGROUNDING) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, state: %{public}d, not complete background", - abilityRecord->GetAbilityState()); - return; - } - abilityRecord->SetAbilityState(AbilityState::BACKGROUND); - // notify AppMS to update application state. - DelayedSingleton::GetInstance()->MoveToBackground(abilityRecord->GetToken()); - - if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) { - abilityRecord->PostForegroundTimeoutTask(); - abilityRecord->SetAbilityState(AbilityState::FOREGROUNDING); - abilityRecord->SetBackgroundDrivenFlag(abilityRecord->HasLastWant()); - DelayedSingleton::GetInstance()->MoveToForeground(abilityRecord->GetToken()); - } else if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "not continuous startup."); - abilityRecord->SetPendingState(AbilityState::INITIAL); - } - - // new version. started by caller, scheduler call request - if (abilityRecord->IsStartedByCall() && abilityRecord->IsStartToBackground() && abilityRecord->IsReady()) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "call request after completing background state"); - abilityRecord->CallRequest(); - abilityRecord->SetStartToBackground(false); - } - - // Abilities ahead of the one started were put in terminate list, we need to terminate them. - auto self(shared_from_this()); - for (auto terminateAbility : terminateAbilityList_) { - if (terminateAbility->GetAbilityState() == AbilityState::BACKGROUND) { - auto timeoutTask = [terminateAbility, self]() { - TAG_LOGW(AAFwkTag::ABILITYMGR, "terminate ability timeout"); - self->DelayCompleteTerminate(terminateAbility); - }; - terminateAbility->Terminate(timeoutTask); - } - } -} - -int32_t UIAbilityLifecycleManager::BackToCallerAbilityWithResult(std::shared_ptr abilityRecord, - int resultCode, const Want *resultWant, int64_t callerRequestCode) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null abilityRecord"); - return ERR_INVALID_VALUE; - } - auto requestInfo = StartupUtil::ParseFullRequestCode(callerRequestCode); - TAG_LOGI(AAFwkTag::ABILITYMGR, "pid:%{public}d, backFlag:%{public}d, requestCode:%{public}d", - requestInfo.pid, requestInfo.backFlag, requestInfo.requestCode); - if (requestInfo.requestCode <= 0 || requestInfo.pid <= 0) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "no find caller by requestCode"); - return ERR_CALLER_NOT_EXISTS; - } - auto callerAbilityRecord = abilityRecord->GetCallerByRequestCode(requestInfo.requestCode, requestInfo.pid); - if (callerAbilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller not exist"); - return ERR_CALLER_NOT_EXISTS; - } - auto abilityResult = std::make_shared(requestInfo.requestCode, resultCode, *resultWant); - callerAbilityRecord->SendResultByBackToCaller(abilityResult); - abilityRecord->RemoveCallerRequestCode(callerAbilityRecord, requestInfo.requestCode); - if (!requestInfo.backFlag) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "not back to caller"); - return ERR_NOT_SUPPORT_BACK_TO_CALLER; - } - if (callerAbilityRecord == abilityRecord) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "caller is self"); - return ERR_OK; - } - auto tokenId = abilityRecord->GetAbilityInfo().applicationInfo.accessTokenId; - TAG_LOGD(AAFwkTag::ABILITYMGR, "tokenId: %{public}d.", tokenId); - if (!abilityRecord->IsForeground() && !abilityRecord->GetAbilityForegroundingFlag() && - !PermissionVerification::GetInstance()->VerifyPermissionByTokenId(tokenId, - PermissionConstants::PERMISSION_START_ABILITIES_FROM_BACKGROUND)) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "no call ability"); - return CHECK_PERMISSION_FAILED; - } - // find host of UI Extension - auto foundCount = 0; - while (((++foundCount) <= MAX_FIND_UIEXTENSION_CALLER_TIMES) && callerAbilityRecord && - UIExtensionUtils::IsUIExtension(callerAbilityRecord->GetAbilityInfo().extensionAbilityType)) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "caller uiExtension"); - callerAbilityRecord = callerAbilityRecord->GetCallerRecord(); - } - return BackToCallerAbilityWithResultLocked(abilityRecord->GetSessionInfo(), callerAbilityRecord); -} - -int32_t UIAbilityLifecycleManager::BackToCallerAbilityWithResultLocked(sptr currentSessionInfo, - std::shared_ptr callerAbilityRecord) -{ - if (currentSessionInfo == nullptr || currentSessionInfo->sessionToken == nullptr) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "currentSessionInfo invalid"); - return ERR_INVALID_VALUE; - } - - if (callerAbilityRecord == nullptr) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "callerAbility invalid"); - return ERR_INVALID_VALUE; - } - - auto callerSessionInfo = callerAbilityRecord->GetSessionInfo(); - if (callerSessionInfo == nullptr || callerSessionInfo->sessionToken == nullptr) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "callerSessionInfo invalid"); - return ERR_INVALID_VALUE; - } - - std::string callerBundleName = currentSessionInfo->want.GetBundle(); - std::string currentName = callerAbilityRecord->GetApplicationInfo().bundleName; - EventInfo eventInfo = { .bundleName = currentName, .callerBundleName = callerBundleName, .uri = "backToCaller"}; - EventReport::SendGrantUriPermissionEvent(EventName::GRANT_URI_PERMISSION, eventInfo); - - auto currentSession = iface_cast(currentSessionInfo->sessionToken); - callerSessionInfo->isBackTransition = true; - callerSessionInfo->want.SetParam(ServerConstant::IS_CALL_BY_SCB, false); - callerSessionInfo->scenarios = ServerConstant::SCENARIO_BACK_TO_CALLER_ABILITY_WITH_RESULT; - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, backToCaller"); - auto ret = static_cast(currentSession->PendingSessionActivation(callerSessionInfo)); - callerSessionInfo->isBackTransition = false; - return ret; -} - -int UIAbilityLifecycleManager::CloseUIAbility(const std::shared_ptr &abilityRecord, - int resultCode, const Want *resultWant, bool isClearSession, bool isIndependentRecovery) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_UI_ABILITY_MANAGER_NULL_ABILITY_RECORD); - std::string element = abilityRecord->GetElementName().GetURI(); - TAG_LOGI(AAFwkTag::ABILITYMGR, "CloseUIAbility call: %{public}s", element.c_str()); - if (abilityRecord->IsTerminating() && !abilityRecord->IsForeground()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "ability on terminating"); - return ERR_OK; - } - PrepareCloseUIAbility(abilityRecord, resultCode, resultWant, isClearSession); - if (abilityRecord->GetAbilityState() == AbilityState::INITIAL) { - if (abilityRecord->GetScheduler() == nullptr) { - auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); - CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler."); - abilityRecord->RemoveLoadTimeoutTask(); - } - terminateAbilityList_.remove(abilityRecord); - return abilityRecord->TerminateAbility(); - } - if (abilityRecord->IsDebug() && isClearSession) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "notify AppMS terminate"); - terminateAbilityList_.remove(abilityRecord); - return abilityRecord->TerminateAbility(); - } - if (abilityRecord->GetPendingState() != AbilityState::INITIAL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "pending state: FOREGROUND/ BACKGROUND, dropped. independentRecovery:%{public}d", - isIndependentRecovery); - abilityRecord->SetPendingState(AbilityState::BACKGROUND); - if (!isIndependentRecovery) { - return ERR_OK; - } - abilityRecord->RemoveForegroundTimeoutTask(); - } - return CloseUIAbilityInner(abilityRecord); -} - -void UIAbilityLifecycleManager::PrepareCloseUIAbility(std::shared_ptr abilityRecord, - int resultCode, const Want *resultWant, bool isClearSession) -{ - if (!abilityRecord) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability record null"); - return; - } - DelayedSingleton::GetInstance()->PrepareTerminate(abilityRecord->GetToken(), isClearSession); - abilityRecord->SetTerminatingState(); - abilityRecord->SetClearMissionFlag(isClearSession); - // save result to caller AbilityRecord - if (resultWant != nullptr) { - Want* newWant = const_cast(resultWant); - newWant->RemoveParam(Want::PARAM_RESV_CALLER_TOKEN); - abilityRecord->SaveResultToCallers(resultCode, newWant); - } else { - Want want; - abilityRecord->SaveResultToCallers(-1, &want); - } - EraseAbilityRecord(abilityRecord); - abilityRecord->SendResultToCallers(); - terminateAbilityList_.push_back(abilityRecord); -} - -int UIAbilityLifecycleManager::CloseUIAbilityInner(std::shared_ptr abilityRecord) -{ - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_UI_ABILITY_MANAGER_NULL_ABILITY_RECORD); - if (abilityRecord->IsAbilityState(FOREGROUND) || abilityRecord->IsAbilityState(FOREGROUNDING)) { - abilityRecord->SetPendingState(AbilityState::BACKGROUND); - MoveToBackground(abilityRecord); - return ERR_OK; - } - // ability on background, schedule to terminate. - if (abilityRecord->GetAbilityState() == AbilityState::BACKGROUND) { - auto self(shared_from_this()); - auto task = [abilityRecord, self]() { - TAG_LOGW(AAFwkTag::ABILITYMGR, "close ability by scb timeout"); - self->DelayCompleteTerminate(abilityRecord); - }; - abilityRecord->Terminate(task); - } - return ERR_OK; -} - -void UIAbilityLifecycleManager::DelayCompleteTerminate(const std::shared_ptr &abilityRecord) -{ - auto handler = DelayedSingleton::GetInstance()->GetTaskHandler(); - CHECK_POINTER(handler); - - PrintTimeOutLog(abilityRecord, AbilityManagerService::TERMINATE_TIMEOUT_MSG); - - auto timeoutTask = [self = shared_from_this(), abilityRecord]() { - TAG_LOGI(AAFwkTag::ABILITYMGR, "delay complete terminate task"); - self->CompleteTerminate(abilityRecord); - }; - int killTimeout = AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * KILL_TIMEOUT_MULTIPLE; - handler->SubmitTaskJust(timeoutTask, "DELAY_KILL_PROCESS", killTimeout); -} - -void UIAbilityLifecycleManager::CompleteTerminate(const std::shared_ptr &abilityRecord) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - - CompleteTerminateLocked(abilityRecord); -} - -void UIAbilityLifecycleManager::CompleteTerminateLocked(const std::shared_ptr &abilityRecord) -{ - CHECK_POINTER(abilityRecord); - if (abilityRecord->GetAbilityState() != AbilityState::TERMINATING) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "failed, %{public}s, ability not terminating", __func__); - return; - } - abilityRecord->RemoveAbilityDeathRecipient(); - auto ret = abilityRecord->TerminateAbility(); - // notify AppMS terminate - if (ret != ERR_OK) { - // Don't return here - TAG_LOGE(AAFwkTag::ABILITYMGR, "appMS fail to terminate ability"); - abilityRecord->SendTerminateAbilityErrorEvent(ret); - } - terminateAbilityList_.remove(abilityRecord); -} - -int32_t UIAbilityLifecycleManager::GetPersistentIdByAbilityRequest(const AbilityRequest &abilityRequest, - bool &reuse) const -{ - if (abilityRequest.collaboratorType != CollaboratorType::DEFAULT_TYPE) { - return GetReusedCollaboratorPersistentId(abilityRequest, reuse); - } - - if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { - return GetReusedSpecifiedPersistentId(abilityRequest, reuse); - } - - if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD) { - return GetReusedStandardPersistentId(abilityRequest, reuse); - } - - if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::SINGLETON) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "launch not singleton"); - return 0; - } - - reuse = true; - for (const auto& [first, second] : sessionAbilityMap_) { - if (CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::SINGLETON)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "SINGLETON: find."); - return first; - } - } - - TAG_LOGD(AAFwkTag::ABILITYMGR, "Not find existed ui ability."); - return 0; -} - -int32_t UIAbilityLifecycleManager::GetReusedSpecifiedPersistentId(const AbilityRequest &abilityRequest, - bool &reuse) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::SPECIFIED) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "not SPECIFIED"); - return 0; - } - - reuse = true; - // specified ability name and bundle name and module name and appIndex format is same as singleton. - for (const auto& [first, second] : sessionAbilityMap_) { - if (second->GetSpecifiedFlag() == abilityRequest.specifiedFlag && - CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::SPECIFIED)) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "SPECIFIED: find."); - return first; - } - } - return 0; -} - -int32_t UIAbilityLifecycleManager::GetReusedStandardPersistentId(const AbilityRequest &abilityRequest, - bool &reuse) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::STANDARD) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "not STANDARD"); - return 0; - } - - if (!abilityRequest.startRecent) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "startRecent false"); - return 0; - } - - reuse = true; - int64_t sessionTime = 0; - int32_t persistentId = 0; - for (const auto& [first, second] : sessionAbilityMap_) { - if (CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::STANDARD) && - second->GetRestartTime() >= sessionTime) { - persistentId = first; - sessionTime = second->GetRestartTime(); - } - } - return persistentId; -} - -int32_t UIAbilityLifecycleManager::GetReusedCollaboratorPersistentId(const AbilityRequest &abilityRequest, - bool &reuse) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - - reuse = false; - int64_t sessionTime = 0; - int32_t persistentId = 0; - for (const auto& [first, second] : sessionAbilityMap_) { - if (second->GetCollaboratorType() != CollaboratorType::DEFAULT_TYPE && - abilityRequest.want.GetStringParam(PARAM_MISSION_AFFINITY_KEY) == second->GetMissionAffinity() && - second->GetRestartTime() >= sessionTime) { - reuse = true; - persistentId = first; - sessionTime = second->GetRestartTime(); - } - } - return persistentId; -} - -bool UIAbilityLifecycleManager::CheckProperties(const std::shared_ptr &abilityRecord, - const AbilityRequest &abilityRequest, AppExecFwk::LaunchMode launchMode) const -{ - CHECK_POINTER_RETURN_BOOL(abilityRecord); - const auto& abilityInfo = abilityRecord->GetAbilityInfo(); - int32_t appIndex = 0; - (void)AbilityRuntime::StartupUtil::GetAppIndex(abilityRequest.want, appIndex); - auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - return abilityInfo.launchMode == launchMode && abilityRequest.abilityInfo.name == abilityInfo.name && - abilityRequest.abilityInfo.bundleName == abilityInfo.bundleName && - abilityRequest.abilityInfo.moduleName == abilityInfo.moduleName && - appIndex == abilityRecord->GetAppIndex() && instanceKey == abilityRecord->GetInstanceKey(); -} - -void UIAbilityLifecycleManager::OnTimeOut(uint32_t msgId, int64_t abilityRecordId, bool isHalf) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call, msgId is %{public}d", msgId); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - std::shared_ptr abilityRecord; - for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) { - if (iter->second != nullptr && iter->second->GetAbilityRecordId() == abilityRecordId) { - abilityRecord = iter->second; - break; - } - } - if (abilityRecord == nullptr) { - for (auto abilityIter : terminateAbilityList_) { - if (abilityIter && abilityIter->GetAbilityRecordId() == abilityRecordId) { - abilityRecord = abilityIter; - break; - } - } - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "call, msgId:%{public}d, name:%{public}s", msgId, - abilityRecord->GetAbilityInfo().name.c_str()); - PrintTimeOutLog(abilityRecord, msgId, isHalf); - if (isHalf) { - return; - } - switch (msgId) { - case AbilityManagerService::LOAD_TIMEOUT_MSG: - abilityRecord->SetLoading(false); - HandleLoadTimeout(abilityRecord); - break; - case AbilityManagerService::FOREGROUND_TIMEOUT_MSG: - HandleForegroundTimeout(abilityRecord); - break; - default: - break; - } -} - -void UIAbilityLifecycleManager::SetRootSceneSession(const sptr &rootSceneSession) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - auto tmpSceneSession = iface_cast(rootSceneSession); - if (tmpSceneSession == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "rootSceneSession invalid"); - return; - } - rootSceneSession_ = rootSceneSession; -} - -void UIAbilityLifecycleManager::NotifySCBToHandleException(const std::shared_ptr &abilityRecord, - int32_t errorCode, const std::string& errorReason, bool needClearCallerLink) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - auto sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER(sessionInfo); - CHECK_POINTER(sessionInfo->sessionToken); - auto session = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER(session); - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBToHandleException reason: %{public}s", errorReason.c_str()); - sptr info = abilityRecord->GetSessionInfo(); - info->errorCode = errorCode; - info->errorReason = errorReason; - info->shouldSkipKillInStartup = abilityRecord->IsKillPrecedeStart(); - Rosen::ExceptionInfo exceptionInfo; - exceptionInfo.needClearCallerLink = needClearCallerLink; - session->NotifySessionException(info, exceptionInfo); - EraseAbilityRecord(abilityRecord); -} - -void UIAbilityLifecycleManager::NotifySCBToHandleAtomicServiceException(sptr sessionInfo, - int32_t errorCode, const std::string& errorReason) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - CHECK_POINTER(sessionInfo); - CHECK_POINTER(sessionInfo->sessionToken); - auto session = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER(session); - TAG_LOGI(AAFwkTag::ABILITYMGR, - "call notifySessionException, errorReason: %{public}s", errorReason.c_str()); - sessionInfo->errorCode = errorCode; - sessionInfo->errorReason = errorReason; - Rosen::ExceptionInfo exceptionInfo; - session->NotifySessionException(sessionInfo, exceptionInfo); -} - -void UIAbilityLifecycleManager::HandleLoadTimeout(const std::shared_ptr &abilityRecord) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - NotifySCBToHandleException(abilityRecord, - static_cast(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout"); - DelayedSingleton::GetInstance()->AttachTimeOut(abilityRecord->GetToken()); -} - -void UIAbilityLifecycleManager::HandleForegroundTimeout(const std::shared_ptr &abilityRecord) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability not foregrounding"); - return; - } - NotifySCBToHandleException(abilityRecord, - static_cast(ErrorLifecycleState::ABILITY_STATE_FOREGROUND_TIMEOUT), "handleForegroundTimeout"); - DelayedSingleton::GetInstance()->AttachTimeOut(abilityRecord->GetToken()); -} - -void UIAbilityLifecycleManager::OnAbilityDied(std::shared_ptr abilityRecord) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call OnAbilityDied"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - CancelPrepareTerminate(abilityRecord); - std::lock_guard guard(sessionLock_); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); - CHECK_POINTER_LOG(handler, "Fail to get AbilityEventHandler."); - if (abilityRecord->GetAbilityState() == AbilityState::INITIAL) { - abilityRecord->RemoveLoadTimeoutTask(); - abilityRecord->SetLoading(false); - } - if (abilityRecord->GetAbilityState() == AbilityState::FOREGROUNDING) { - abilityRecord->RemoveForegroundTimeoutTask(); - } - auto taskHandler = DelayedSingleton::GetInstance()->GetTaskHandler(); - CHECK_POINTER_LOG(taskHandler, "Get AbilityTaskHandler failed."); - if (abilityRecord->GetAbilityState() == AbilityState::BACKGROUNDING) { - taskHandler->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId())); - } - - terminateAbilityList_.push_back(abilityRecord); - abilityRecord->SetAbilityState(AbilityState::TERMINATING); - if (abilityRecord->GetKillForPermissionUpdateFlag()) { - bool needClearCallerLink = false; - NotifySCBToHandleException(abilityRecord, - static_cast(ErrorLifecycleState::ABILITY_STATE_PERMISSION_UPDATE), - "kill process for permission update", needClearCallerLink); - } else if (abilityRecord->IsKillPrecedeStart()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "Killing processes before application startup"); - auto errCode = abilityRecord->GetKillReason() == GlobalConstant::LOW_MEMORY_KILL ? - static_cast(ErrorLifecycleState::ABILITY_STATE_LOW_MEMORY_KILL) : - static_cast(ErrorLifecycleState::ABILITY_STATE_SKIP_KILL_IN_STARTUP); - NotifySCBToHandleException(abilityRecord, errCode, abilityRecord->GetKillReason()); - } else if (!abilityRecord->GetRestartAppFlag()) { - NotifySCBToHandleException(abilityRecord, static_cast(ErrorLifecycleState::ABILITY_STATE_DIED), - "onAbilityDied"); - } - DelayedSingleton::GetInstance()->AttachTimeOut(abilityRecord->GetToken()); - DispatchTerminate(abilityRecord); -} - -void UIAbilityLifecycleManager::OnAcceptWantResponse(const AAFwk::Want &want, const std::string &flag, - int32_t requestId) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "OnAcceptWantResponse, %{public}d", requestId); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - auto iter = hookSpecifiedMap_.find(requestId); - if (iter != hookSpecifiedMap_.end() && iter->second != nullptr) { - auto abilityRecord = iter->second; - abilityRecord->SetSpecifiedFlag(flag); - auto sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER(sessionInfo); - sessionInfo->reuseDelegatorWindow = true; - AbilityRequest request; - request.callerToken = abilityRecord->GetToken(); - std::string errMsg; - int ret = NotifySCBPendingActivation(sessionInfo, request, errMsg); - if (ret == ERR_OK) { - abilityRecord->SetHookOff(true); - abilityRecord->SetIsHook(false); - } - sessionInfo->reuseDelegatorWindow = false; - hookSpecifiedMap_.erase(iter); - return; - } - auto request = GetSpecifiedRequest(requestId); - if (request == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "no request"); - return; - } - auto nextRequest = PopAndGetNextSpecified(requestId); - if (nextRequest) { - TaskHandlerWrap::GetFfrtHandler()->SubmitTask([nextRequest, pThis = shared_from_this()]() { - std::lock_guard lock(pThis->sessionLock_); - pThis->StartSpecifiedRequest(*nextRequest); - }); - } - if (request->isCold) { - if (HandleColdAcceptWantDone(want, flag, *request)) { - return; - } - } - - HandleLegacyAcceptWantDone(*request, flag, want); -} - -void UIAbilityLifecycleManager::HandleLegacyAcceptWantDone(SpecifiedRequest &specifiedRequest, - const std::string &flag, const AAFwk::Want &want) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}s", want.GetElement().GetURI().c_str()); - auto &abilityRequest = specifiedRequest.abilityRequest; - auto callerAbility = GetAbilityRecordByToken(abilityRequest.callerToken); - abilityRequest.specifiedFlag = flag; - if (!flag.empty()) { - bool reuse = false; - auto persistentId = GetReusedSpecifiedPersistentId(abilityRequest, reuse); - if (persistentId != 0) { - std::shared_ptr abilityRecord = nullptr; - auto iter = sessionAbilityMap_.find(persistentId); - if (iter == sessionAbilityMap_.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "OnAcceptWantResponse Unexpected Error"); - return; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "find specified ability, session:%{public}d", persistentId); - abilityRecord = iter->second; - CHECK_POINTER_LOG(abilityRecord, "OnAcceptWantResponse abilityRecord null"); - UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord); - MoveAbilityToFront(specifiedRequest, abilityRecord, callerAbility); - NotifyRestartSpecifiedAbility(abilityRequest, abilityRecord->GetToken()); - return; - } - } - NotifyStartSpecifiedAbility(abilityRequest, want); - StartAbilityBySpecifed(specifiedRequest, callerAbility); -} - -void UIAbilityLifecycleManager::OnStartSpecifiedAbilityTimeoutResponse(int32_t requestId) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "SpecifiedAbilityTimeout %{public}d", requestId); - OnStartSpecifiedFailed(requestId); -} - -void UIAbilityLifecycleManager::OnStartSpecifiedFailed(int32_t requestId) -{ - std::lock_guard lock(sessionLock_); - auto iter = hookSpecifiedMap_.find(requestId); - if (iter != hookSpecifiedMap_.end() && iter->second != nullptr) { - std::shared_ptr abilityRecord = iter->second; - NotifySCBToHandleException(abilityRecord, - static_cast(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout"); - hookSpecifiedMap_.erase(iter); - return; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "OnStartSpecifiedFailed %{public}d", requestId); - auto curRequest = GetSpecifiedRequest(requestId); - if (curRequest == nullptr) { - return; - } - if (curRequest->persistentId != 0) { - auto iter = sessionAbilityMap_.find(curRequest->persistentId); - if (iter != sessionAbilityMap_.end() && iter->second != nullptr) { - auto abilityRecord = iter->second; - NotifySCBToHandleException(abilityRecord, - static_cast(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout"); - } - } else { - RemoveInstanceKey(curRequest->abilityRequest); - } - - HandleAbilitiesRequestDone(requestId, curRequest->requestListId, nullptr); - auto nextRequest = PopAndGetNextSpecified(requestId); - if (nextRequest) { - StartSpecifiedRequest(*nextRequest); - } -} - -void UIAbilityLifecycleManager::OnStartSpecifiedProcessResponse(const std::string &flag, int32_t requestId, - const std::string &callerProcessName) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "OnStartSpecifiedProcessResponse, %{public}d", requestId); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - auto request = GetSpecifiedRequest(requestId); - if (request == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "no request"); - return; - } - - auto &abilityRequest = request->abilityRequest; - abilityRequest.want.SetParam(PARAM_SPECIFIED_PROCESS_FLAG, flag); - if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { - abilityRequest.want.RemoveParam(SPECIFED_PROCESS_CALLER_PROCESS); - abilityRequest.want.SetParam(SPECIFED_PROCESS_CALLER_PROCESS, callerProcessName); - request->specifiedProcessState = SpecifiedProcessState::STATE_ABILITY; - StartSpecifiedRequest(*request); - abilityRequest.want.RemoveParam(SPECIFED_PROCESS_CALLER_PROCESS); - return; - } - auto nextRequest = PopAndGetNextSpecified(requestId); - if (nextRequest) { - ffrt::submit([nextRequest, pThis = shared_from_this()]() { - std::lock_guard lock(pThis->sessionLock_); - pThis->StartSpecifiedRequest(*nextRequest); - }, ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); - } - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse); - sessionInfo->userId = abilityRequest.userId; - sessionInfo->isAtomicService = - (abilityRequest.abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - TAG_LOGI(AAFwkTag::ABILITYMGR, "reused sessionId: %{public}d, userId: %{public}d", sessionInfo->persistentId, - abilityRequest.userId); - if (request->requestListId != REQUEST_LIST_ID_INIT) { - HandleAbilitiesRequestDone(requestId, request->requestListId, sessionInfo); - return; - } - std::string errMsg; - NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); -} - -void UIAbilityLifecycleManager::OnStartSpecifiedProcessTimeoutResponse(int32_t requestId) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "OnStartSpecifiedProcessTimeoutResponse %{public}d", requestId); - std::lock_guard guard(sessionLock_); - auto request = GetSpecifiedRequest(requestId); - if (request != nullptr) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "removing instance key"); - RemoveInstanceKey(request->abilityRequest); - HandleAbilitiesRequestDone(requestId, request->requestListId, nullptr); - } - auto nextRequest = PopAndGetNextSpecified(requestId); - if (nextRequest) { - StartSpecifiedRequest(*nextRequest); - } -} - -bool UIAbilityLifecycleManager::IsStartSpecifiedProcessRequest(const AbilityRequest &abilityRequest) -{ - const auto &abilityInfo = abilityRequest.abilityInfo; - if (!abilityInfo.isolationProcess) { - return false; - } - if (!AppUtils::GetInstance().IsStartSpecifiedProcess()) { - return false; - } - bool isUIAbility = (abilityInfo.type == AppExecFwk::AbilityType::PAGE && abilityInfo.isStageBasedModel); - if (!isUIAbility) { - return false; - } - // When 'processMode' is set to new process mode, the priority is higher than 'isolationProcess'. - bool isNewProcessMode = abilityRequest.processOptions && - ProcessOptions::IsNewProcessMode(abilityRequest.processOptions->processMode); - if (isNewProcessMode) { - return false; - } - bool isPlugin = StartupUtil::IsStartPlugin(abilityRequest.want); - if (isPlugin) { - return false; - } - return true; -} - -int32_t UIAbilityLifecycleManager::StartSpecifiedProcessRequest(const AbilityRequest &abilityRequest, - std::shared_ptr abilitiesRequest) -{ - auto isCreating = abilityRequest.want.GetBoolParam(Want::CREATE_APP_INSTANCE_KEY, false); - const auto &abilityInfo = abilityRequest.abilityInfo; - auto sceneSessionManager = Rosen::SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); - if (AppUtils::GetInstance().InOnNewProcessEnableList(abilityRequest.abilityInfo.bundleName) && - abilityInfo.applicationInfo.multiAppMode.multiAppModeType == AppExecFwk::MultiAppModeType::MULTI_INSTANCE && - isCreating && sceneSessionManager != nullptr) { - std::string instanceKey; - Rosen::WMError ret = sceneSessionManager->CreateNewInstanceKey(abilityRequest.want.GetBundle(), instanceKey); - if (ret != Rosen::WMError::WM_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "create new isntance error:%{public}d", ret); - return ERR_CREATE_INSTANCE_KEY_FAILED; - } - const_cast(abilityRequest).want.SetParam(Want::APP_INSTANCE_KEY, instanceKey); - } - auto requestId = RequestIdUtil::GetRequestId(); - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartSpecifiedProcess, requestId:%{public}d", requestId); - auto specifiedRequest = std::make_shared(requestId, abilityRequest); - specifiedRequest->specifiedProcessState = SpecifiedProcessState::STATE_PROCESS; - if (abilitiesRequest != nullptr) { - abilitiesRequest->sessionInfoList.emplace_back(requestId, nullptr); - specifiedRequest->requestListId = abilitiesRequest->requestListId; - } - AddSpecifiedRequest(specifiedRequest); - return ERR_OK; -} - -int32_t UIAbilityLifecycleManager::StartSpecifiedAbilityBySCB(AbilityRequest &abilityRequest) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - abilityRequest.isFromIcon = true; - std::lock_guard guard(sessionLock_); - // support specified process mode - if (IsStartSpecifiedProcessRequest(abilityRequest)) { - return StartSpecifiedProcessRequest(abilityRequest, nullptr); - } - AddSpecifiedRequest(std::make_shared(RequestIdUtil::GetRequestId(), abilityRequest)); - return ERR_OK; -} - -void UIAbilityLifecycleManager::NotifyRestartSpecifiedAbility(const AbilityRequest &request, - const sptr &token) -{ - if (request.abilityInfoCallback == nullptr) { - return; - } - sptr abilityInfoCallback - = iface_cast (request.abilityInfoCallback); - if (abilityInfoCallback != nullptr) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "called"); - abilityInfoCallback->NotifyRestartSpecifiedAbility(token); - } -} - -void UIAbilityLifecycleManager::NotifyStartSpecifiedAbility(AbilityRequest &abilityRequest, const AAFwk::Want &want) -{ - if (abilityRequest.abilityInfoCallback == nullptr) { - return; - } - - sptr abilityInfoCallback - = iface_cast (abilityRequest.abilityInfoCallback); - if (abilityInfoCallback != nullptr) { - Want newWant = want; - int32_t type = static_cast(abilityRequest.abilityInfo.type); - newWant.SetParam("abilityType", type); - sptr extraParam = new (std::nothrow) Want(); - CHECK_POINTER(extraParam); - abilityInfoCallback->NotifyStartSpecifiedAbility(abilityRequest.callerToken, newWant, - abilityRequest.requestCode, extraParam); - int32_t procCode = extraParam->GetIntParam(Want::PARAM_RESV_REQUEST_PROC_CODE, 0); - if (procCode != 0) { - abilityRequest.want.SetParam(Want::PARAM_RESV_REQUEST_PROC_CODE, procCode); - } - int32_t tokenCode = extraParam->GetIntParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, 0); - if (tokenCode != 0) { - abilityRequest.want.SetParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, tokenCode); - } - } -} - -int32_t UIAbilityLifecycleManager::MoveAbilityToFront(const SpecifiedRequest &specifiedRequest, - std::shared_ptr abilityRecord, std::shared_ptr callerAbility) -{ - if (!abilityRecord) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability record failed"); - return ERR_INVALID_VALUE; - } - const auto &abilityRequest = specifiedRequest.abilityRequest; - int32_t requestId = specifiedRequest.requestId; - int32_t requestListId = specifiedRequest.requestListId; - sptr sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - sessionInfo->want = abilityRequest.want; - sessionInfo->callerToken = abilityRequest.callerToken; - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->processOptions = nullptr; - if (AppUtils::GetInstance().IsStartOptionsWithProcessOptions() && - abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { - sessionInfo->processOptions = abilityRequest.processOptions; - } - sessionInfo->startWindowOption = nullptr; - sessionInfo->isFromIcon = abilityRequest.isFromIcon; - sessionInfo->requestId = requestId; - sessionInfo->specifiedFlag = abilityRequest.specifiedFlag; - TAG_LOGI(AAFwkTag::ABILITYMGR, "MoveAbilityToFront: %{public}d-%{public}s", requestId, - abilityRequest.specifiedFlag.c_str()); - if (requestListId != REQUEST_LIST_ID_INIT) { - HandleAbilitiesRequestDone(requestId, requestListId, sessionInfo); - return ERR_OK; - } - SendSessionInfoToSCB(callerAbility, sessionInfo); - abilityRecord->RemoveWindowMode(); - return ERR_OK; -} - -int UIAbilityLifecycleManager::SendSessionInfoToSCB(std::shared_ptr &callerAbility, - sptr &sessionInfo) -{ - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - TAG_LOGD(AAFwkTag::ABILITYMGR, "call SendSessionInfoToSCB,windowLeft=%{public}d,windowTop=%{public}d," - "windowHeight=%{public}d,windowWidth=%{public}d,minWindowWidth=%{public}d,minWindowHeight=%{public}d," - "maxWindowWidth=%{public}d,mixWindowHeight=%{public}d,specifiedFlag=%{public}s", - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_LEFT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_TOP, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_HEIGHT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_WIDTH, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_MIN_WINDOW_WIDTH, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_MIN_WINDOW_HEIGHT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_MAX_WINDOW_WIDTH, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_MAX_WINDOW_HEIGHT, 0), - sessionInfo->specifiedFlag.c_str()); - auto tmpSceneSession = iface_cast(rootSceneSession_); - sptr callerSessionInfo = nullptr; - if (callerAbility != nullptr && (callerSessionInfo = callerAbility->GetSessionInfo()) != nullptr && - callerSessionInfo->sessionToken != nullptr) { - auto callerSession = iface_cast(callerSessionInfo->sessionToken); - CHECK_POINTER_AND_RETURN(callerSession, ERR_INVALID_VALUE); - CheckCallerFromBackground(callerAbility, sessionInfo); - auto requestId = sessionInfo->want.GetStringParam(KEY_REQUEST_ID); - if (!requestId.empty()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "notify request success, requestId:%{public}s", requestId.c_str()); - callerAbility->NotifyAbilityRequestSuccess(requestId, sessionInfo->want.GetElement()); - } - sessionInfo->want.RemoveParam(KEY_REQUEST_ID); - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for callerSession, target: %{public}s", - sessionInfo->want.GetElement().GetAbilityName().c_str()); - callerSession->PendingSessionActivation(sessionInfo); - return ERR_OK; - } - CHECK_POINTER_AND_RETURN(tmpSceneSession, ERR_INVALID_VALUE); - sessionInfo->canStartAbilityFromBackground = true; - auto abilityRecord = Token::GetAbilityRecordByToken(sessionInfo->callerToken); - if (abilityRecord != nullptr) { - auto requestId = sessionInfo->want.GetStringParam(KEY_REQUEST_ID); - if (!requestId.empty()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "notify request success, requestId:%{public}s", requestId.c_str()); - abilityRecord->NotifyAbilityRequestSuccess(requestId, sessionInfo->want.GetElement()); - } - sessionInfo->want.RemoveParam(KEY_REQUEST_ID); - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for rootSceneSession, target: %{public}s", - sessionInfo->want.GetElement().GetAbilityName().c_str()); - tmpSceneSession->PendingSessionActivation(sessionInfo); - return ERR_OK; -} - -int32_t UIAbilityLifecycleManager::StartAbilityBySpecifed(const SpecifiedRequest &specifiedRequest, - std::shared_ptr callerAbility) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - sptr sessionInfo = new SessionInfo(); - const auto &abilityRequest = specifiedRequest.abilityRequest; - sessionInfo->callerToken = abilityRequest.callerToken; - sessionInfo->want = abilityRequest.want; - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->processOptions = abilityRequest.processOptions; - sessionInfo->startWindowOption = abilityRequest.startWindowOption; - sessionInfo->instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - sessionInfo->isFromIcon = abilityRequest.isFromIcon; - sessionInfo->requestId = specifiedRequest.requestId; - sessionInfo->specifiedFlag = abilityRequest.specifiedFlag; - TAG_LOGI(AAFwkTag::ABILITYMGR, "specified flag:%{public}s", abilityRequest.specifiedFlag.c_str()); - if (specifiedRequest.requestListId != REQUEST_LIST_ID_INIT) { - HandleAbilitiesRequestDone(specifiedRequest.requestId, specifiedRequest.requestListId, sessionInfo); - } else { - SendSessionInfoToSCB(callerAbility, sessionInfo); - } - return ERR_OK; -} - -void UIAbilityLifecycleManager::CallRequestDone(const std::shared_ptr &abilityRecord, - const sptr &callStub) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null ability record"); - return; - } - if (callStub == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null call stub"); - return; - } - abilityRecord->CallRequestDone(callStub); - - auto iter = callRequestCache_.find(abilityRecord); - if (iter == callRequestCache_.end()) { - return; - } - auto requestList = std::move(iter->second); - callRequestCache_.erase(iter); - auto wThis = weak_from_this(); - for (const auto &request : requestList) { - auto task = [request, wThis]() { - auto pThis = wThis.lock(); - if (pThis) { - std::string errMsg; - pThis->CallAbilityLocked(request, errMsg); - } - }; - ffrt::submit(std::move(task), - ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); - } -} - -int UIAbilityLifecycleManager::ReleaseCallLocked( - const sptr &connect, const AppExecFwk::ElementName &element) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "release call ability."); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE); - CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE); - - std::lock_guard guard(sessionLock_); - - auto abilityRecords = GetAbilityRecordsByNameInner(element); - auto isExist = [connect] (const std::shared_ptr &abilityRecord) { - if (abilityRecord == nullptr) { - return false; - } - return abilityRecord->IsExistConnection(connect); - }; - auto findRecord = std::find_if(abilityRecords.begin(), abilityRecords.end(), isExist); - if (findRecord == abilityRecords.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not find record"); - return RELEASE_CALL_ABILITY_INNER_ERR; - } - auto abilityRecord = *findRecord; - CHECK_POINTER_AND_RETURN(abilityRecord, RELEASE_CALL_ABILITY_INNER_ERR); - - if (!abilityRecord->ReleaseCall(connect)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability release call failed"); - return RELEASE_CALL_ABILITY_INNER_ERR; - } - return ERR_OK; -} - -void UIAbilityLifecycleManager::OnCallConnectDied(const std::shared_ptr &callRecord) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "on callConnect died"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - CHECK_POINTER(callRecord); - std::lock_guard guard(sessionLock_); - - AppExecFwk::ElementName element = callRecord->GetTargetServiceName(); - auto abilityRecords = GetAbilityRecordsByNameInner(element); - auto isExist = [callRecord] (const std::shared_ptr &abilityRecord) { - if (abilityRecord == nullptr) { - return false; - } - return abilityRecord->IsExistConnection(callRecord->GetConCallBack()); - }; - auto findRecord = std::find_if(abilityRecords.begin(), abilityRecords.end(), isExist); - if (findRecord == abilityRecords.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not find record"); - return; - } - auto abilityRecord = *findRecord; - CHECK_POINTER(abilityRecord); - abilityRecord->ReleaseCall(callRecord->GetConCallBack()); -} - -std::vector> UIAbilityLifecycleManager::GetAbilityRecordsByName( - const AppExecFwk::ElementName &element) -{ - std::lock_guard guard(sessionLock_); - return GetAbilityRecordsByNameInner(element); -} - -std::vector> UIAbilityLifecycleManager::GetAbilityRecordsByNameInner( - const AppExecFwk::ElementName &element) -{ - std::vector> records; - for (const auto& [first, second] : sessionAbilityMap_) { - auto &abilityInfo = second->GetAbilityInfo(); - AppExecFwk::ElementName localElement(abilityInfo.deviceId, abilityInfo.bundleName, - abilityInfo.name, abilityInfo.moduleName); - AppExecFwk::ElementName localElementNoModuleName(abilityInfo.deviceId, - abilityInfo.bundleName, abilityInfo.name); - if (localElement == element || localElementNoModuleName == element) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "find element %{public}s", localElement.GetURI().c_str()); - records.push_back(second); - } - } - return records; -} - -int32_t UIAbilityLifecycleManager::GetSessionIdByAbilityToken(const sptr &token) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - for (const auto& [first, second] : sessionAbilityMap_) { - if (second && second->GetToken()->AsObject() == token) { - return first; - } - } - TAG_LOGE(AAFwkTag::ABILITYMGR, "not find"); - return 0; -} - -void UIAbilityLifecycleManager::SetReceiverInfo(const AbilityRequest &abilityRequest, - std::shared_ptr &abilityRecord) const -{ - CHECK_POINTER(abilityRecord); - const auto &abilityInfo = abilityRequest.abilityInfo; - std::string abilityName = abilityInfo.name; - auto isStandard = abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD && !abilityRequest.startRecent; - if (isStandard && abilityRequest.sessionInfo != nullptr) { - // Support standard launch type. - auto persistentId = abilityRequest.sessionInfo->persistentId; - abilityName += std::to_string(abilityRequest.sessionInfo->persistentId); - } - - bool hasRecoverInfo = false; - (void)DelayedSingleton::GetInstance()-> - GetAbilityRecoverInfo(abilityInfo.applicationInfo.accessTokenId, abilityInfo.moduleName, abilityName, - hasRecoverInfo); - abilityRecord->UpdateRecoveryInfo(hasRecoverInfo); - (void)DelayedSingleton::GetInstance()-> - DeleteAbilityRecoverInfo(abilityInfo.applicationInfo.accessTokenId, abilityInfo.moduleName, abilityName); -} - -void UIAbilityLifecycleManager::SetLastExitReason(std::shared_ptr &abilityRecord) const -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (abilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null abilityRecord"); - return; - } - - if (abilityRecord->GetAbilityInfo().bundleName.empty()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "bundleName empty"); - return; - } - - auto sessionInfo = abilityRecord->GetSessionInfo(); - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo invalid"); - return; - } - - std::string abilityName = abilityRecord->GetAbilityInfo().name; - if (abilityRecord->GetAbilityInfo().launchMode == AppExecFwk::LaunchMode::STANDARD) { - abilityName += std::to_string(sessionInfo->persistentId); - } - - ExitReason exitReason; - bool isSetReason; - auto accessTokenId = abilityRecord->GetAbilityInfo().applicationInfo.accessTokenId; - AppExecFwk::RunningProcessInfo processInfo; - int64_t time_stamp = 0; - bool withKillMsg = false; - DelayedSingleton::GetInstance()->GetAppExitReason( - abilityRecord->GetAbilityInfo().bundleName, accessTokenId, abilityName, isSetReason, exitReason, - processInfo, time_stamp, withKillMsg); - - if (isSetReason) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "Set last exit reason, ability: %{public}s, reason: %{public}d.", - abilityName.c_str(), exitReason.reason); - abilityRecord->SetLastExitReason(exitReason, processInfo, time_stamp, withKillMsg); - } -} - -bool UIAbilityLifecycleManager::PrepareTerminateAbility(const std::shared_ptr &abilityRecord, - bool isSCBCall) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call PrepareTerminateAbility"); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - if (AbilityPermissionUtil::GetInstance().CheckPrepareTerminateEnable(abilityRecord) != ERR_OK) { - TAG_LOGD(AAFwkTag::ABILITYMGR, "Not support prepare terminate."); - return false; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str()); - return abilityRecord->PrepareTerminateAbility(isSCBCall); -} - -void UIAbilityLifecycleManager::PrepareTerminateAbilityDone(std::shared_ptr abilityRecord, - bool isTerminate) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call PrepareTerminateAbilityDone"); - CHECK_POINTER(abilityRecord); - abilityRecord->PrepareTerminateAbilityDone(isTerminate); -} - -void UIAbilityLifecycleManager::SetSessionHandler(const sptr &handler) -{ - handler_ = handler; -} - -std::shared_ptr UIAbilityLifecycleManager::GetAbilityRecordsById(int32_t sessionId) const -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - auto search = sessionAbilityMap_.find(sessionId); - if (search == sessionAbilityMap_.end()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "sessionId invalid"); - return nullptr; - } - return search->second; -} - -void UIAbilityLifecycleManager::GetActiveAbilityList(int32_t uid, std::vector &abilityList, int32_t pid) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call"); - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null second"); - continue; - } - if (!CheckPid(abilityRecord, pid)) { - continue; - } - const auto &abilityInfo = abilityRecord->GetAbilityInfo(); - if (abilityInfo.applicationInfo.uid == uid && !abilityInfo.name.empty()) { - std::string abilityName = abilityInfo.name; - if (abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD && - abilityRecord->GetSessionInfo() != nullptr) { - abilityName += std::to_string(abilityRecord->GetSessionInfo()->persistentId); - } - TAG_LOGD(AAFwkTag::ABILITYMGR, "find ability name is %{public}s.", abilityName.c_str()); - abilityList.push_back(abilityName); - } - } - if (!abilityList.empty()) { - sort(abilityList.begin(), abilityList.end()); - abilityList.erase(unique(abilityList.begin(), abilityList.end()), abilityList.end()); - } -} - -bool UIAbilityLifecycleManager::CheckPid(const std::shared_ptr abilityRecord, const int32_t pid) const -{ - CHECK_POINTER_RETURN_BOOL(abilityRecord); - return pid == NO_PID || abilityRecord->GetPid() == pid; -} - -int32_t UIAbilityLifecycleManager::CheckAbilityNumber( - const std::string &bundleName, const std::string &abilityName, const std::string &moduleName) const -{ - int32_t checkAbilityNumber = 0; - - for (auto [persistentId, record] : sessionAbilityMap_) { - auto recordAbilityInfo = record->GetAbilityInfo(); - if (bundleName == recordAbilityInfo.bundleName && abilityName == recordAbilityInfo.name && - moduleName == recordAbilityInfo.moduleName) { - // check ability number created previously and add new one. - checkAbilityNumber += 1; - } - } - - return checkAbilityNumber; -} - -void UIAbilityLifecycleManager::MoreAbilityNumbersSendEventInfo( - int32_t userId, const std::string &bundleName, const std::string &abilityName, const std::string &moduleName) -{ - int32_t checkAbilityNumber = 0; - checkAbilityNumber = CheckAbilityNumber(bundleName, abilityName, moduleName); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Check ability number:%{public}d", checkAbilityNumber); - - if (checkAbilityNumber >= 1) { - EventInfo eventInfo; - eventInfo.userId = userId; - eventInfo.abilityName = abilityName; - eventInfo.bundleName = bundleName; - eventInfo.moduleName = moduleName; - // get ability number created previously and add new one. - eventInfo.abilityNumber = checkAbilityNumber + 1; - EventReport::SendAbilityEvent(EventName::START_STANDARD_ABILITIES, HiSysEventType::BEHAVIOR, eventInfo); - } -} - -void UIAbilityLifecycleManager::OnAppStateChanged(const AppInfo &info) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - if (info.state == AppState::TERMINATED || info.state == AppState::END) { - for (const auto& abilityRecord : terminateAbilityList_) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - if (info.bundleName == abilityRecord->GetApplicationInfo().bundleName && - info.appIndex == abilityRecord->GetAppIndex() && info.instanceKey == abilityRecord->GetInstanceKey()) { - abilityRecord->SetAppState(info.state); - } - } - return; - } - if (info.state == AppState::COLD_START) { - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - if (info.bundleName == abilityRecord->GetApplicationInfo().bundleName && - info.appIndex == abilityRecord->GetAppIndex() && info.instanceKey == abilityRecord->GetInstanceKey()) { -#ifdef SUPPORT_SCREEN - abilityRecord->SetColdStartFlag(true); -#endif // SUPPORT_SCREEN - break; - } - } - return; - } - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - if (info.bundleName == abilityRecord->GetApplicationInfo().bundleName && - info.appIndex == abilityRecord->GetAppIndex() && info.instanceKey == abilityRecord->GetInstanceKey()) { - abilityRecord->SetAppState(info.state); - } - } -} - -void UIAbilityLifecycleManager::UninstallApp(const std::string &bundleName, int32_t uid) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call"); - for (auto it = sessionAbilityMap_.begin(); it != sessionAbilityMap_.end();) { - if (it->second == nullptr) { - it++; - continue; - } - auto &abilityInfo = it->second->GetAbilityInfo(); - if (abilityInfo.bundleName == bundleName && it->second->GetUid() == uid) { - std::string abilityName = abilityInfo.name; - auto sessionInfo = it->second->GetSessionInfo(); - if (abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD && sessionInfo != nullptr) { - abilityName += std::to_string(sessionInfo->persistentId); - } - (void)DelayedSingleton::GetInstance()-> - DeleteAbilityRecoverInfo(abilityInfo.applicationInfo.accessTokenId, abilityInfo.moduleName, - abilityName); - } - it++; - } -} - -void UIAbilityLifecycleManager::GetAbilityRunningInfos(std::vector &info, bool isPerm) const -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - TAG_LOGD(AAFwkTag::ABILITYMGR, "Call."); - for (auto [sessionId, abilityRecord] : sessionAbilityMap_) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - if (isPerm) { - DelayedSingleton::GetInstance()->GetAbilityRunningInfo(info, abilityRecord); - } else { - auto callingTokenId = IPCSkeleton::GetCallingTokenID(); - auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId; - if (callingTokenId == tokenID) { - DelayedSingleton::GetInstance()->GetAbilityRunningInfo(info, abilityRecord); - } - } - } -} - -void UIAbilityLifecycleManager::Dump(std::vector &info) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "call"); - std::unordered_map> sessionAbilityMapLocked; - { - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - sessionAbilityMapLocked[sessionId] = abilityRecord; - } - } - - std::string dumpInfo = "User ID #" + std::to_string(userId_); - info.push_back(dumpInfo); - dumpInfo = " current mission lists:{"; - info.push_back(dumpInfo); - - for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - - sptr sessionInfo = abilityRecord->GetSessionInfo(); - dumpInfo = " Mission ID #" + std::to_string(sessionId); - if (sessionInfo) { - dumpInfo += " mission name #[" + sessionInfo->sessionName + "]"; - } - dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState()); - dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]"; - info.push_back(dumpInfo); - - abilityRecord->Dump(info); - } - dumpInfo = " }"; - info.push_back(dumpInfo); -} - -void UIAbilityLifecycleManager::DumpMissionList( - std::vector &info, bool isClient, const std::string &args) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "call"); - std::unordered_map> sessionAbilityMapLocked; - { - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - sessionAbilityMapLocked[sessionId] = abilityRecord; - } - } - std::string dumpInfo = "User ID #" + std::to_string(userId_); - info.push_back(dumpInfo); - dumpInfo = " current mission lists:{"; - info.push_back(dumpInfo); - - for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - sptr sessionInfo = abilityRecord->GetSessionInfo(); - dumpInfo = " Mission ID #" + std::to_string(sessionId); - if (sessionInfo) { - dumpInfo += " mission name #[" + sessionInfo->sessionName + "]"; - } - dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState()); - dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]"; - info.push_back(dumpInfo); - - std::vector params; - abilityRecord->DumpAbilityState(info, isClient, params); - } - dumpInfo = " }"; - info.push_back(dumpInfo); -} - -void UIAbilityLifecycleManager::DumpMissionListByRecordId(std::vector &info, bool isClient, - int32_t abilityRecordId, const std::vector ¶ms) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "call"); - std::unordered_map> sessionAbilityMapLocked; - { - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) { - sessionAbilityMapLocked[sessionId] = abilityRecord; - } - } - std::string dumpInfo = "User ID #" + std::to_string(userId_); - info.push_back(dumpInfo); - dumpInfo = " current mission lists:{"; - info.push_back(dumpInfo); - - for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) { - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "null abilityRecord"); - continue; - } - if (abilityRecord->GetAbilityRecordId() != abilityRecordId) { - continue; - } - sptr sessionInfo = abilityRecord->GetSessionInfo(); - dumpInfo = " Mission ID #" + std::to_string(sessionId); - if (sessionInfo) { - dumpInfo += " mission name #[" + sessionInfo->sessionName + "]"; - } - dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState()); - dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]"; - info.push_back(dumpInfo); - - abilityRecord->DumpAbilityState(info, isClient, params); - } - dumpInfo = " }"; - info.push_back(dumpInfo); -} - -int UIAbilityLifecycleManager::MoveMissionToFront(int32_t sessionId, std::shared_ptr startOptions) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - auto tmpSceneSession = iface_cast(rootSceneSession_); - CHECK_POINTER_AND_RETURN(tmpSceneSession, ERR_INVALID_VALUE); - std::shared_ptr abilityRecord = GetAbilityRecordsById(sessionId); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - sptr sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - if (startOptions != nullptr) { - abilityRecord->SetWindowMode(startOptions->GetWindowMode()); - TAG_LOGI(AAFwkTag::ABILITYMGR, "MoveMissionToFront, setting displayId=%{public}d", - startOptions->GetDisplayID()); - (sessionInfo->want).SetParam(Want::PARAM_RESV_DISPLAY_ID, startOptions->GetDisplayID()); - if (startOptions->GetDisplayID() == 0) { - (sessionInfo->want).SetParam(Want::PARAM_RESV_DISPLAY_ID, DisplayUtil::GetDefaultDisplayId()); - } - } else { - (sessionInfo->want).SetParam(Want::PARAM_RESV_DISPLAY_ID, -1); - } - sessionInfo->processOptions = nullptr; - sessionInfo->startWindowOption = nullptr; - TAG_LOGI(AAFwkTag::ABILITYMGR, "call PendingSessionActivation by rootSceneSession" - "windowLeft=%{public}d,windowTop=%{public}d," - "windowHeight=%{public}d,windowWidth=%{public}d", - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_LEFT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_TOP, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_HEIGHT, 0), - (sessionInfo->want).GetIntParam(Want::PARAM_RESV_WINDOW_WIDTH, 0)); - sessionInfo->canStartAbilityFromBackground = true; - sessionInfo->scenarios = ServerConstant::SCENARIO_MOVE_MISSION_TO_FRONT; - return static_cast(tmpSceneSession->PendingSessionActivation(sessionInfo)); -} - -std::shared_ptr UIAbilityLifecycleManager::GetStatusBarDelegateManager() -{ - std::lock_guard lock(statusBarDelegateManagerLock_); - if (statusBarDelegateManager_ == nullptr) { - statusBarDelegateManager_ = std::make_shared(); - } - return statusBarDelegateManager_; -} - -int32_t UIAbilityLifecycleManager::RegisterStatusBarDelegate(sptr delegate) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, ERR_INVALID_VALUE); - return statusBarDelegateManager->RegisterStatusBarDelegate(delegate); -} - -bool UIAbilityLifecycleManager::IsCallerInStatusBar(const std::string &instanceKey) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, false); - return statusBarDelegateManager->IsCallerInStatusBar(instanceKey); -} - -bool UIAbilityLifecycleManager::IsInStatusBar(uint32_t accessTokenId, bool isMultiInstance) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, false); - return statusBarDelegateManager->IsInStatusBar(accessTokenId, isMultiInstance); -} - -bool UIAbilityLifecycleManager::IsSupportStatusBar() -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, false); - return statusBarDelegateManager->IsSupportStatusBar(); -} - -int32_t UIAbilityLifecycleManager::DoProcessAttachment(std::shared_ptr abilityRecord) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, ERR_INVALID_VALUE); - return statusBarDelegateManager->DoProcessAttachment(abilityRecord); -} - -int32_t UIAbilityLifecycleManager::DoCallerProcessAttachment(std::shared_ptr abilityRecord) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, ERR_INVALID_VALUE); - return statusBarDelegateManager->DoCallerProcessAttachment(abilityRecord); -} - -int32_t UIAbilityLifecycleManager::DoCallerProcessDetachment(std::shared_ptr abilityRecord) -{ - auto statusBarDelegateManager = GetStatusBarDelegateManager(); - CHECK_POINTER_AND_RETURN(statusBarDelegateManager, ERR_INVALID_VALUE); - return statusBarDelegateManager->DoCallerProcessDetachment(abilityRecord); -} - -bool UIAbilityLifecycleManager::CheckPrepareTerminateTokens(const std::vector> &tokens, - uint32_t &tokenId, std::map>> &tokensPerModuleName) -{ - if (!AppUtils::GetInstance().IsStartOptionsWithAnimation()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "Not supported device"); - return false; - } - if (tokens.empty()) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "empty tokens"); - return false; - } - for (auto token: tokens) { - auto abilityRecord = Token::GetAbilityRecordByToken(token); - if (abilityRecord == nullptr) { - continue; - } - tokenId = abilityRecord->GetApplicationInfo().accessTokenId; - auto moduleName = abilityRecord->GetAbilityInfo().moduleName; - if (tokensPerModuleName.find(moduleName) == tokensPerModuleName.end()) { - tokensPerModuleName[moduleName] = {}; - } - tokensPerModuleName[moduleName].push_back(token); - } - if (tokenId == 0 || !AAFwk::PermissionVerification::GetInstance()->VerifyPrepareTerminatePermission(tokenId)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "invalid tokenId or no permission ohos.permission.PREPARE_APP_TERMINATE"); - return false; - } - return true; -} - -void UIAbilityLifecycleManager::HandleAbilityStageOnPrepareTerminationTimeout( - int32_t pid, const std::string &moduleName, const std::vector> &tokens) -{ - TAG_LOGE(AAFwkTag::ABILITYMGR, "handle abilityStage.onPrepareTermination timeout, token size=%{public}zu", - tokens.size()); - for (auto token: tokens) { - TerminateSession(Token::GetAbilityRecordByToken(token)); - } - auto iter = std::find_if(prepareTerminateByPidRecords_.begin(), prepareTerminateByPidRecords_.end(), - [pid, _moduleName = moduleName](const std::shared_ptr &record) { - return record->pid_ == pid && record->moduleName_ == _moduleName; - }); - if (iter != prepareTerminateByPidRecords_.end()) { - prepareTerminateByPidRecords_.erase(iter); - } -} - -std::vector> UIAbilityLifecycleManager::PrepareTerminateAppAndGetRemainingInner( - int32_t pid, const std::string &moduleName, const std::vector> &tokens) -{ - std::vector> remainingTokens; - // execute onPrepareTerminate until timeout - std::unique_lock lock(isTryPrepareTerminateByPidsDoneMutex_); - auto iter = std::find_if(prepareTerminateByPidRecords_.begin(), prepareTerminateByPidRecords_.end(), - [pid, _moduleName = moduleName](const std::shared_ptr &record) { - return record->pid_ == pid && record->moduleName_ == _moduleName; - }); - if (iter != prepareTerminateByPidRecords_.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "record with (pid=%{public}d,moduleName=%{public}s) already exists", - pid, moduleName.c_str()); - return remainingTokens; - } - std::shared_ptr record = std::make_shared( - pid, moduleName, false, 0, false); - prepareTerminateByPidRecords_.push_back(record); - auto condition = [record] { - if (record == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null record"); - return false; - } - return record->isTryPrepareTerminateByPidsDone_.load(); - }; - auto task = [pid, _moduleName = moduleName]() { - DelayedSingleton::GetInstance()->PrepareTerminateApp(pid, _moduleName); - }; - ffrt::submit(task); - if (!isTryPrepareTerminateByPidsCv_.wait_for(lock, - std::chrono::milliseconds(GlobalConstant::PREPARE_TERMINATE_TIMEOUT_TIME), condition)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "wait timeout, kill immediately"); - HandleAbilityStageOnPrepareTerminationTimeout(pid, moduleName, tokens); - } else if (!record->isExist_) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "onPrepareTermination/onPrepareTerminationAsync not exist"); - remainingTokens.insert(remainingTokens.end(), tokens.begin(), tokens.end()); - } else if (static_cast(record->prepareTermination_) == - AppExecFwk::PrepareTermination::CANCEL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "PrepareTerminate cancel"); - } else { - // Terminate immediately by default - TAG_LOGI(AAFwkTag::ABILITYMGR, "PrepareTerminate immediately"); - for (auto token: tokens) { - TerminateSession(Token::GetAbilityRecordByToken(token)); - } - } - return remainingTokens; -} - -std::vector> UIAbilityLifecycleManager::PrepareTerminateAppAndGetRemaining( - int32_t pid, const std::vector> &tokens) -{ - uint32_t tokenId = 0; - std::map>> tokensPerModuleName; - if (!CheckPrepareTerminateTokens(tokens, tokenId, tokensPerModuleName)) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "CheckPrepareTerminateTokens failed"); - return tokens; - } - std::vector> remainingTokens; - for (const auto& [moduleName, _tokens] : tokensPerModuleName) { - auto _remainingTokens = PrepareTerminateAppAndGetRemainingInner(pid, moduleName, _tokens); - if (!_remainingTokens.empty()) { - remainingTokens.insert(remainingTokens.end(), _remainingTokens.begin(), _remainingTokens.end()); - } - } - return remainingTokens; -} - -int32_t UIAbilityLifecycleManager::TryPrepareTerminateByPids(const std::vector& pids) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - TAG_LOGI(AAFwkTag::ABILITYMGR, "prepare terminate app"); - IN_PROCESS_CALL_WITHOUT_RET(DelayedSingleton::GetInstance()->BlockProcessCacheByPids(pids)); - for (const auto &pid : pids) { - std::unordered_set> abilitysToTerminate; - std::vector> tokens; - IN_PROCESS_CALL_WITHOUT_RET( - DelayedSingleton::GetInstance()->GetAbilityRecordsByProcessID(pid, tokens)); - for (const auto &token : PrepareTerminateAppAndGetRemaining(pid, tokens)) { - auto abilityRecord = Token::GetAbilityRecordByToken(token); - if (PrepareTerminateAbility(abilityRecord, true)) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "terminate blocked"); - continue; - } - abilitysToTerminate.emplace(abilityRecord); - } - for (const auto &abilityRecord : abilitysToTerminate) { - TerminateSession(abilityRecord); - } - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "end."); - return ERR_OK; -} - -void UIAbilityLifecycleManager::TryPrepareTerminateByPidsDone(const std::string &moduleName, - int32_t prepareTermination, bool isExist) -{ - auto pid = IPCSkeleton::GetCallingPid(); - TAG_LOGD(AAFwkTag::ABILITYMGR, "call TryPrepareTerminateByPidsDone, pid=%{public}d", pid); - std::unique_lock lock(isTryPrepareTerminateByPidsDoneMutex_); - auto iter = std::find_if(prepareTerminateByPidRecords_.begin(), prepareTerminateByPidRecords_.end(), - [pid, _moduleName = moduleName](const std::shared_ptr &record) { - return record->pid_ == pid && record->moduleName_ == _moduleName; - }); - if (iter == prepareTerminateByPidRecords_.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "record with (pid=%{public}d,moduleName=%{public}s) not exist", - pid, moduleName.c_str()); - return; - } - if ((*iter) == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "record is nullptr"); - prepareTerminateByPidRecords_.erase(iter); - return; - } - (*iter)->prepareTermination_ = prepareTermination; - (*iter)->isExist_ = isExist; - (*iter)->isTryPrepareTerminateByPidsDone_.store(true); - isTryPrepareTerminateByPidsCv_.notify_one(); - prepareTerminateByPidRecords_.erase(iter); -} - -void UIAbilityLifecycleManager::CancelPrepareTerminate(std::shared_ptr abilityRecord) -{ - CHECK_POINTER(abilityRecord); - auto abilityInfo = abilityRecord->GetAbilityInfo(); - TAG_LOGI(AAFwkTag::ABILITYMGR, - "canceling PrepareTerminate,bundle=%{public}s,module=%{public}s,ability=%{public}s", - abilityInfo.bundleName.c_str(), abilityInfo.moduleName.c_str(), abilityInfo.name.c_str()); - std::unique_lock lock(isTryPrepareTerminateByPidsDoneMutex_); - auto iter = std::find_if(prepareTerminateByPidRecords_.begin(), prepareTerminateByPidRecords_.end(), - [pid = abilityRecord->GetPid(), moduleName = abilityInfo.moduleName]( - const std::shared_ptr &record) { - return record->pid_ == pid && record->moduleName_ == moduleName; - }); - if (iter == prepareTerminateByPidRecords_.end()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "record with (pid=%{public}d,moduleName=%{public}s) not exist", - abilityRecord->GetPid(), abilityInfo.moduleName.c_str()); - return; - } - if ((*iter) == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "record is nullptr"); - prepareTerminateByPidRecords_.erase(iter); - return; - } - // no need to terminate again, return cancel by default - (*iter)->prepareTermination_ = static_cast(AppExecFwk::PrepareTermination::CANCEL); - (*iter)->isExist_ = true; - (*iter)->isTryPrepareTerminateByPidsDone_.store(true); - isTryPrepareTerminateByPidsCv_.notify_one(); - prepareTerminateByPidRecords_.erase(iter); -} - -void UIAbilityLifecycleManager::BatchCloseUIAbility( - const std::unordered_set>& abilitySet) -{ - auto closeTask = [ self = shared_from_this(), abilitySet]() { - TAG_LOGI(AAFwkTag::ABILITYMGR, "abilities must close"); - if (self == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null manager"); - return; - } - for (const auto& ability : abilitySet) { - self->CloseUIAbility(ability, -1, nullptr, false, true); - } - }; - auto taskHandler = DelayedSingleton::GetInstance()->GetTaskHandler(); - if (taskHandler != nullptr) { - taskHandler->SubmitTask(closeTask, TaskQoS::USER_INTERACTIVE); - } -} - -void UIAbilityLifecycleManager::TerminateSession(std::shared_ptr abilityRecord) -{ - CHECK_POINTER(abilityRecord); - auto sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER(sessionInfo); - CHECK_POINTER(sessionInfo->sessionToken); - auto session = iface_cast(sessionInfo->sessionToken); - CHECK_POINTER(session); - TAG_LOGI(AAFwkTag::ABILITYMGR, "call TerminateSession, session id: %{public}d", sessionInfo->persistentId); - session->TerminateSession(sessionInfo); -} - -int UIAbilityLifecycleManager::ChangeAbilityVisibility(sptr token, bool isShow) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::shared_ptr abilityRecord; - { - std::lock_guard guard(sessionLock_); - abilityRecord = GetAbilityRecordByToken(token); - } - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); - if (IPCSkeleton::GetCallingTokenID() != abilityRecord->GetApplicationInfo().accessTokenId) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not self"); - return ERR_NATIVE_NOT_SELF_APPLICATION; - } - auto sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - - do { - if (HiddenStartObserverManager::GetInstance().IsHiddenStart(abilityRecord->GetPid())) { - if (!IsCallerInStatusBar(abilityRecord->GetInstanceKey())) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "no status bar while detaching."); - break; - } - auto ret = DoCallerProcessDetachment(abilityRecord); - if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller detach to status bar failed, ret: %{public}d", ret); - return ERR_START_OPTIONS_CHECK_FAILED; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "Hidden start allowed by observer."); - break; - } - if (!IsCallerInStatusBar(abilityRecord->GetInstanceKey()) && sessionInfo->processOptions != nullptr && - !ProcessOptions::IsNoAttachmentMode(sessionInfo->processOptions->processMode) && - !sessionInfo->processOptions->isRestartKeepAlive) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller not add to status bar"); - return ERR_START_OPTIONS_CHECK_FAILED; - } - if (sessionInfo->processOptions == nullptr || - (!ProcessOptions::IsAttachToStatusBarMode(sessionInfo->processOptions->processMode) && - !ProcessOptions::IsNoAttachmentMode(sessionInfo->processOptions->processMode) && - !sessionInfo->processOptions->isRestartKeepAlive)) { - auto ret = DoCallerProcessAttachment(abilityRecord); - if (ret != ERR_OK) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "caller attach to status bar failed, ret: %{public}d", ret); - return ERR_START_OPTIONS_CHECK_FAILED; - } - } - } while (false); - - auto callerSessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(callerSessionInfo, ERR_INVALID_VALUE); - CHECK_POINTER_AND_RETURN(callerSessionInfo->sessionToken, ERR_INVALID_VALUE); - auto callerSession = iface_cast(callerSessionInfo->sessionToken); - TAG_LOGI(AAFwkTag::ABILITYMGR, "got callerSession, call ChangeSessionVisibilityWithStatusBar()"); - CHECK_POINTER_AND_RETURN(callerSession, ERR_INVALID_VALUE); - return static_cast(callerSession->ChangeSessionVisibilityWithStatusBar(callerSessionInfo, isShow)); -} - -int UIAbilityLifecycleManager::ChangeUIAbilityVisibilityBySCB(sptr sessionInfo, bool isShow) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - auto iter = sessionAbilityMap_.find(sessionInfo->persistentId); - if (iter == sessionAbilityMap_.end()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability not found"); - return ERR_NATIVE_ABILITY_NOT_FOUND; - } - std::shared_ptr uiAbilityRecord = iter->second; - CHECK_POINTER_AND_RETURN(uiAbilityRecord, ERR_INVALID_VALUE); - if ((static_cast(uiAbilityRecord->GetOnNewWantSkipScenarios()) & - static_cast(ServerConstant::SCENARIO_SHOW_ABILITY)) == 0) { - uiAbilityRecord->SetIsNewWant(sessionInfo->isNewWant); - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "change ability visibility: %{public}d, isNewWant: %{public}d", - isShow, sessionInfo->isNewWant); - if (isShow) { - uiAbilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_SHOW); -#ifdef SUPPORT_SCREEN - if (uiAbilityRecord->GetPendingState() != AbilityState::INITIAL) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "pending state: FOREGROUND/ BACKGROUND, dropped"); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - return ERR_OK; - } else { - TAG_LOGD(AAFwkTag::ABILITYMGR, "pending state is not FOREGROUND or BACKGROUND."); - uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); - } - uiAbilityRecord->ProcessForegroundAbility(sessionInfo->callingTokenId); -#endif // SUPPORT_SCREEN - } else { - uiAbilityRecord->SetAbilityVisibilityState(AbilityVisibilityState::FOREGROUND_HIDE); - } - return ERR_OK; -} - -int32_t UIAbilityLifecycleManager::UpdateSessionInfoBySCB(std::list &sessionInfos, - std::vector &sessionIds) -{ - std::unordered_set> abilitySet; - { - std::lock_guard guard(sessionLock_); - isSCBRecovery_ = false; - for (auto [sessionId, abilityRecord] : sessionAbilityMap_) { - bool isFind = false; - for (auto iter = sessionInfos.begin(); iter != sessionInfos.end(); iter++) { - if (iter->persistentId == sessionId) { - abilityRecord->UpdateSessionInfo(iter->sessionToken); - sessionInfos.erase(iter); - isFind = true; - break; - } - } - if (!isFind && coldStartInSCBRecovery_.count(sessionId) == 0) { - abilitySet.emplace(abilityRecord); - } - } - coldStartInSCBRecovery_.clear(); - } - for (const auto &info : sessionInfos) { - sessionIds.emplace_back(info.persistentId); - } - - BatchCloseUIAbility(abilitySet); - TAG_LOGI(AAFwkTag::ABILITYMGR, "end of updating sessionInfo"); - return ERR_OK; -} - -void UIAbilityLifecycleManager::SignRestartAppFlag(int32_t uid, const std::string &instanceKey, bool isAppRecovery) -{ - std::lock_guard guard(sessionLock_); - auto tempSessionAbilityMap = sessionAbilityMap_; - for (auto &[sessionId, abilityRecord] : tempSessionAbilityMap) { - if (abilityRecord == nullptr || abilityRecord->GetUid() != uid || - abilityRecord->GetInstanceKey() != instanceKey) { - continue; - } - abilityRecord->SetRestartAppFlag(true); - std::string reason = "onAbilityDied"; - if (isAppRecovery) { - reason = "appRecovery"; - } - NotifySCBToHandleException(abilityRecord, static_cast(ErrorLifecycleState::ABILITY_STATE_DIED), - reason); - } -} - -void UIAbilityLifecycleManager::CompleteFirstFrameDrawing(int32_t sessionId) const -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "called"); - auto abilityRecord = GetAbilityRecordsById(sessionId); - if (abilityRecord == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "completeFirstFrameDrawing, get AbilityRecord by sessionId failed"); - return; - } - abilityRecord->ReportAtomicServiceDrawnCompleteEvent(); -#ifdef SUPPORT_SCREEN - abilityRecord->SetCompleteFirstFrameDrawing(true); - AppExecFwk::AbilityFirstFrameStateObserverManager::GetInstance(). - HandleOnFirstFrameState(abilityRecord); - AbilityStartWithWaitObserverManager::GetInstance().NotifyAATerminateWait(abilityRecord); -#endif // SUPPORT_SCREEN -} - -int UIAbilityLifecycleManager::StartWithPersistentIdByDistributed(const AbilityRequest &abilityRequest, - int32_t persistentId) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartWithPersistentIdByDistributed, called"); - auto sessionInfo = CreateSessionInfo(abilityRequest); - sessionInfo->requestCode = abilityRequest.requestCode; - sessionInfo->persistentId = persistentId; - sessionInfo->userId = userId_; - sessionInfo->isAtomicService = - (abilityRequest.abilityInfo.applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE); - std::string errMsg; - return NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg); -} - -int32_t UIAbilityLifecycleManager::GetAbilityStateByPersistentId(int32_t persistentId, bool &state) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "called"); - std::lock_guard guard(sessionLock_); - auto iter = sessionAbilityMap_.find(persistentId); - if (iter != sessionAbilityMap_.end()) { - std::shared_ptr uiAbilityRecord = iter->second; - if (uiAbilityRecord && uiAbilityRecord->GetPendingState() == AbilityState::INITIAL) { - state = true; - return ERR_OK; - } - } - state = false; - return ERR_INVALID_VALUE; -} - -int32_t UIAbilityLifecycleManager::CleanUIAbility( - const std::shared_ptr &abilityRecord) -{ - TAG_LOGD(AAFwkTag::ABILITYMGR, "call"); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_UI_ABILITY_MANAGER_NULL_ABILITY_RECORD); - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::string element = abilityRecord->GetElementName().GetURI(); - if (DelayedSingleton::GetInstance()->CleanAbilityByUserRequest(abilityRecord->GetToken())) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "user clean ability: %{public}s success", element.c_str()); - return ERR_OK; - } - TAG_LOGI(AAFwkTag::ABILITYMGR, - "can not force kill when user request clean ability, schedule lifecycle:%{public}s", element.c_str()); - return CloseUIAbility(abilityRecord, -1, nullptr, true, false); -} - -void UIAbilityLifecycleManager::CheckCallerFromBackground( - std::shared_ptr callerAbility, sptr &sessionInfo) -{ - CHECK_POINTER(callerAbility); - CHECK_POINTER(sessionInfo); - TAG_LOGD(AAFwkTag::ABILITYMGR, "called"); - auto permission = AAFwk::PermissionVerification::GetInstance(); - bool hasPermission = - permission->VerifyCallingPermission(PermissionConstants::PERMISSION_START_ABILITIES_FROM_BACKGROUND) || - permission->VerifyCallingPermission(PermissionConstants::PERMISSION_START_ABILIIES_FROM_BACKGROUND); - - sessionInfo->canStartAbilityFromBackground = hasPermission; - TAG_LOGD(AAFwkTag::ABILITYMGR, "CheckCallerFromBackground: %{public}d", sessionInfo->canStartAbilityFromBackground); -} - -void UIAbilityLifecycleManager::EnableListForSCBRecovery() -{ - std::lock_guard guard(sessionLock_); - isSCBRecovery_ = true; - coldStartInSCBRecovery_.clear(); -} - -std::shared_ptr UIAbilityLifecycleManager::FindRecordFromSessionMap(const AbilityRequest &abilityRequest) -{ - int32_t appIndex = 0; - (void)AbilityRuntime::StartupUtil::GetAppIndex(abilityRequest.want, appIndex); - auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - for (const auto &[sessionId, abilityRecord] : sessionAbilityMap_) { - if (abilityRecord) { - const auto &info = abilityRecord->GetAbilityInfo(); - if (info.bundleName == abilityRequest.abilityInfo.bundleName && - info.moduleName == abilityRequest.abilityInfo.moduleName && - appIndex == abilityRecord->GetAppIndex() && instanceKey == abilityRecord->GetInstanceKey()) { - return abilityRecord; - } - } - } - return nullptr; -} - -void UIAbilityLifecycleManager::AddSpecifiedRequest(std::shared_ptr request) -{ - if (!request) { - return; - } - - auto &abilityRequest = request->abilityRequest; - TAG_LOGI(AAFwkTag::ABILITYMGR, "AddSpecifiedRequest: %{public}d, %{public}s", request->requestId, - abilityRequest.want.GetElement().GetURI().c_str()); - auto instanceKey = abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY); - auto accessTokenIdStr = std::to_string(abilityRequest.abilityInfo.applicationInfo.accessTokenId); - auto &list = specifiedRequestList_[accessTokenIdStr + instanceKey]; - list.push_back(request); - if (list.size() == 1) { - StartSpecifiedRequest(*request); - } -} - -bool UIAbilityLifecycleManager::TryProcessHookModule(SpecifiedRequest &specifiedRequest, bool isHookModule) -{ - if (!isHookModule) { - return false; - } - auto abilityRecord = FindRecordFromSessionMap(specifiedRequest.abilityRequest); - if (abilityRecord == nullptr || !abilityRecord->IsHook() || abilityRecord->GetHookOff()) { - return false; - } - sptr hookSessionInfo = abilityRecord->GetSessionInfo(); - std::string errMsg; - NotifySCBPendingActivation(hookSessionInfo, specifiedRequest.abilityRequest, errMsg); - auto nextRequest = PopAndGetNextSpecified(specifiedRequest.requestId); - if (nextRequest) { - ffrt::submit([nextRequest, pThis = shared_from_this()]() { - std::lock_guard lock(pThis->sessionLock_); - pThis->StartSpecifiedRequest(*nextRequest); - }, ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); - } - return true; -} - -void UIAbilityLifecycleManager::StartSpecifiedRequest(SpecifiedRequest &specifiedRequest) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartSpecifiedRequest: %{public}d", specifiedRequest.requestId); - auto &request = specifiedRequest.abilityRequest; - - bool isDebug = false; - bool isLoaded = IsSpecifiedModuleLoaded(request, isDebug); - if (specifiedRequest.specifiedProcessState == SpecifiedProcessState::STATE_PROCESS) { - DelayedSingleton::GetInstance()->StartSpecifiedProcess(request.want, - request.abilityInfo, specifiedRequest.requestId); - } else { - if (specifiedRequest.preCreateProcessName) { - PreCreateProcessName(request); - } - if (TryProcessHookModule(specifiedRequest, IsHookModule(request))) { - return; - } - if (specifiedRequest.specifiedProcessState == SpecifiedProcessState::STATE_NONE && - specifiedRequest.requestListId == REQUEST_LIST_ID_INIT && !isLoaded) { - specifiedRequest.isCold = true; - auto sessionInfo = CreateSessionInfo(request); - sessionInfo->requestCode = request.requestCode; - sessionInfo->userId = userId_; - sessionInfo->requestId = specifiedRequest.requestId; - sessionInfo->isFromIcon = request.isFromIcon; - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartSpecifiedRequest cold"); - std::string errMsg; - auto result = NotifySCBPendingActivation(sessionInfo, request, errMsg); - if (result != ERR_OK) { - RemoveInstanceKey(request); - } - sessionInfo->want.RemoveAllFd(); - } else { - DelayedSingleton::GetInstance()->StartSpecifiedAbility(request.want, - request.abilityInfo, specifiedRequest.requestId); - } - } - if (request.want.GetBoolParam("debugApp", false) || request.want.GetBoolParam("nativeDebug", false) || - !request.want.GetStringParam("perfCmd").empty() || isDebug) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "StartSpecifiedRequest debug mode"); - return; - } - auto timeoutTask = [requestId = specifiedRequest.requestId, wThis = weak_from_this()]() { - auto pThis = wThis.lock(); - if (pThis) { - pThis->OnStartSpecifiedFailed(requestId); - } - }; - ffrt::submit(std::move(timeoutTask), ffrt::task_attr().name("SpecifiedFinalTimeout") - .delay(GlobalConstant::TIMEOUT_UNIT_TIME_MICRO * (int64_t)GlobalConstant::COLDSTART_TIMEOUT_MULTIPLE)); -} - -void UIAbilityLifecycleManager::RemoveInstanceKey(const AbilityRequest &abilityRequest) const -{ - if (!abilityRequest.want.HasParameter(Want::APP_INSTANCE_KEY)) { - return; - } - auto sceneSessionManager = Rosen::SessionManagerLite::GetInstance().GetSceneSessionManagerLiteProxy(); - if (sceneSessionManager != nullptr) { - Rosen::WMError ret = sceneSessionManager->RemoveInstanceKey(abilityRequest.want.GetBundle(), - abilityRequest.want.GetStringParam(Want::APP_INSTANCE_KEY)); - TAG_LOGI(AAFwkTag::ABILITYMGR, "remove instance key ret:%{public}d", ret); - } -} - -std::shared_ptr UIAbilityLifecycleManager::PopAndGetNextSpecified(int32_t requestId) -{ - for (auto iter = specifiedRequestList_.begin(); iter != specifiedRequestList_.end(); ++iter) { - auto &list = iter->second; - if (!list.empty() && list.front()->requestId == requestId) { - list.pop_front(); - if (list.empty()) { - TAG_LOGI(AAFwkTag::ABILITYMGR, "empty list"); - specifiedRequestList_.erase(iter); - return nullptr; - } else { - return list.front(); - } - } - } - TAG_LOGI(AAFwkTag::ABILITYMGR, "unknown request: %{public}d", requestId); - return nullptr; -} - -bool UIAbilityLifecycleManager::IsSpecifiedModuleLoaded(const AbilityRequest &abilityRequest, bool &isDebug) -{ - auto appMgr = AppMgrUtil::GetAppMgr(); - if (appMgr == nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "AppMgrUtil::GetAppMgr failed"); - return false; - } - bool appExist = false; - auto ret = IN_PROCESS_CALL(appMgr->IsSpecifiedModuleLoaded(abilityRequest.want, - abilityRequest.abilityInfo, appExist, isDebug)); - return ret == ERR_OK && appExist; -} - -bool UIAbilityLifecycleManager::HandleStartSpecifiedCold(AbilityRequest &abilityRequest, sptr sessionInfo, - uint32_t sceneFlag) -{ - if (!sessionInfo) { - return false; - } - const auto &abilityInfo = abilityRequest.abilityInfo; - if (abilityInfo.launchMode != AppExecFwk::LaunchMode::SPECIFIED) { - return false; - } - - auto request = GetSpecifiedRequest(sessionInfo->requestId); - if (request == nullptr || !request->isCold) { - return false; - } - - TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleStartSpecifiedCold: %{public}d, persitentId: %{public}d", - request->requestId, sessionInfo->persistentId); - request->persistentId = sessionInfo->persistentId; - request->sceneFlag = sceneFlag; - request->callingTokenId = sessionInfo->callingTokenId; - return true; -} - -bool UIAbilityLifecycleManager::HandleColdAcceptWantDone(const AAFwk::Want &want, const std::string &flag, - const SpecifiedRequest &specifiedRequest) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - auto iter = sessionAbilityMap_.find(specifiedRequest.persistentId); - if (iter == sessionAbilityMap_.end() || !(iter->second) || - !(iter->second->GetSpecifiedFlag().empty())) { - return false; - } - - TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleColdAcceptWantDone: %{public}d, session:%{public}d", - specifiedRequest.requestId, specifiedRequest.persistentId); - auto uiAbilityRecord = iter->second; - CHECK_POINTER_AND_RETURN(uiAbilityRecord, false); - UpdateSpecifiedFlag(uiAbilityRecord, flag); - uiAbilityRecord->SetSpecifiedFlag(flag); - auto isShellCall = specifiedRequest.abilityRequest.want.GetBoolParam(IS_SHELL_CALL, false); - uiAbilityRecord->ProcessForegroundAbility(specifiedRequest.callingTokenId, - specifiedRequest.sceneFlag, isShellCall); - SendKeyEvent(specifiedRequest.abilityRequest); - return true; -} - -std::shared_ptr UIAbilityLifecycleManager::GetSpecifiedRequest(int32_t requestId) -{ - for (const auto &[key, list] : specifiedRequestList_) { - if (!list.empty() && list.front()->requestId == requestId) { - return list.front(); - } - } - return nullptr; -} - -void UIAbilityLifecycleManager::SetKillForPermissionUpdateFlag(uint32_t accessTokenId) -{ - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - std::lock_guard guard(sessionLock_); - for (auto it = sessionAbilityMap_.begin(); it != sessionAbilityMap_.end(); it++) { - if (it->second == nullptr) { - continue; - } - auto &abilityInfo = it->second->GetAbilityInfo(); - auto &applicationInfo = it->second->GetApplicationInfo(); - if (applicationInfo.accessTokenId == accessTokenId && - applicationInfo.bundleType == AppExecFwk::BundleType::ATOMIC_SERVICE && - abilityInfo.type == AppExecFwk::AbilityType::PAGE) { - it->second->SetKillForPermissionUpdateFlag(true); - } - } -} - -void UIAbilityLifecycleManager::HandleForegroundCollaborate( - const AbilityRequest &abilityRequest, std::shared_ptr abilityRecord) -{ - abilityRecord->SetWant(abilityRequest.want); - if (abilityRecord->GetAbilityState() == AbilityState::FOREGROUND) { - abilityRecord->ScheduleCollaborate(abilityRequest.want); - } -} - -bool UIAbilityLifecycleManager::UpdateSpecifiedFlag(std::shared_ptr uiAbilityRecord, - const std::string &flag) -{ - if (uiAbilityRecord == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "uiAbilityRecord is nullptr"); - return false; - } - auto sessionInfo = uiAbilityRecord->GetSessionInfo(); - if (sessionInfo == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "sessionInfo is nullptr"); - return false; - } - auto session = iface_cast(sessionInfo->sessionToken); - if (session == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "session is nullptr"); - return false; - } - session->UpdateFlag(flag); - TAG_LOGD(AAFwkTag::ABILITYMGR, "call session UpdateFlag, specifiedFlag: %{public}s", flag.c_str()); - return true; -} - -int32_t UIAbilityLifecycleManager::RevokeDelegator(sptr token) -{ - if (token == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "null token"); - return ERR_INVALID_CONTEXT; - } - std::lock_guard guard(sessionLock_); - auto abilityRecord = Token::GetAbilityRecordByToken(token); - CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_CONTEXT); - auto callingTokenId = IPCSkeleton::GetCallingTokenID(); - if (callingTokenId != abilityRecord->GetApplicationInfo().accessTokenId) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "not self"); - return ERR_INVALID_CONTEXT; - } - if (!abilityRecord->IsForeground() && !abilityRecord->GetAbilityForegroundingFlag()) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "ability not foreground"); - return ERR_ABILITY_NOT_FOREGROUND; - } - if (!abilityRecord->IsHook()) { - return ERR_NOT_HOOK; - } - auto abilityInfo = abilityRecord->GetAbilityInfo(); - auto isSpecified = (abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED); - if (isSpecified) { - auto requestId = RequestIdUtil::GetRequestId(); - hookSpecifiedMap_.emplace(requestId, abilityRecord); - DelayedSingleton::GetInstance()->StartSpecifiedAbility(abilityRecord->GetWant(), - abilityInfo, requestId); - return ERR_OK; - } - auto sessionInfo = abilityRecord->GetSessionInfo(); - CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE); - sessionInfo->reuseDelegatorWindow = true; - auto launchWant = abilityRecord->GetLaunchWant(); - if (launchWant == nullptr) { - TAG_LOGE(AAFwkTag::ABILITYMGR, "launchWant is nullptr"); - return ERR_INVALID_VALUE; - } - sessionInfo->want = *launchWant; - abilityRecord->SetWant(sessionInfo->want); - AbilityRequest request; - request.callerToken = token; - std::string errMsg; - int ret = NotifySCBPendingActivation(sessionInfo, request, errMsg); - TAG_LOGI( - AAFwkTag::ABILITYMGR, "Reused sessionId: %{public}d, ret: %{public}d.", sessionInfo->persistentId, ret); - sessionInfo->reuseDelegatorWindow = false; - sessionInfo->want.RemoveAllFd(); - if (ret == ERR_OK) { - abilityRecord->SetHookOff(true); - abilityRecord->SetIsHook(false); - abilityRecord->SetLaunchWant(nullptr); - return ERR_OK; - } else { - TAG_LOGE(AAFwkTag::ABILITYMGR, "scb error"); - return ERR_FROM_WINDOW; - } -} - -int32_t UIAbilityLifecycleManager::NotifyStartupExceptionBySCB(int32_t requestId, const std::string &reason) -{ - TAG_LOGI(AAFwkTag::ABILITYMGR, "scb notify exception:%{public}d", requestId); - std::lock_guard guard(sessionLock_); - for (auto it = tmpAbilityMap_.begin(); it != tmpAbilityMap_.end(); ++it) { - if (requestId == it->first) { - auto abilityRecord = it->second; - if (abilityRecord != nullptr) { - TAG_LOGW(AAFwkTag::ABILITYMGR, "startup exception: %{public}s", abilityRecord->GetURI().c_str()); - SendAbilityEvent(abilityRecord->GetAbilityInfo(), reason); - } - tmpAbilityMap_.erase(it); - callRequestCache_.erase(abilityRecord); - return ERR_OK; - } - } - - auto request = GetSpecifiedRequest(requestId); - if (request != nullptr) { - std::string reasonFromSCB = "SCB intercepted this startup attempt"; - SendAbilityEvent(request->abilityRequest.abilityInfo, reasonFromSCB); - } - - auto nextRequest = PopAndGetNextSpecified(requestId); - if (nextRequest) { - ffrt::submit([nextRequest, pThis = shared_from_this()]() { - std::lock_guard lock(pThis->sessionLock_); - pThis->StartSpecifiedRequest(*nextRequest); - }, ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::DEFAULT_FFRT_TASK_TIMEOUT)); - } - return ERR_OK; -} - -void UIAbilityLifecycleManager::SendAbilityEvent(const AppExecFwk::AbilityInfo &abilityInfo, - const std::string &reason) const -{ - EventInfo eventInfo; - eventInfo.userId = userId_; - eventInfo.abilityName = abilityInfo.name; - eventInfo.bundleName = abilityInfo.bundleName; - eventInfo.moduleName = abilityInfo.moduleName; - eventInfo.errCode = ERR_SCB_INTERCEPTION; - eventInfo.errMsg = reason; - ffrt::submit([eventInfo]() { - EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo); - }, ffrt::task_attr().timeout(AbilityRuntime::GlobalConstant::FFRT_TASK_TIMEOUT)); -} -} // namespace AAFwk -} // namespace OHOS \ No newline at end of file -- Gitee