diff --git a/frameworks/kits/ability/ability_runtime/BUILD.gn b/frameworks/kits/ability/ability_runtime/BUILD.gn index 4cb8bfd8cd093c676728e5eb6b17f4de93bf8650..25671b0711bcfbb89b259259082509eaab5af40e 100644 --- a/frameworks/kits/ability/ability_runtime/BUILD.gn +++ b/frameworks/kits/ability/ability_runtime/BUILD.gn @@ -50,6 +50,7 @@ ohos_shared_library("ability_context_native") { external_deps = [ "aafwk_standard:runtime", + "bytrace_standard:bytrace_core", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "utils_base:utils", diff --git a/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp b/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp index d585dcd03d8507477e6cbc4e2d01e43eb7e075bc..2abf85bd7020849b51e43893699024888d1bac72 100644 --- a/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp +++ b/frameworks/kits/ability/ability_runtime/src/ability_context_impl.cpp @@ -16,6 +16,7 @@ #include "ability_context_impl.h" #include "ability_manager_client.h" +#include "bytrace.h" #include "connection_manager.h" #include "hilog_wrapper.h" @@ -58,45 +59,46 @@ std::string AbilityContextImpl::GetDistributedFilesDir() ErrCode AbilityContextImpl::StartAbility(const AAFwk::Want &want, int requestCode) { - HILOG_DEBUG("AbilityContextImpl::StartAbility. Start calling ams->StartAbility."); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_DEBUG("AbilityContextImpl::StartAbility. Start calling StartAbility."); ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, token_, requestCode); - HILOG_INFO("AbilityContextImpl::StartAbility. End calling ams->StartAbility. ret=%{public}d", err); + HILOG_INFO("AbilityContextImpl::StartAbility. End calling StartAbility. ret=%{public}d", err); return err; } ErrCode AbilityContextImpl::StartAbility(const AAFwk::Want &want, const AAFwk::StartOptions &startOptions, int requestCode) { - HILOG_DEBUG("AbilityContextImpl::StartAbility. Start calling ams->StartAbility."); + HILOG_DEBUG("AbilityContextImpl::StartAbility. Start calling StartAbility."); ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, startOptions, token_, requestCode); - HILOG_INFO("AbilityContextImpl::StartAbility. End calling ams->StartAbility. ret=%{public}d", err); + HILOG_INFO("AbilityContextImpl::StartAbility. End calling StartAbility. ret=%{public}d", err); return err; } ErrCode AbilityContextImpl::StartAbilityForResult(const AAFwk::Want &want, int requestCode, RuntimeTask &&task) { - HILOG_DEBUG("%{public}s. Start calling ams->StartAbilityForResult.", __func__); + HILOG_DEBUG("%{public}s. Start calling StartAbilityForResult.", __func__); resultCallbacks_.insert(make_pair(requestCode, std::move(task))); ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want, token_, requestCode); - HILOG_INFO("%{public}s. End calling ams->StartAbilityForResult. ret=%{public}d", __func__, err); + HILOG_INFO("%{public}s. End calling StartAbilityForResult. ret=%{public}d", __func__, err); return err; } ErrCode AbilityContextImpl::TerminateAbilityWithResult(const AAFwk::Want &want, int resultCode) { - HILOG_DEBUG("%{public}s. Start calling ams->TerminateAbilityWithResult.", __func__); + HILOG_DEBUG("%{public}s. Start calling TerminateAbilityWithResult.", __func__); ErrCode err = AAFwk::AbilityManagerClient::GetInstance()->TerminateAbility(token_, resultCode, &want); - HILOG_INFO("%{public}s. End calling ams->TerminateAbilityWithResult. ret=%{public}d", __func__, err); + HILOG_INFO("%{public}s. End calling TerminateAbilityWithResult. ret=%{public}d", __func__, err); return err; } void AbilityContextImpl::OnAbilityResult(int requestCode, int resultCode, const AAFwk::Want &resultData) { - HILOG_DEBUG("%{public}s. Start calling ams->OnAbilityResult.", __func__); + HILOG_DEBUG("%{public}s. Start calling OnAbilityResult.", __func__); resultCallbacks_[requestCode](resultCode, resultData); resultCallbacks_.erase(requestCode); - HILOG_INFO("%{public}s. End calling ams->OnAbilityResult.", __func__); + HILOG_INFO("%{public}s. End calling OnAbilityResult.", __func__); } bool AbilityContextImpl::ConnectAbility(const AAFwk::Want &want, @@ -116,9 +118,9 @@ void AbilityContextImpl::DisconnectAbility(const AAFwk::Want &want, ErrCode ret = ConnectionManager::GetInstance().DisconnectAbility(token_, want.GetElement(), connectCallback); if (ret != ERR_OK) { - HILOG_ERROR("%{public}s end ams->DisconnectAbility error, ret=%{public}d", __func__, ret); + HILOG_ERROR("%{public}s end DisconnectAbility error, ret=%{public}d", __func__, ret); } - HILOG_INFO("%{public}s end ams->DisconnectAbility", __func__); + HILOG_INFO("%{public}s end DisconnectAbility", __func__); } std::string AbilityContextImpl::GetBundleName() const diff --git a/frameworks/kits/ability/native/include/ability_impl.h b/frameworks/kits/ability/native/include/ability_impl.h index eceba3ece6d494704033afe3445288a339171e60..c1240698e951fdff2bafee00490f5f76c13a896c 100755 --- a/frameworks/kits/ability/native/include/ability_impl.h +++ b/frameworks/kits/ability/native/include/ability_impl.h @@ -46,6 +46,20 @@ public: std::shared_ptr &ability, std::shared_ptr &handler, const sptr &token, std::shared_ptr &contextDeal); + /** + * @brief Set if use new mission. + * + * @param useNewMission new mission flag. + */ + static void SetUseNewMission(bool useNewMission); + + /** + * @brief Get if use new mission. + * + * @return return true if use new mission. + */ + static bool IsUseNewMission(); + /** * @brief Connect the ability. and Calling information back to Ability. * diff --git a/frameworks/kits/ability/native/include/page_ability_impl.h b/frameworks/kits/ability/native/include/page_ability_impl.h index 048fe8c84fced9cd106354cbf3fb557f93d735a3..7782fbe69dbd70654f3fe510014a78608d739cb8 100644 --- a/frameworks/kits/ability/native/include/page_ability_impl.h +++ b/frameworks/kits/ability/native/include/page_ability_impl.h @@ -58,6 +58,17 @@ public: */ bool AbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState); + /** + * @brief Handling the life cycle switching of PageAbility in switch. + * + * @param want Indicates the structure containing information about the ability. + * @param targetState The life cycle state to switch to. + * + * @return return true if the lifecycle transaction successfully, otherwise return false. + * + */ + bool AbilityTransactionNew(const Want &want, const AAFwk::LifeCycleStateInfo &targetState); + /** * @brief Execution the KeyDown callback of the ability * @param keyEvent Indicates the key-down event. diff --git a/frameworks/kits/ability/native/src/ability.cpp b/frameworks/kits/ability/native/src/ability.cpp index c457361bee0f25d764cd96c4c9209d2c7a1ac1b6..f62297a73c27f7b73a2307c3e4371f54baca87b7 100644 --- a/frameworks/kits/ability/native/src/ability.cpp +++ b/frameworks/kits/ability/native/src/ability.cpp @@ -18,6 +18,7 @@ #include #include +#include "ability_impl.h" #include "ability_loader.h" #include "ability_post_event_timeout.h" #include "ability_runtime/js_ability.h" @@ -169,7 +170,7 @@ std::shared_ptr Ability::GetResourceManager() */ void Ability::OnStart(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (abilityInfo_ == nullptr) { APP_LOGE("Ability::OnStart falied abilityInfo_ is nullptr."); @@ -244,7 +245,7 @@ void Ability::OnStart(const Want &want) */ void Ability::OnStop() { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (scene_ != nullptr) { scene_ = nullptr; @@ -284,7 +285,7 @@ void Ability::OnStop() */ void Ability::OnActive() { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (abilityWindow_ != nullptr) { APP_LOGI("%{public}s begin abilityWindow_->OnPostAbilityActive.", __func__); @@ -314,7 +315,7 @@ void Ability::OnActive() */ void Ability::OnInactive() { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (abilityWindow_ != nullptr && abilityInfo_->type == AppExecFwk::AbilityType::PAGE) { APP_LOGI("%{public}s begin abilityWindow_->OnPostAbilityInactive.", __func__); @@ -378,7 +379,7 @@ void Ability::onSceneDestroyed() */ void Ability::OnForeground(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); DoOnForeground(want); DispatchLifecycleOnForeground(want); @@ -427,7 +428,7 @@ void Ability::NotityContinuationResult(const Want& want, bool success) */ void Ability::OnBackground() { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) { APP_LOGI("%{public}s begin OnPostAbilityBackground.", __func__); @@ -476,7 +477,7 @@ void Ability::OnBackground() */ sptr Ability::OnConnect(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); if (abilityLifecycleExecutor_ == nullptr) { APP_LOGE("Ability::OnConnect error. abilityLifecycleExecutor_ == nullptr."); @@ -501,7 +502,7 @@ sptr Ability::OnConnect(const Want &want) */ void Ability::OnDisconnect(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); } /** @@ -673,9 +674,15 @@ void Ability::InitWindow(Rosen::WindowType winType) APP_LOGE("Ability::InitWindow abilityWindow_ is nullptr"); return; } - + bool useNewMission = AbilityImpl::IsUseNewMission(); APP_LOGI("%{public}s beign abilityWindow_->InitWindow.", __func__); - abilityWindow_->InitWindow(winType, abilityContext_, sceneListener_); + if (useNewMission) { + abilityWindow_->InitWindow(winType, abilityContext_, sceneListener_); + } else { + std::shared_ptr context = nullptr; + sptr listener = nullptr; + abilityWindow_->InitWindow(winType, context, listener); + } APP_LOGI("%{public}s end abilityWindow_->InitWindow.", __func__); } @@ -1140,7 +1147,7 @@ void Ability::SetVolumeTypeAdjustedByKey(int volumeType) */ void Ability::OnCommand(const AAFwk::Want &want, bool restart, int startId) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin restart=%{public}s,startId=%{public}d.", __func__, restart ? "true" : "false", startId); if (abilityLifecycleExecutor_ == nullptr) { APP_LOGE("Ability::OnCommand error. abilityLifecycleExecutor_ == nullptr."); diff --git a/frameworks/kits/ability/native/src/ability_impl.cpp b/frameworks/kits/ability/native/src/ability_impl.cpp index 31af78f66b774df0ccf02afd6396dbd26d08073c..feb6cc865b5edb7dddeb3a161a069f539e25d5d4 100755 --- a/frameworks/kits/ability/native/src/ability_impl.cpp +++ b/frameworks/kits/ability/native/src/ability_impl.cpp @@ -23,12 +23,14 @@ namespace OHOS { namespace AppExecFwk { const int TARGET_VERSION_THRESHOLDS = 8; +static bool g_useNewMission = false; +static bool g_isMissionFlagSetted = false; void AbilityImpl::Init(std::shared_ptr &application, const std::shared_ptr &record, std::shared_ptr &ability, std::shared_ptr &handler, const sptr &token, std::shared_ptr &contextDeal) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityImpl::init begin"); if ((token == nullptr) || (application == nullptr) || (handler == nullptr) || (record == nullptr) || ability == nullptr || contextDeal == nullptr) { @@ -203,6 +205,7 @@ void AbilityImpl::AfterUnFocused() void AbilityImpl::WindowLifeCycleImpl::AfterForeground() { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); auto owner = owner_.lock(); if (owner && owner->GetCompatibleVersion() < TARGET_VERSION_THRESHOLDS) { @@ -217,6 +220,7 @@ void AbilityImpl::WindowLifeCycleImpl::AfterForeground() void AbilityImpl::WindowLifeCycleImpl::AfterBackground() { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("%{public}s begin.", __func__); auto owner = owner_.lock(); if (owner && owner->GetCompatibleVersion() < TARGET_VERSION_THRESHOLDS) { @@ -906,5 +910,18 @@ void AbilityImpl::NotifyContinuationResult(const int32_t result) } ability_->OnCompleteContinuation(result); } + +void AbilityImpl::SetUseNewMission(bool useNewMission) +{ + if (!g_isMissionFlagSetted) { + g_isMissionFlagSetted = true; + g_useNewMission = useNewMission; + } +} + +bool AbilityImpl::IsUseNewMission() +{ + return g_useNewMission; +} } // namespace AppExecFwk } // namespace OHOS diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp index 5c11d6ff05f9cfc52db76e0e60666dc032d7f6bf..52a8a8bc64ec7b0a5d1600b84796e6ef79023841 100644 --- a/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp @@ -17,6 +17,7 @@ #include +#include "bytrace.h" #include "hilog_wrapper.h" #include "js_context_utils.h" #include "js_data_struct_converter.h" @@ -45,6 +46,7 @@ void JsAbilityContext::Finalizer(NativeEngine* engine, void* data, void* hint) NativeValue* JsAbilityContext::StartAbility(NativeEngine* engine, NativeCallbackInfo* info) { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); JsAbilityContext* me = CheckParamsAndGetThis(engine, info); return (me != nullptr) ? me->OnStartAbility(*engine, *info) : nullptr; } diff --git a/frameworks/kits/ability/native/src/ability_thread.cpp b/frameworks/kits/ability/native/src/ability_thread.cpp index 7e23ce2e55d51941ff0da97d98a0ab1b3283202a..cee7f5e6f31afb6fe0111db5ec035a21b57c82fa 100644 --- a/frameworks/kits/ability/native/src/ability_thread.cpp +++ b/frameworks/kits/ability/native/src/ability_thread.cpp @@ -166,7 +166,7 @@ void AbilityThread::Attach(std::shared_ptr &application, const std::shared_ptr &abilityRecord, const std::shared_ptr &mainRunner, const std::shared_ptr &stageContext) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::Attach begin"); if ((application == nullptr) || (abilityRecord == nullptr) || (mainRunner == nullptr)) { APP_LOGE("AbilityThread::ability attach failed,context or record is nullptr"); @@ -235,7 +235,7 @@ void AbilityThread::Attach(std::shared_ptr &application, void AbilityThread::AttachExtension(std::shared_ptr &application, const std::shared_ptr &abilityRecord, const std::shared_ptr &mainRunner) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::AttachExtension begin"); if ((application == nullptr) || (abilityRecord == nullptr) || (mainRunner == nullptr)) { APP_LOGE("AbilityThread::AttachExtension attach failed,context or record is nullptr"); @@ -290,7 +290,7 @@ void AbilityThread::AttachExtension(std::shared_ptr &applicatio void AbilityThread::AttachExtension(std::shared_ptr &application, const std::shared_ptr &abilityRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::AttachExtension begin"); if ((application == nullptr) || (abilityRecord == nullptr)) { APP_LOGE("AbilityThread::AttachExtension failed,context or record is nullptr"); @@ -349,7 +349,7 @@ void AbilityThread::Attach( std::shared_ptr &application, const std::shared_ptr &abilityRecord, const std::shared_ptr &stageContext) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::Attach begin"); if ((application == nullptr) || (abilityRecord == nullptr)) { APP_LOGE("AbilityThread::ability attach failed,context or record is nullptr"); @@ -420,7 +420,7 @@ void AbilityThread::Attach( */ void AbilityThread::HandleAbilityTransaction(const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleAbilityTransaction begin"); if (abilityImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleAbilityTransaction abilityImpl_ == nullptr"); @@ -446,7 +446,7 @@ void AbilityThread::HandleAbilityTransaction(const Want &want, const LifeCycleSt */ void AbilityThread::HandleExtensionTransaction(const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleExtensionTransaction begin"); if (extensionImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleExtensionTransaction extensionImpl_ == nullptr"); @@ -462,7 +462,7 @@ void AbilityThread::HandleExtensionTransaction(const Want &want, const LifeCycle */ void AbilityThread::HandleConnectAbility(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleConnectAbility begin"); if (abilityImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleConnectAbility abilityImpl_ == nullptr"); @@ -486,7 +486,7 @@ void AbilityThread::HandleConnectAbility(const Want &want) */ void AbilityThread::HandleDisconnectAbility(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleDisconnectAbility begin"); if (abilityImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleDisconnectAbility abilityImpl_ == nullptr"); @@ -519,7 +519,7 @@ void AbilityThread::HandleDisconnectAbility(const Want &want) */ void AbilityThread::HandleCommandAbility(const Want &want, bool restart, int startId) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleCommandAbility begin"); APP_LOGI("AbilityThread::HandleCommandAbility before abilityImpl_->CommandAbility"); abilityImpl_->CommandAbility(want, restart, startId); @@ -540,7 +540,7 @@ void AbilityThread::HandleCommandAbility(const Want &want, bool restart, int sta */ void AbilityThread::HandleConnectExtension(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleConnectExtension begin"); if (extensionImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleConnectExtension extensionImpl_ == nullptr"); @@ -559,7 +559,7 @@ void AbilityThread::HandleConnectExtension(const Want &want) */ void AbilityThread::HandleDisconnectExtension(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleDisconnectExtension begin"); if (extensionImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleDisconnectExtension extensionImpl_ == nullptr"); @@ -585,7 +585,7 @@ void AbilityThread::HandleDisconnectExtension(const Want &want) */ void AbilityThread::HandleCommandExtension(const Want &want, bool restart, int startId) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("AbilityThread::HandleCommandExtension begin"); if (extensionImpl_ == nullptr) { APP_LOGE("AbilityThread::HandleCommandExtension extensionImpl_ == nullptr"); @@ -702,6 +702,7 @@ void AbilityThread::HandleUpdateConfiguration(const Configuration &config) */ void AbilityThread::ScheduleAbilityTransaction(const Want &want, const LifeCycleStateInfo &lifeCycleStateInfo) { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); APP_LOGI("ScheduleAbilityTransaction begin: targeState = %{public}d, isNewWant = %{public}d", lifeCycleStateInfo.state, lifeCycleStateInfo.isNewWant); diff --git a/frameworks/kits/ability/native/src/extension_impl.cpp b/frameworks/kits/ability/native/src/extension_impl.cpp index 65361e81524d872074c2cd54c1d51def9741ed10..0286fddd1796667ee8d3d9a6ed1783a71bb15b6f 100644 --- a/frameworks/kits/ability/native/src/extension_impl.cpp +++ b/frameworks/kits/ability/native/src/extension_impl.cpp @@ -28,7 +28,7 @@ void ExtensionImpl::Init(std::shared_ptr &applicati std::shared_ptr &handler, const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("ExtensionImpl Init begin."); if ((token == nullptr) || (application == nullptr) || (handler == nullptr) || (record == nullptr) || extension == nullptr) { diff --git a/frameworks/kits/ability/native/src/page_ability_impl.cpp b/frameworks/kits/ability/native/src/page_ability_impl.cpp index 6f188d88cd4fe4e4e3d3dcfe6975104a4b1bba6c..5828ad80424faa338554d284c1774dedebb3d241 100644 --- a/frameworks/kits/ability/native/src/page_ability_impl.cpp +++ b/frameworks/kits/ability/native/src/page_ability_impl.cpp @@ -28,6 +28,7 @@ using AbilityManagerClient = OHOS::AAFwk::AbilityManagerClient; */ void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) { + AbilityImpl::SetUseNewMission(targetState.useNewMission); APP_LOGI("PageAbilityImpl::HandleAbilityTransaction begin sourceState:%{public}d; targetState: %{public}d; " "isNewWant: %{public}d", lifecycleState_, @@ -50,12 +51,17 @@ void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::Li Inactive(); } - if (targetState.state == AAFwk::ABILITY_STATE_BACKGROUND_NEW) { + if (targetState.state == AAFwk::ABILITY_STATE_BACKGROUND_NEW || + targetState.state == AAFwk::ABILITY_STATE_BACKGROUND) { CheckAndSave(); } bool ret = false; - ret = AbilityTransaction(want, targetState); + if (AbilityImpl::IsUseNewMission()) { + ret = AbilityTransactionNew(want, targetState); + } else { + ret = AbilityTransaction(want, targetState); + } if (ret) { APP_LOGI("AbilityThread::HandleAbilityTransaction before AbilityManagerClient->AbilityTransitionDone"); AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, targetState.state, GetRestoreData()); @@ -74,6 +80,61 @@ void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::Li * */ bool PageAbilityImpl::AbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) +{ + APP_LOGI("PageAbilityImpl::AbilityTransaction begin"); + bool ret = true; + switch (targetState.state) { + case AAFwk::ABILITY_STATE_INITIAL: { + if (lifecycleState_ == AAFwk::ABILITY_STATE_INACTIVE) { + Background(); + } + Stop(); + break; + } + case AAFwk::ABILITY_STATE_INACTIVE: { + if (lifecycleState_ == AAFwk::ABILITY_STATE_BACKGROUND) { + Foreground(want); + } + break; + } + case AAFwk::ABILITY_STATE_ACTIVE: { + if (lifecycleState_ == AAFwk::ABILITY_STATE_BACKGROUND) { + Foreground(want); + } + if (targetState.isNewWant) { + NewWant(want); + } + SerUriString(targetState.caller.deviceId + "/" + targetState.caller.bundleName + "/" + + targetState.caller.abilityName); + Active(); + break; + } + case AAFwk::ABILITY_STATE_BACKGROUND: { + if (lifecycleState_ == AAFwk::ABILITY_STATE_INACTIVE) { + Background(); + } + break; + } + default: { + ret = false; + APP_LOGE("PageAbilityImpl::HandleAbilityTransaction state error"); + break; + } + } + APP_LOGI("PageAbilityImpl::AbilityTransaction end: retVal = %{public}d", (int)ret); + return ret; +} + +/** + * @brief Handling the life cycle switching of PageAbility in switch. + * + * @param want Indicates the structure containing information about the ability. + * @param targetState The life cycle state to switch to. + * + * @return return true if the lifecycle transaction successfully, otherwise return false. + * + */ +bool PageAbilityImpl::AbilityTransactionNew(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) { APP_LOGI("PageAbilityImpl::AbilityTransaction begin"); bool ret = true; diff --git a/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h b/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h index 26c8355dad9586b70304a1f6ef2b48b569bf3f0f..df11ed76f4aca73ab1994efd935726720a0ce2b8 100644 --- a/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h +++ b/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h @@ -53,6 +53,7 @@ struct LifeCycleStateInfo : public Parcelable { CallerInfo caller; std::shared_ptr setting = nullptr; LaunchParam launchParam; + bool useNewMission = false; bool ReadFromParcel(Parcel &parcel); virtual bool Marshalling(Parcel &parcel) const override; diff --git a/interfaces/kits/napi/aafwk/mission_manager/napi_mission_registration.cpp b/interfaces/kits/napi/aafwk/mission_manager/napi_mission_registration.cpp index 5b1294c1714e24726e561ca4ff1b2cc24f49d343..c4e1e70c117635e61a7600a3b3a2448d8b3da843 100644 --- a/interfaces/kits/napi/aafwk/mission_manager/napi_mission_registration.cpp +++ b/interfaces/kits/napi/aafwk/mission_manager/napi_mission_registration.cpp @@ -196,7 +196,7 @@ napi_value NAPI_StartSyncRemoteMissions(napi_env env, napi_callback_info info) auto syncContext = new SyncRemoteMissionsContext(); if (syncContext == nullptr) { HILOG_ERROR("%{public}s, syncContext is nullptr.", __func__); - NAPI_ASSERT(env, syncContext == nullptr, "Wrong argument"); + NAPI_ASSERT(env, false, "wrong arguments"); } if (!ProcessSyncInput(env, info, true, syncContext)) { delete syncContext; @@ -272,7 +272,7 @@ napi_value NAPI_StopSyncRemoteMissions(napi_env env, napi_callback_info info) auto syncContext = new SyncRemoteMissionsContext(); if (syncContext == nullptr) { HILOG_ERROR("%{public}s, syncContext is nullptr.", __func__); - NAPI_ASSERT(env, syncContext == nullptr, "Wrong argument"); + NAPI_ASSERT(env, false, "wrong arguments"); } if (!ProcessSyncInput(env, info, false, syncContext)) { delete syncContext; @@ -553,7 +553,7 @@ napi_value NAPI_RegisterMissionListener(napi_env env, napi_callback_info info) RegisterMissonCB *registerMissonCB = CreateRegisterMissonCBCBInfo(env); if (registerMissonCB == nullptr) { HILOG_ERROR("%{public}s registerMissonCB == nullptr", __func__); - return nullptr; + NAPI_ASSERT(env, false, "wrong arguments"); } napi_value ret = RegisterMissonWrap(env, info, registerMissonCB); @@ -561,7 +561,7 @@ napi_value NAPI_RegisterMissionListener(napi_env env, napi_callback_info info) HILOG_ERROR("%{public}s ret == nullptr", __func__); delete registerMissonCB; registerMissonCB = nullptr; - NAPI_ASSERT(env, ret == nullptr, "wrong arguments"); + NAPI_ASSERT(env, false, "wrong arguments"); } HILOG_INFO("%{public}s end.", __func__); return ret; @@ -982,7 +982,7 @@ napi_value NAPI_UnRegisterMissionListener(napi_env env, napi_callback_info info) RegisterMissonCB *registerMissonCB = CreateRegisterMissonCBCBInfo(env); if (registerMissonCB == nullptr) { HILOG_ERROR("%{public}s registerMissonCB == nullptr", __func__); - return nullptr; + NAPI_ASSERT(env, false, "wrong arguments"); } napi_value ret = UnRegisterMissonWrap(env, info, registerMissonCB); @@ -990,7 +990,7 @@ napi_value NAPI_UnRegisterMissionListener(napi_env env, napi_callback_info info) HILOG_ERROR("%{public}s ret == nullptr", __func__); delete registerMissonCB; registerMissonCB = nullptr; - NAPI_ASSERT(env, ret == nullptr, "wrong arguments"); + NAPI_ASSERT(env, false, "wrong arguments"); } HILOG_INFO("%{public}s end.", __func__); return ret; @@ -1279,7 +1279,7 @@ napi_value NAPI_ContinueAbility(napi_env env, napi_callback_info info) ContinueAbilityCB *continueAbilityCB = CreateContinueAbilityCBCBInfo(env); if (continueAbilityCB == nullptr) { HILOG_ERROR("%{public}s continueAbilityCB == nullptr", __func__); - return nullptr; + NAPI_ASSERT(env, false, "wrong arguments"); } napi_value ret = ContinueAbilityWrap(env, info, continueAbilityCB); @@ -1287,7 +1287,7 @@ napi_value NAPI_ContinueAbility(napi_env env, napi_callback_info info) HILOG_ERROR("%{public}s ret == nullptr", __func__); delete continueAbilityCB; continueAbilityCB = nullptr; - NAPI_ASSERT(env, ret == nullptr, "wrong arguments"); + NAPI_ASSERT(env, false, "wrong arguments"); } HILOG_INFO("%{public}s end.", __func__); return ret; diff --git a/pa.patch b/pa.patch new file mode 100644 index 0000000000000000000000000000000000000000..fdbc1a091f4f305483bc3899142b000fb4803575 --- /dev/null +++ b/pa.patch @@ -0,0 +1,760 @@ +diff --git a/frameworks/kits/ability/native/include/ability_impl.h b/frameworks/kits/ability/native/include/ability_impl.h +index eceba3e..c124069 100755 +--- a/frameworks/kits/ability/native/include/ability_impl.h ++++ b/frameworks/kits/ability/native/include/ability_impl.h +@@ -46,6 +46,20 @@ public: + std::shared_ptr &ability, std::shared_ptr &handler, const sptr &token, + std::shared_ptr &contextDeal); + ++ /** ++ * @brief Set if use new mission. ++ * ++ * @param useNewMission new mission flag. ++ */ ++ static void SetUseNewMission(bool useNewMission); ++ ++ /** ++ * @brief Get if use new mission. ++ * ++ * @return return true if use new mission. ++ */ ++ static bool IsUseNewMission(); ++ + /** + * @brief Connect the ability. and Calling information back to Ability. + * +diff --git a/frameworks/kits/ability/native/include/page_ability_impl.h b/frameworks/kits/ability/native/include/page_ability_impl.h +index 048fe8c..7782fbe 100644 +--- a/frameworks/kits/ability/native/include/page_ability_impl.h ++++ b/frameworks/kits/ability/native/include/page_ability_impl.h +@@ -58,6 +58,17 @@ public: + */ + bool AbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState); + ++ /** ++ * @brief Handling the life cycle switching of PageAbility in switch. ++ * ++ * @param want Indicates the structure containing information about the ability. ++ * @param targetState The life cycle state to switch to. ++ * ++ * @return return true if the lifecycle transaction successfully, otherwise return false. ++ * ++ */ ++ bool AbilityTransactionNew(const Want &want, const AAFwk::LifeCycleStateInfo &targetState); ++ + /** + * @brief Execution the KeyDown callback of the ability + * @param keyEvent Indicates the key-down event. +diff --git a/frameworks/kits/ability/native/src/ability.cpp b/frameworks/kits/ability/native/src/ability.cpp +index c457361..980f7de 100644 +--- a/frameworks/kits/ability/native/src/ability.cpp ++++ b/frameworks/kits/ability/native/src/ability.cpp +@@ -18,6 +18,7 @@ + #include + #include + ++#include "ability_impl.h" + #include "ability_loader.h" + #include "ability_post_event_timeout.h" + #include "ability_runtime/js_ability.h" +@@ -673,9 +674,15 @@ void Ability::InitWindow(Rosen::WindowType winType) + APP_LOGE("Ability::InitWindow abilityWindow_ is nullptr"); + return; + } +- ++ bool useNewMission = AbilityImpl::IsUseNewMission(); + APP_LOGI("%{public}s beign abilityWindow_->InitWindow.", __func__); +- abilityWindow_->InitWindow(winType, abilityContext_, sceneListener_); ++ if (useNewMission) { ++ abilityWindow_->InitWindow(winType, abilityContext_, sceneListener_); ++ } else { ++ std::shared_ptr context = nullptr; ++ sptr listener = nullptr; ++ abilityWindow_->InitWindow(winType, context, listener); ++ } + APP_LOGI("%{public}s end abilityWindow_->InitWindow.", __func__); + } + +diff --git a/frameworks/kits/ability/native/src/ability_impl.cpp b/frameworks/kits/ability/native/src/ability_impl.cpp +index 31af78f..7c11e44 100755 +--- a/frameworks/kits/ability/native/src/ability_impl.cpp ++++ b/frameworks/kits/ability/native/src/ability_impl.cpp +@@ -23,6 +23,8 @@ + namespace OHOS { + namespace AppExecFwk { + const int TARGET_VERSION_THRESHOLDS = 8; ++static bool g_useNewMission = false; ++static bool g_isMissionFlagSetted = false; + + void AbilityImpl::Init(std::shared_ptr &application, const std::shared_ptr &record, + std::shared_ptr &ability, std::shared_ptr &handler, const sptr &token, +@@ -906,5 +908,18 @@ void AbilityImpl::NotifyContinuationResult(const int32_t result) + } + ability_->OnCompleteContinuation(result); + } ++ ++void AbilityImpl::SetUseNewMission(bool useNewMission) ++{ ++ if (!g_isMissionFlagSetted) { ++ g_isMissionFlagSetted = true; ++ g_useNewMission = useNewMission; ++ } ++} ++ ++bool AbilityImpl::IsUseNewMission() ++{ ++ return g_useNewMission; ++} + } // namespace AppExecFwk + } // namespace OHOS +diff --git a/frameworks/kits/ability/native/src/page_ability_impl.cpp b/frameworks/kits/ability/native/src/page_ability_impl.cpp +index 6f188d8..5828ad8 100644 +--- a/frameworks/kits/ability/native/src/page_ability_impl.cpp ++++ b/frameworks/kits/ability/native/src/page_ability_impl.cpp +@@ -28,6 +28,7 @@ using AbilityManagerClient = OHOS::AAFwk::AbilityManagerClient; + */ + void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) + { ++ AbilityImpl::SetUseNewMission(targetState.useNewMission); + APP_LOGI("PageAbilityImpl::HandleAbilityTransaction begin sourceState:%{public}d; targetState: %{public}d; " + "isNewWant: %{public}d", + lifecycleState_, +@@ -50,12 +51,17 @@ void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::Li + Inactive(); + } + +- if (targetState.state == AAFwk::ABILITY_STATE_BACKGROUND_NEW) { ++ if (targetState.state == AAFwk::ABILITY_STATE_BACKGROUND_NEW || ++ targetState.state == AAFwk::ABILITY_STATE_BACKGROUND) { + CheckAndSave(); + } + + bool ret = false; +- ret = AbilityTransaction(want, targetState); ++ if (AbilityImpl::IsUseNewMission()) { ++ ret = AbilityTransactionNew(want, targetState); ++ } else { ++ ret = AbilityTransaction(want, targetState); ++ } + if (ret) { + APP_LOGI("AbilityThread::HandleAbilityTransaction before AbilityManagerClient->AbilityTransitionDone"); + AbilityManagerClient::GetInstance()->AbilityTransitionDone(token_, targetState.state, GetRestoreData()); +@@ -74,6 +80,61 @@ void PageAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::Li + * + */ + bool PageAbilityImpl::AbilityTransaction(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) ++{ ++ APP_LOGI("PageAbilityImpl::AbilityTransaction begin"); ++ bool ret = true; ++ switch (targetState.state) { ++ case AAFwk::ABILITY_STATE_INITIAL: { ++ if (lifecycleState_ == AAFwk::ABILITY_STATE_INACTIVE) { ++ Background(); ++ } ++ Stop(); ++ break; ++ } ++ case AAFwk::ABILITY_STATE_INACTIVE: { ++ if (lifecycleState_ == AAFwk::ABILITY_STATE_BACKGROUND) { ++ Foreground(want); ++ } ++ break; ++ } ++ case AAFwk::ABILITY_STATE_ACTIVE: { ++ if (lifecycleState_ == AAFwk::ABILITY_STATE_BACKGROUND) { ++ Foreground(want); ++ } ++ if (targetState.isNewWant) { ++ NewWant(want); ++ } ++ SerUriString(targetState.caller.deviceId + "/" + targetState.caller.bundleName + "/" + ++ targetState.caller.abilityName); ++ Active(); ++ break; ++ } ++ case AAFwk::ABILITY_STATE_BACKGROUND: { ++ if (lifecycleState_ == AAFwk::ABILITY_STATE_INACTIVE) { ++ Background(); ++ } ++ break; ++ } ++ default: { ++ ret = false; ++ APP_LOGE("PageAbilityImpl::HandleAbilityTransaction state error"); ++ break; ++ } ++ } ++ APP_LOGI("PageAbilityImpl::AbilityTransaction end: retVal = %{public}d", (int)ret); ++ return ret; ++} ++ ++/** ++ * @brief Handling the life cycle switching of PageAbility in switch. ++ * ++ * @param want Indicates the structure containing information about the ability. ++ * @param targetState The life cycle state to switch to. ++ * ++ * @return return true if the lifecycle transaction successfully, otherwise return false. ++ * ++ */ ++bool PageAbilityImpl::AbilityTransactionNew(const Want &want, const AAFwk::LifeCycleStateInfo &targetState) + { + APP_LOGI("PageAbilityImpl::AbilityTransaction begin"); + bool ret = true; +diff --git a/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h b/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h +index 26c8355..df11ed7 100644 +--- a/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h ++++ b/interfaces/innerkits/ability_manager/include/lifecycle_state_info.h +@@ -53,6 +53,7 @@ struct LifeCycleStateInfo : public Parcelable { + CallerInfo caller; + std::shared_ptr setting = nullptr; + LaunchParam launchParam; ++ bool useNewMission = false; + + bool ReadFromParcel(Parcel &parcel); + virtual bool Marshalling(Parcel &parcel) const override; +diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h +index f389e93..04fd7a1 100755 +--- a/services/abilitymgr/include/ability_manager_service.h ++++ b/services/abilitymgr/include/ability_manager_service.h +@@ -886,6 +886,7 @@ private: + const static std::map dumpMap; + + // new ams here ++ bool useNewMission_ {false}; + std::unordered_map> missionListManagers_; + std::shared_ptr currentMissionListManager_; + std::shared_ptr kernalAbilityManager_; +diff --git a/services/abilitymgr/include/ability_record.h b/services/abilitymgr/include/ability_record.h +index ad725c7..985923f 100644 +--- a/services/abilitymgr/include/ability_record.h ++++ b/services/abilitymgr/include/ability_record.h +@@ -724,6 +724,7 @@ public: + void NotifyContinuationResult(const int32_t result); + std::shared_ptr GetOwnedMissionList() const; + ++ void SetUseNewMission(); + void SetMission(const std::shared_ptr &mission); + void SetMissionList(const std::shared_ptr &missionList); + std::shared_ptr GetMission() const; +diff --git a/services/abilitymgr/include/ams_configuration_parameter.h b/services/abilitymgr/include/ams_configuration_parameter.h +index b159298..c04fee9 100644 +--- a/services/abilitymgr/include/ams_configuration_parameter.h ++++ b/services/abilitymgr/include/ams_configuration_parameter.h +@@ -37,6 +37,7 @@ const std::string SYSTEM_CONFIGURATION {"system_configuration"}; + const std::string SYSTEM_ORIENTATION {"system_orientation"}; + const std::string STARTUP_CONTACTS {"startup_contacts"}; + const std::string STARTUP_MMS {"startup_mms"}; ++const std::string USE_NEW_MISSION {"use_new_mission"}; + } // namespace AmsConfig + + enum class SatrtUiMode { STATUSBAR = 1, NAVIGATIONBAR = 2, STARTUIBOTH = 3 }; +@@ -101,6 +102,12 @@ public: + * Get current system direction parameters, Temporary method. + */ + std::string GetOrientation() const; ++ /** ++ * check if use new mission. ++ * ++ * return true if use mission list, false if use mission stack. ++ */ ++ bool IsUseNewMission() const; + + enum { READ_OK = 0, READ_FAIL = 1, READ_JSON_FAIL = 2 }; + +@@ -123,6 +130,7 @@ private: + bool canStartPhoneService_ {false}; + bool canStartContacts {false}; + bool canStartMms {false}; ++ bool useNewMission_ {false}; + std::string orientation_ {""}; + int missionSaveTime_ {12 * 60 * 60 * 1000}; + std::map memThreshold_; +diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp +index e846ed0..0f2ad5f 100644 +--- a/services/abilitymgr/src/ability_manager_service.cpp ++++ b/services/abilitymgr/src/ability_manager_service.cpp +@@ -146,6 +146,7 @@ bool AbilityManagerService::Init() + amsConfigResolver_->Parse(); + HILOG_INFO("ams config parse"); + } ++ useNewMission_ = amsConfigResolver_->IsUseNewMission(); + + auto pendingWantManager = std::make_shared(); + if (!pendingWantManager) { +@@ -268,11 +269,18 @@ int AbilityManagerService::StartAbility( + return connectManager_->StartAbility(abilityRequest); + } + +- if (IsSystemUiApp(abilityRequest.abilityInfo)) { +- return kernalAbilityManager_->StartAbility(abilityRequest); +- } ++ if (useNewMission_) { ++ if (IsSystemUiApp(abilityRequest.abilityInfo)) { ++ return kernalAbilityManager_->StartAbility(abilityRequest); ++ } ++ return currentMissionListManager_->StartAbility(abilityRequest); ++ } else { ++ if (IsSystemUiApp(abilityRequest.abilityInfo)) { ++ return systemAppManager_->StartAbility(abilityRequest); ++ } + +- return currentMissionListManager_->StartAbility(abilityRequest); ++ return currentStackManager_->StartAbility(abilityRequest); ++ } + } + + int AbilityManagerService::StartAbility(const Want &want, const AbilityStartSetting &abilityStartSetting, +@@ -318,11 +326,19 @@ int AbilityManagerService::StartAbility(const Want &want, const AbilityStartSett + HILOG_ERROR("Only support for page type ability."); + return ERR_INVALID_VALUE; + } +- if (IsSystemUiApp(abilityRequest.abilityInfo)) { +- return kernalAbilityManager_->StartAbility(abilityRequest); +- } ++ if (useNewMission_) { ++ if (IsSystemUiApp(abilityRequest.abilityInfo)) { ++ return kernalAbilityManager_->StartAbility(abilityRequest); ++ } ++ ++ return currentMissionListManager_->StartAbility(abilityRequest); ++ } else { ++ if (IsSystemUiApp(abilityRequest.abilityInfo)) { ++ return systemAppManager_->StartAbility(abilityRequest); ++ } + +- return currentMissionListManager_->StartAbility(abilityRequest); ++ return currentStackManager_->StartAbility(abilityRequest); ++ } + } + + int AbilityManagerService::StartAbility(const Want &want, const StartOptions &startOptions, +@@ -364,10 +380,20 @@ int AbilityManagerService::StartAbility(const Want &want, const StartOptions &st + } + + if (IsSystemUiApp(abilityRequest.abilityInfo)) { +- return kernalAbilityManager_->StartAbility(abilityRequest); ++ if (useNewMission_) { ++ return kernalAbilityManager_->StartAbility(abilityRequest); ++ } else { ++ return systemAppManager_->StartAbility(abilityRequest); ++ } + } ++ + abilityRequest.want.SetParam(StartOptions::STRING_WINDOW_MODE, startOptions.GetWindowMode()); +- return currentMissionListManager_->StartAbility(abilityRequest); ++ ++ if (useNewMission_) { ++ return currentMissionListManager_->StartAbility(abilityRequest); ++ } else { ++ return currentStackManager_->StartAbility(abilityRequest); ++ } + } + + int AbilityManagerService::TerminateAbility(const sptr &token, int resultCode, const Want *resultWant) +@@ -410,7 +436,11 @@ int AbilityManagerService::TerminateAbility(const sptr &token, in + RequestPermission(resultWant); + } + +- return currentMissionListManager_->TerminateAbility(abilityRecord, resultCode, resultWant); ++ if (useNewMission_) { ++ return currentMissionListManager_->TerminateAbility(abilityRecord, resultCode, resultWant); ++ } else { ++ return currentStackManager_->TerminateAbility(token, resultCode, resultWant); ++ } + } + + int AbilityManagerService::StartRemoteAbility(const Want &want, int requestCode) +@@ -581,7 +611,11 @@ int AbilityManagerService::MinimizeAbility(const sptr &token) + return ERR_INVALID_VALUE; + } + +- return currentMissionListManager_->MinimizeAbility(token); ++ if (useNewMission_) { ++ return currentMissionListManager_->MinimizeAbility(token); ++ } else { ++ return currentStackManager_->MinimizeAbility(token); ++ } + } + + int AbilityManagerService::GetRecentMissions( +@@ -1435,9 +1469,17 @@ int AbilityManagerService::AttachAbilityThread( + } else if (type == AppExecFwk::AbilityType::DATA) { + returnCode = dataAbilityManager_->AttachAbilityThread(scheduler, token); + } else if (IsSystemUiApp(abilityInfo)) { +- returnCode = kernalAbilityManager_->AttachAbilityThread(scheduler, token); ++ if (useNewMission_) { ++ returnCode = kernalAbilityManager_->AttachAbilityThread(scheduler, token); ++ } else { ++ returnCode = systemAppManager_->AttachAbilityThread(scheduler, token); ++ } + } else { +- returnCode = currentMissionListManager_->AttachAbilityThread(scheduler, token); ++ if (useNewMission_) { ++ returnCode = currentMissionListManager_->AttachAbilityThread(scheduler, token); ++ } else { ++ returnCode = currentStackManager_->AttachAbilityThread(scheduler, token); ++ } + } + + HILOG_INFO("attach ability type [%{public}d] | returnCode [%{public}d]", type, returnCode); +@@ -1467,8 +1509,14 @@ void AbilityManagerService::DumpFuncInit() + + void AbilityManagerService::DumpInner(const std::string &args, std::vector &info) + { +- if (currentMissionListManager_) { +- currentMissionListManager_->Dump(info); ++ if (useNewMission_) { ++ if (currentMissionListManager_) { ++ currentMissionListManager_->Dump(info); ++ } ++ } else { ++ if (currentStackManager_) { ++ currentStackManager_->Dump(info); ++ } + } + } + +@@ -1530,7 +1578,11 @@ void AbilityManagerService::DumpMissionInner(const std::string &args, std::vecto + } + int missionId = DEFAULT_INVAL_VALUE; + (void)StrToInt(argList[1], missionId); +- currentMissionListManager_->DumpMission(missionId, info); ++ if (useNewMission_) { ++ currentMissionListManager_->DumpMission(missionId, info); ++ } else { ++ currentStackManager_->DumpMission(missionId, info); ++ } + } + + void AbilityManagerService::DumpTopAbilityInner(const std::string &args, std::vector &info) +@@ -1647,11 +1699,19 @@ int AbilityManagerService::AbilityTransitionDone(const sptr &toke + if (type == AppExecFwk::AbilityType::DATA) { + return dataAbilityManager_->AbilityTransitionDone(token, state); + } +- if (IsSystemUiApp(abilityInfo)) { +- return kernalAbilityManager_->AbilityTransitionDone(token, state); +- } ++ if (useNewMission_) { ++ if (IsSystemUiApp(abilityInfo)) { ++ return kernalAbilityManager_->AbilityTransitionDone(token, state); ++ } ++ ++ return currentMissionListManager_->AbilityTransactionDone(token, state, saveData); ++ } else { ++ if (IsSystemUiApp(abilityInfo)) { ++ return systemAppManager_->AbilityTransitionDone(token, state); ++ } + +- return currentMissionListManager_->AbilityTransactionDone(token, state, saveData); ++ return currentStackManager_->AbilityTransitionDone(token, state, saveData); ++ } + } + + int AbilityManagerService::ScheduleConnectAbilityDone( +@@ -1745,11 +1805,19 @@ void AbilityManagerService::OnAbilityRequestDone(const sptr &toke + dataAbilityManager_->OnAbilityRequestDone(token, state); + break; + default: { +- if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { +- kernalAbilityManager_->OnAbilityRequestDone(token, state); +- break; ++ if (useNewMission_) { ++ if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { ++ kernalAbilityManager_->OnAbilityRequestDone(token, state); ++ break; ++ } ++ currentMissionListManager_->OnAbilityRequestDone(token, state); ++ } else { ++ if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { ++ systemAppManager_->OnAbilityRequestDone(token, state); ++ break; ++ } ++ currentStackManager_->OnAbilityRequestDone(token, state); + } +- currentMissionListManager_->OnAbilityRequestDone(token, state); + break; + } + } +@@ -1760,7 +1828,11 @@ void AbilityManagerService::OnAppStateChanged(const AppInfo &info) + HILOG_INFO("On app state changed."); + currentStackManager_->OnAppStateChanged(info); + connectManager_->OnAppStateChanged(info); +- kernalAbilityManager_->OnAppStateChanged(info); ++ if (useNewMission_) { ++ kernalAbilityManager_->OnAppStateChanged(info); ++ } else { ++ systemAppManager_->OnAppStateChanged(info); ++ } + dataAbilityManager_->OnAppStateChanged(info); + } + +@@ -2010,13 +2082,24 @@ void AbilityManagerService::OnAbilityDied(std::shared_ptr ability + { + CHECK_POINTER(abilityRecord); + +- if (kernalAbilityManager_ && abilityRecord->IsKernalSystemAbility()) { +- kernalAbilityManager_->OnAbilityDied(abilityRecord); +- return; +- } ++ if (useNewMission_) { ++ if (kernalAbilityManager_ && abilityRecord->IsKernalSystemAbility()) { ++ kernalAbilityManager_->OnAbilityDied(abilityRecord); ++ return; ++ } + +- if (currentMissionListManager_) { +- currentMissionListManager_->OnAbilityDied(abilityRecord); ++ if (currentMissionListManager_) { ++ currentMissionListManager_->OnAbilityDied(abilityRecord); ++ } ++ } else { ++ if (systemAppManager_ && abilityRecord->IsKernalSystemAbility()) { ++ systemAppManager_->OnAbilityDied(abilityRecord); ++ return; ++ } ++ ++ if (currentStackManager_) { ++ currentStackManager_->OnAbilityDied(abilityRecord); ++ } + } + + if (connectManager_) { +@@ -2158,9 +2241,15 @@ bool AbilityManagerService::IsSystemUiApp(const AppExecFwk::AbilityInfo &info) c + void AbilityManagerService::HandleLoadTimeOut(int64_t eventId) + { + HILOG_DEBUG("Handle load timeout."); +- if (kernalAbilityManager_) { +- kernalAbilityManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); +- } ++ if (useNewMission_) { ++ if (kernalAbilityManager_) { ++ kernalAbilityManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); ++ } ++ } else { ++ if (systemAppManager_) { ++ systemAppManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); ++ } ++ } + if (currentStackManager_) { + currentStackManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); + } +@@ -2170,8 +2259,14 @@ void AbilityManagerService::HandleActiveTimeOut(int64_t eventId) + { + HILOG_DEBUG("Handle active timeout."); + +- if (kernalAbilityManager_) { +- kernalAbilityManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); ++ if (useNewMission_) { ++ if (kernalAbilityManager_) { ++ kernalAbilityManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); ++ } ++ } else { ++ if (systemAppManager_) { ++ systemAppManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); ++ } + } + if (currentStackManager_) { + currentStackManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); +@@ -2189,8 +2284,14 @@ void AbilityManagerService::HandleInactiveTimeOut(int64_t eventId) + void AbilityManagerService::HandleForegroundNewTimeOut(int64_t eventId) + { + HILOG_DEBUG("Handle ForegroundNew timeout."); +- if (kernalAbilityManager_) { +- kernalAbilityManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); ++ if (useNewMission_) { ++ if (kernalAbilityManager_) { ++ kernalAbilityManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); ++ } ++ } else { ++ if (systemAppManager_) { ++ systemAppManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); ++ } + } + if (currentStackManager_) { + currentStackManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); +@@ -2200,8 +2301,14 @@ void AbilityManagerService::HandleForegroundNewTimeOut(int64_t eventId) + void AbilityManagerService::HandleBackgroundNewTimeOut(int64_t eventId) + { + HILOG_DEBUG("Handle BackgroundNew timeout."); +- if (kernalAbilityManager_) { +- kernalAbilityManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); ++ if (useNewMission_) { ++ if (kernalAbilityManager_) { ++ kernalAbilityManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); ++ } ++ } else { ++ if (systemAppManager_) { ++ systemAppManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); ++ } + } + if (currentStackManager_) { + currentStackManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); +@@ -2213,16 +2320,26 @@ bool AbilityManagerService::VerificationToken(const sptr &token) + HILOG_INFO("Verification token."); + CHECK_POINTER_RETURN_BOOL(dataAbilityManager_); + CHECK_POINTER_RETURN_BOOL(connectManager_); +- ++ CHECK_POINTER_RETURN_BOOL(currentStackManager_); ++ CHECK_POINTER_RETURN_BOOL(systemAppManager_); + CHECK_POINTER_RETURN_BOOL(currentMissionListManager_); + CHECK_POINTER_RETURN_BOOL(kernalAbilityManager_); + +- if (currentMissionListManager_->GetAbilityRecordByToken(token)) { +- return true; +- } ++ if (useNewMission_) { ++ if (currentMissionListManager_->GetAbilityRecordByToken(token)) { ++ return true; ++ } ++ if (currentMissionListManager_->GetAbilityFromTerminateList(token)) { ++ return true; ++ } ++ } else { ++ if (currentStackManager_->GetAbilityRecordByToken(token)) { ++ return true; ++ } + +- if (currentMissionListManager_->GetAbilityFromTerminateList(token)) { +- return true; ++ if (currentStackManager_->GetAbilityFromTerminateList(token)) { ++ return true; ++ } + } + + if (dataAbilityManager_->GetAbilityRecordByToken(token)) { +@@ -2233,8 +2350,14 @@ bool AbilityManagerService::VerificationToken(const sptr &token) + return true; + } + +- if (kernalAbilityManager_->GetAbilityRecordByToken(token)) { +- return true; ++ if (useNewMission_) { ++ if (kernalAbilityManager_->GetAbilityRecordByToken(token)) { ++ return true; ++ } ++ } else { ++ if (systemAppManager_->GetAbilityRecordByToken(token)) { ++ return true; ++ } + } + + HILOG_ERROR("Failed to verify token."); +@@ -2374,6 +2497,7 @@ void AbilityManagerService::RestartAbility(const sptr &token) + HILOG_INFO("%{public}s called", __func__); + CHECK_POINTER(currentStackManager_); + CHECK_POINTER(kernalAbilityManager_); ++ CHECK_POINTER(systemAppManager_); + if (!VerificationToken(token)) { + return; + } +@@ -2382,7 +2506,11 @@ void AbilityManagerService::RestartAbility(const sptr &token) + CHECK_POINTER(abilityRecord); + + if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { +- kernalAbilityManager_->RestartAbility(abilityRecord); ++ if (useNewMission_) { ++ kernalAbilityManager_->RestartAbility(abilityRecord); ++ } else { ++ systemAppManager_->RestartAbility(abilityRecord); ++ } + return; + } + +diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp +index d07294c..da5cf66 100644 +--- a/services/abilitymgr/src/ability_record.cpp ++++ b/services/abilitymgr/src/ability_record.cpp +@@ -1225,6 +1225,11 @@ void AbilityRecord::SetMissionList(const std::shared_ptr &missionLi + missionList_ = missionList; + } + ++void AbilityRecord::SetUseNewMission() ++{ ++ lifeCycleStateInfo_.useNewMission = true; ++} ++ + void AbilityRecord::SetMission(const std::shared_ptr &mission) + { + if (mission) { +diff --git a/services/abilitymgr/src/ams_configuration_parameter.cpp b/services/abilitymgr/src/ams_configuration_parameter.cpp +index 99ec0ec..0c132a9 100644 +--- a/services/abilitymgr/src/ams_configuration_parameter.cpp ++++ b/services/abilitymgr/src/ams_configuration_parameter.cpp +@@ -77,6 +77,11 @@ std::string AmsConfigurationParameter::GetOrientation() const + return orientation_; + } + ++bool AmsConfigurationParameter::IsUseNewMission() const ++{ ++ return useNewMission_; ++} ++ + int AmsConfigurationParameter::LoadAmsConfiguration(const std::string &filePath) + { + HILOG_DEBUG("%{public}s", __func__); +@@ -137,6 +142,9 @@ int AmsConfigurationParameter::LoadAppConfigurationForStartUpService(nlohmann::j + canStartContacts = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_CONTACTS).get(); + canStartMms = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_MMS).get(); + missionSaveTime_ = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::MISSION_SAVE_TIME).get(); ++ if (Object.at(AmsConfig::SERVICE_ITEM_AMS).contains(AmsConfig::USE_NEW_MISSION)) { ++ useNewMission_ = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::USE_NEW_MISSION).get(); ++ } + HILOG_INFO("get ams service config succes!"); + ret = 0; + } +diff --git a/services/abilitymgr/src/kernal_ability_manager.cpp b/services/abilitymgr/src/kernal_ability_manager.cpp +index d1dd396..6e1059d 100644 +--- a/services/abilitymgr/src/kernal_ability_manager.cpp ++++ b/services/abilitymgr/src/kernal_ability_manager.cpp +@@ -200,6 +200,7 @@ void KernalAbilityManager::GetOrCreateAbilityRecord( + return; + } + targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest); ++ targetAbility->SetUseNewMission(); + abilities_.push_front(targetAbility); + } + +diff --git a/services/abilitymgr/src/lifecycle_state_info.cpp b/services/abilitymgr/src/lifecycle_state_info.cpp +index 1070cb1..62df134 100644 +--- a/services/abilitymgr/src/lifecycle_state_info.cpp ++++ b/services/abilitymgr/src/lifecycle_state_info.cpp +@@ -43,6 +43,7 @@ bool LifeCycleStateInfo::ReadFromParcel(Parcel &parcel) + return false; + } + launchParam = *launchInfo; ++ useNewMission = parcel.ReadBool(); + return true; + } + +@@ -90,6 +91,10 @@ bool LifeCycleStateInfo::Marshalling(Parcel &parcel) const + if (!parcel.WriteParcelable(&launchParam)) { + return false; + } ++ // write useNewMission ++ if (!parcel.WriteBool(useNewMission)) { ++ return false; ++ } + return true; + } + } // namespace AAFwk +diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp +index 266e515..65e8663 100644 +--- a/services/abilitymgr/src/mission_list_manager.cpp ++++ b/services/abilitymgr/src/mission_list_manager.cpp +@@ -290,6 +290,7 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit + } + targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + targetMission = std::make_shared(info.missionInfo.id, targetRecord, missionName); ++ targetRecord->SetUseNewMission(); + targetRecord->SetMission(targetMission); + + if (abilityRequest.abilityInfo.applicationInfo.isLauncherApp) { +@@ -1215,6 +1216,7 @@ std::shared_ptr MissionListManager::GetTargetMissionList(int missio + } + + auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); ++ abilityRecord->SetUseNewMission(); + mission = std::make_shared(innerMissionInfo.missionInfo.id, abilityRecord, innerMissionInfo.missionName); + abilityRecord->SetMission(mission); + std::shared_ptr newMissionList = std::make_shared(); diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index f389e93a0bde2372081dc7729a0254118c4abbcb..04fd7a110a0ec988bafe20e06026953bf42457ab 100755 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -886,6 +886,7 @@ private: const static std::map dumpMap; // new ams here + bool useNewMission_ {false}; std::unordered_map> missionListManagers_; std::shared_ptr currentMissionListManager_; std::shared_ptr kernalAbilityManager_; diff --git a/services/abilitymgr/include/ability_record.h b/services/abilitymgr/include/ability_record.h index ad725c794fbd39539d05d52d7326c1a63fa7b5b9..985923f979409c61f2751fee3826ca19d5d142ac 100644 --- a/services/abilitymgr/include/ability_record.h +++ b/services/abilitymgr/include/ability_record.h @@ -724,6 +724,7 @@ public: void NotifyContinuationResult(const int32_t result); std::shared_ptr GetOwnedMissionList() const; + void SetUseNewMission(); void SetMission(const std::shared_ptr &mission); void SetMissionList(const std::shared_ptr &missionList); std::shared_ptr GetMission() const; diff --git a/services/abilitymgr/include/ams_configuration_parameter.h b/services/abilitymgr/include/ams_configuration_parameter.h index b15929854828dbb6525632cd94b87aa9686f78e9..c04fee90ebbb295db8efda331e9f290f4e435ba2 100644 --- a/services/abilitymgr/include/ams_configuration_parameter.h +++ b/services/abilitymgr/include/ams_configuration_parameter.h @@ -37,6 +37,7 @@ const std::string SYSTEM_CONFIGURATION {"system_configuration"}; const std::string SYSTEM_ORIENTATION {"system_orientation"}; const std::string STARTUP_CONTACTS {"startup_contacts"}; const std::string STARTUP_MMS {"startup_mms"}; +const std::string USE_NEW_MISSION {"use_new_mission"}; } // namespace AmsConfig enum class SatrtUiMode { STATUSBAR = 1, NAVIGATIONBAR = 2, STARTUIBOTH = 3 }; @@ -101,6 +102,12 @@ public: * Get current system direction parameters, Temporary method. */ std::string GetOrientation() const; + /** + * check if use new mission. + * + * return true if use mission list, false if use mission stack. + */ + bool IsUseNewMission() const; enum { READ_OK = 0, READ_FAIL = 1, READ_JSON_FAIL = 2 }; @@ -123,6 +130,7 @@ private: bool canStartPhoneService_ {false}; bool canStartContacts {false}; bool canStartMms {false}; + bool useNewMission_ {false}; std::string orientation_ {""}; int missionSaveTime_ {12 * 60 * 60 * 1000}; std::map memThreshold_; diff --git a/services/abilitymgr/include/mission_list_manager.h b/services/abilitymgr/include/mission_list_manager.h index 51f27f05027b72e14bdf17fad1af70d72df7da46..fe7b0590606ce2f3328f5ca148f4125ab6f4ac79 100644 --- a/services/abilitymgr/include/mission_list_manager.h +++ b/services/abilitymgr/include/mission_list_manager.h @@ -286,6 +286,11 @@ private: std::shared_ptr GetTargetMissionList(int missionId, std::shared_ptr &mission); void UpdateMissionTimeStamp(const std::shared_ptr &abilityRecord); void PostStartWaittingAbility(); + void HandleAbilityDied(std::shared_ptr abilityRecord); + void HandleLauncherDied(std::shared_ptr ability); + void HandleAbilityDiedByDefault(std::shared_ptr abilityRecord); + void DelayedStartLauncher(); + void BackToLauncher(); private: int userId_; diff --git a/services/abilitymgr/src/ability_connect_manager.cpp b/services/abilitymgr/src/ability_connect_manager.cpp index 8ee091e55da0d91b21ebe4d9ce632fb405484b93..29356963aa464e6f8415238346f5f3c81ef18843 100644 --- a/services/abilitymgr/src/ability_connect_manager.cpp +++ b/services/abilitymgr/src/ability_connect_manager.cpp @@ -35,7 +35,7 @@ AbilityConnectManager::~AbilityConnectManager() int AbilityConnectManager::StartAbility(const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); return StartAbilityLocked(abilityRequest); } @@ -95,7 +95,7 @@ int AbilityConnectManager::TerminateAbilityResult(const sptr &tok int AbilityConnectManager::StartAbilityLocked(const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Start ability locked, ability_name: %{public}s", abilityRequest.want.GetElement().GetURI().c_str()); std::shared_ptr targetService; @@ -126,7 +126,7 @@ int AbilityConnectManager::StartAbilityLocked(const AbilityRequest &abilityReque int AbilityConnectManager::TerminateAbilityLocked(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Terminate ability locked."); auto abilityRecord = GetServiceRecordByToken(token); CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); @@ -153,7 +153,7 @@ int AbilityConnectManager::TerminateAbilityLocked(const sptr &tok int AbilityConnectManager::TerminateAbilityResultLocked(const sptr &token, int startId) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Terminate ability result locked, startId: %{public}d", startId); CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE); @@ -170,7 +170,7 @@ int AbilityConnectManager::TerminateAbilityResultLocked(const sptr &targetService, bool &isLoadedAbility) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); AppExecFwk::ElementName element( abilityRequest.abilityInfo.deviceId, abilityRequest.abilityInfo.bundleName, abilityRequest.abilityInfo.name); auto serviceMapIter = serviceMap_.find(element.GetURI()); @@ -233,7 +233,7 @@ void AbilityConnectManager::GetConnectRecordListFromMap( int AbilityConnectManager::ConnectAbilityLocked(const AbilityRequest &abilityRequest, const sptr &connect, const sptr &callerToken) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("%{public}s, ability_name:%{public}s", __func__, abilityRequest.want.GetElement().GetURI().c_str()); std::lock_guard guard(Lock_); @@ -290,7 +290,7 @@ int AbilityConnectManager::ConnectAbilityLocked(const AbilityRequest &abilityReq int AbilityConnectManager::DisconnectAbilityLocked(const sptr &connect) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Disconnect ability locked."); std::lock_guard guard(Lock_); @@ -335,7 +335,7 @@ int AbilityConnectManager::DisconnectAbilityLocked(const sptr &scheduler, const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); auto abilityRecord = GetServiceRecordByToken(token); CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); @@ -355,7 +355,7 @@ int AbilityConnectManager::AttachAbilityThreadLocked( void AbilityConnectManager::OnAbilityRequestDone(const sptr &token, const int32_t state) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); auto abilitState = DelayedSingleton::GetInstance()->ConvertToAppAbilityState(state); auto abilityRecord = GetServiceRecordByToken(token); @@ -385,7 +385,7 @@ void AbilityConnectManager::OnAppStateChanged(const AppInfo &info) int AbilityConnectManager::AbilityTransitionDone(const sptr &token, int state) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); auto abilityRecord = GetServiceRecordByToken(token); CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); @@ -416,7 +416,7 @@ int AbilityConnectManager::AbilityTransitionDone(const sptr &toke int AbilityConnectManager::ScheduleConnectAbilityDoneLocked( const sptr &token, const sptr &remoteObject) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE); @@ -447,7 +447,7 @@ int AbilityConnectManager::ScheduleConnectAbilityDoneLocked( int AbilityConnectManager::ScheduleDisconnectAbilityDoneLocked(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); auto abilityRecord = GetServiceRecordByToken(token); CHECK_POINTER_AND_RETURN(abilityRecord, CONNECTION_NOT_EXIST); @@ -484,7 +484,7 @@ int AbilityConnectManager::ScheduleDisconnectAbilityDoneLocked(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(Lock_); CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE); auto abilityRecord = Token::GetAbilityRecordByToken(token); @@ -561,7 +561,7 @@ void AbilityConnectManager::RemoveAll() void AbilityConnectManager::LoadAbility(const std::shared_ptr &abilityRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); CHECK_POINTER(abilityRecord); PostTimeOutTask(abilityRecord, AbilityManagerService::LOAD_TIMEOUT_MSG); @@ -703,7 +703,7 @@ int AbilityConnectManager::DispatchTerminate(const std::shared_ptr &abilityRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); CHECK_POINTER(abilityRecord); PostTimeOutTask(abilityRecord, AbilityConnectManager::CONNECT_TIMEOUT_MSG); abilityRecord->ConnectAbility(); @@ -711,7 +711,7 @@ void AbilityConnectManager::ConnectAbility(const std::shared_ptr void AbilityConnectManager::CommandAbility(const std::shared_ptr &abilityRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); if (eventHandler_ != nullptr) { // first connect ability, There is at most one connect record. int recordId = abilityRecord->GetRecordId(); @@ -729,7 +729,7 @@ void AbilityConnectManager::CommandAbility(const std::shared_ptr void AbilityConnectManager::TerminateDone(const std::shared_ptr &abilityRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); if (!abilityRecord->IsAbilityState(AbilityState::TERMINATING)) { std::string expect = AbilityRecord::ConvertAbilityState(AbilityState::TERMINATING); std::string actual = AbilityRecord::ConvertAbilityState(abilityRecord->GetAbilityState()); diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index 75fb51b6c44c9d048259491fc303b00064dcce68..3fc23ab7ce50183bde2b7f60c854cd450cdfd77b 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -146,6 +146,7 @@ bool AbilityManagerService::Init() amsConfigResolver_->Parse(); HILOG_INFO("ams config parse"); } + useNewMission_ = amsConfigResolver_->IsUseNewMission(); auto pendingWantManager = std::make_shared(); if (!pendingWantManager) { @@ -212,7 +213,7 @@ int AbilityManagerService::StartAbility(const Want &want, int requestCode) int AbilityManagerService::StartAbility(const Want &want, const sptr &callerToken, int requestCode) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); auto flags = want.GetFlags(); if ((flags & Want::FLAG_ABILITY_CONTINUATION) == Want::FLAG_ABILITY_CONTINUATION) { HILOG_ERROR("StartAbility with continuation flags is not allowed!"); @@ -230,7 +231,7 @@ int AbilityManagerService::StartAbility(const Want &want, const sptr &callerToken, int requestCode, int callerUid) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("%{public}s", __func__); if (callerToken != nullptr && !VerificationToken(callerToken)) { return ERR_INVALID_VALUE; @@ -268,17 +269,24 @@ int AbilityManagerService::StartAbility( return connectManager_->StartAbility(abilityRequest); } - if (IsSystemUiApp(abilityRequest.abilityInfo)) { - return kernalAbilityManager_->StartAbility(abilityRequest); - } + if (useNewMission_) { + if (IsSystemUiApp(abilityRequest.abilityInfo)) { + return kernalAbilityManager_->StartAbility(abilityRequest); + } + return currentMissionListManager_->StartAbility(abilityRequest); + } else { + if (IsSystemUiApp(abilityRequest.abilityInfo)) { + return systemAppManager_->StartAbility(abilityRequest); + } - return currentMissionListManager_->StartAbility(abilityRequest); + return currentStackManager_->StartAbility(abilityRequest); + } } int AbilityManagerService::StartAbility(const Want &want, const AbilityStartSetting &abilityStartSetting, const sptr &callerToken, int requestCode) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Start ability setting."); if (callerToken != nullptr && !VerificationToken(callerToken)) { return ERR_INVALID_VALUE; @@ -318,17 +326,25 @@ int AbilityManagerService::StartAbility(const Want &want, const AbilityStartSett HILOG_ERROR("Only support for page type ability."); return ERR_INVALID_VALUE; } - if (IsSystemUiApp(abilityRequest.abilityInfo)) { - return kernalAbilityManager_->StartAbility(abilityRequest); - } + if (useNewMission_) { + if (IsSystemUiApp(abilityRequest.abilityInfo)) { + return kernalAbilityManager_->StartAbility(abilityRequest); + } + + return currentMissionListManager_->StartAbility(abilityRequest); + } else { + if (IsSystemUiApp(abilityRequest.abilityInfo)) { + return systemAppManager_->StartAbility(abilityRequest); + } - return currentMissionListManager_->StartAbility(abilityRequest); + return currentStackManager_->StartAbility(abilityRequest); + } } int AbilityManagerService::StartAbility(const Want &want, const StartOptions &startOptions, const sptr &callerToken, int requestCode) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Start ability options."); if (callerToken != nullptr && !VerificationToken(callerToken)) { return ERR_INVALID_VALUE; @@ -364,15 +380,25 @@ int AbilityManagerService::StartAbility(const Want &want, const StartOptions &st } if (IsSystemUiApp(abilityRequest.abilityInfo)) { - return kernalAbilityManager_->StartAbility(abilityRequest); + if (useNewMission_) { + return kernalAbilityManager_->StartAbility(abilityRequest); + } else { + return systemAppManager_->StartAbility(abilityRequest); + } } + abilityRequest.want.SetParam(StartOptions::STRING_WINDOW_MODE, startOptions.GetWindowMode()); - return currentMissionListManager_->StartAbility(abilityRequest); + + if (useNewMission_) { + return currentMissionListManager_->StartAbility(abilityRequest); + } else { + return currentStackManager_->StartAbility(abilityRequest); + } } int AbilityManagerService::TerminateAbility(const sptr &token, int resultCode, const Want *resultWant) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Terminate ability for result: %{public}d", (resultWant != nullptr)); if (!VerificationToken(token)) { return ERR_INVALID_VALUE; @@ -410,7 +436,11 @@ int AbilityManagerService::TerminateAbility(const sptr &token, in RequestPermission(resultWant); } - return currentMissionListManager_->TerminateAbility(abilityRecord, resultCode, resultWant); + if (useNewMission_) { + return currentMissionListManager_->TerminateAbility(abilityRecord, resultCode, resultWant); + } else { + return currentStackManager_->TerminateAbility(token, resultCode, resultWant); + } } int AbilityManagerService::StartRemoteAbility(const Want &want, int requestCode) @@ -581,7 +611,11 @@ int AbilityManagerService::MinimizeAbility(const sptr &token) return ERR_INVALID_VALUE; } - return currentMissionListManager_->MinimizeAbility(token); + if (useNewMission_) { + return currentMissionListManager_->MinimizeAbility(token); + } else { + return currentStackManager_->MinimizeAbility(token); + } } int AbilityManagerService::GetRecentMissions( @@ -739,7 +773,7 @@ int AbilityManagerService::RemoveStack(int id) int AbilityManagerService::ConnectAbility( const Want &want, const sptr &connect, const sptr &callerToken) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Connect ability."); CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE); CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE); @@ -753,7 +787,7 @@ int AbilityManagerService::ConnectAbility( int AbilityManagerService::DisconnectAbility(const sptr &connect) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Disconnect ability."); CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE); CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE); @@ -766,7 +800,7 @@ int AbilityManagerService::DisconnectAbility(const sptr &con int AbilityManagerService::ConnectLocalAbility( const Want &want, const sptr &connect, const sptr &callerToken) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("%{public}s begin ConnectAbilityLocal", __func__); AbilityRequest abilityRequest; ErrCode result = GenerateAbilityRequest(want, DEFAULT_INVAL_VALUE, abilityRequest, callerToken); @@ -1415,7 +1449,7 @@ int AbilityManagerService::ReleaseDataAbility( int AbilityManagerService::AttachAbilityThread( const sptr &scheduler, const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Attach ability thread."); CHECK_POINTER_AND_RETURN(scheduler, ERR_INVALID_VALUE); @@ -1435,9 +1469,17 @@ int AbilityManagerService::AttachAbilityThread( } else if (type == AppExecFwk::AbilityType::DATA) { returnCode = dataAbilityManager_->AttachAbilityThread(scheduler, token); } else if (IsSystemUiApp(abilityInfo)) { - returnCode = kernalAbilityManager_->AttachAbilityThread(scheduler, token); + if (useNewMission_) { + returnCode = kernalAbilityManager_->AttachAbilityThread(scheduler, token); + } else { + returnCode = systemAppManager_->AttachAbilityThread(scheduler, token); + } } else { - returnCode = currentMissionListManager_->AttachAbilityThread(scheduler, token); + if (useNewMission_) { + returnCode = currentMissionListManager_->AttachAbilityThread(scheduler, token); + } else { + returnCode = currentStackManager_->AttachAbilityThread(scheduler, token); + } } HILOG_INFO("attach ability type [%{public}d] | returnCode [%{public}d]", type, returnCode); @@ -1467,8 +1509,14 @@ void AbilityManagerService::DumpFuncInit() void AbilityManagerService::DumpInner(const std::string &args, std::vector &info) { - if (currentMissionListManager_) { - currentMissionListManager_->Dump(info); + if (useNewMission_) { + if (currentMissionListManager_) { + currentMissionListManager_->Dump(info); + } + } else { + if (currentStackManager_) { + currentStackManager_->Dump(info); + } } } @@ -1530,7 +1578,11 @@ void AbilityManagerService::DumpMissionInner(const std::string &args, std::vecto } int missionId = DEFAULT_INVAL_VALUE; (void)StrToInt(argList[1], missionId); - currentMissionListManager_->DumpMission(missionId, info); + if (useNewMission_) { + currentMissionListManager_->DumpMission(missionId, info); + } else { + currentStackManager_->DumpMission(missionId, info); + } } void AbilityManagerService::DumpTopAbilityInner(const std::string &args, std::vector &info) @@ -1621,7 +1673,7 @@ void AbilityManagerService::DumpState(const std::string &args, std::vector &token, int state, const PacMap &saveData) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Ability transition done, state:%{public}d", state); if (!VerificationToken(token)) { return ERR_INVALID_VALUE; @@ -1647,17 +1699,25 @@ int AbilityManagerService::AbilityTransitionDone(const sptr &toke if (type == AppExecFwk::AbilityType::DATA) { return dataAbilityManager_->AbilityTransitionDone(token, state); } - if (IsSystemUiApp(abilityInfo)) { - return kernalAbilityManager_->AbilityTransitionDone(token, state); - } + if (useNewMission_) { + if (IsSystemUiApp(abilityInfo)) { + return kernalAbilityManager_->AbilityTransitionDone(token, state); + } + + return currentMissionListManager_->AbilityTransactionDone(token, state, saveData); + } else { + if (IsSystemUiApp(abilityInfo)) { + return systemAppManager_->AbilityTransitionDone(token, state); + } - return currentMissionListManager_->AbilityTransactionDone(token, state, saveData); + return currentStackManager_->AbilityTransitionDone(token, state, saveData); + } } int AbilityManagerService::ScheduleConnectAbilityDone( const sptr &token, const sptr &remoteObject) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Schedule connect ability done."); if (!VerificationToken(token)) { return ERR_INVALID_VALUE; @@ -1677,7 +1737,7 @@ int AbilityManagerService::ScheduleConnectAbilityDone( int AbilityManagerService::ScheduleDisconnectAbilityDone(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Schedule disconnect ability done."); if (!VerificationToken(token)) { return ERR_INVALID_VALUE; @@ -1697,7 +1757,7 @@ int AbilityManagerService::ScheduleDisconnectAbilityDone(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Schedule command ability done."); if (!VerificationToken(token)) { return ERR_INVALID_VALUE; @@ -1726,7 +1786,7 @@ void AbilityManagerService::AddWindowInfo(const sptr &token, int3 void AbilityManagerService::OnAbilityRequestDone(const sptr &token, const int32_t state) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("On ability request done."); if (!VerificationToken(token)) { return; @@ -1745,11 +1805,19 @@ void AbilityManagerService::OnAbilityRequestDone(const sptr &toke dataAbilityManager_->OnAbilityRequestDone(token, state); break; default: { - if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { - kernalAbilityManager_->OnAbilityRequestDone(token, state); - break; + if (useNewMission_) { + if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { + kernalAbilityManager_->OnAbilityRequestDone(token, state); + break; + } + currentMissionListManager_->OnAbilityRequestDone(token, state); + } else { + if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { + systemAppManager_->OnAbilityRequestDone(token, state); + break; + } + currentStackManager_->OnAbilityRequestDone(token, state); } - currentMissionListManager_->OnAbilityRequestDone(token, state); break; } } @@ -1760,7 +1828,11 @@ void AbilityManagerService::OnAppStateChanged(const AppInfo &info) HILOG_INFO("On app state changed."); currentStackManager_->OnAppStateChanged(info); connectManager_->OnAppStateChanged(info); - kernalAbilityManager_->OnAppStateChanged(info); + if (useNewMission_) { + kernalAbilityManager_->OnAppStateChanged(info); + } else { + systemAppManager_->OnAppStateChanged(info); + } dataAbilityManager_->OnAppStateChanged(info); } @@ -1908,7 +1980,7 @@ void AbilityManagerService::StartSystemUi(const std::string abilityName) int AbilityManagerService::GenerateAbilityRequest( const Want &want, int requestCode, AbilityRequest &request, const sptr &callerToken) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); request.want = want; request.requestCode = requestCode; request.callerToken = callerToken; @@ -1989,7 +2061,7 @@ int AbilityManagerService::TerminateAbilityResult(const sptr &tok int AbilityManagerService::StopServiceAbility(const Want &want) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Stop service ability."); AbilityRequest abilityRequest; int result = GenerateAbilityRequest(want, DEFAULT_INVAL_VALUE, abilityRequest, nullptr); @@ -2010,13 +2082,24 @@ void AbilityManagerService::OnAbilityDied(std::shared_ptr ability { CHECK_POINTER(abilityRecord); - if (kernalAbilityManager_ && abilityRecord->IsKernalSystemAbility()) { - kernalAbilityManager_->OnAbilityDied(abilityRecord); - return; - } + if (useNewMission_) { + if (kernalAbilityManager_ && abilityRecord->IsKernalSystemAbility()) { + kernalAbilityManager_->OnAbilityDied(abilityRecord); + return; + } - if (currentStackManager_) { - currentStackManager_->OnAbilityDied(abilityRecord); + if (currentMissionListManager_) { + currentMissionListManager_->OnAbilityDied(abilityRecord); + } + } else { + if (systemAppManager_ && abilityRecord->IsKernalSystemAbility()) { + systemAppManager_->OnAbilityDied(abilityRecord); + return; + } + + if (currentStackManager_) { + currentStackManager_->OnAbilityDied(abilityRecord); + } } if (connectManager_) { @@ -2158,9 +2241,15 @@ bool AbilityManagerService::IsSystemUiApp(const AppExecFwk::AbilityInfo &info) c void AbilityManagerService::HandleLoadTimeOut(int64_t eventId) { HILOG_DEBUG("Handle load timeout."); - if (kernalAbilityManager_) { - kernalAbilityManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); - } + if (useNewMission_) { + if (kernalAbilityManager_) { + kernalAbilityManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); + } + } else { + if (systemAppManager_) { + systemAppManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); + } + } if (currentStackManager_) { currentStackManager_->OnTimeOut(AbilityManagerService::LOAD_TIMEOUT_MSG, eventId); } @@ -2170,8 +2259,14 @@ void AbilityManagerService::HandleActiveTimeOut(int64_t eventId) { HILOG_DEBUG("Handle active timeout."); - if (kernalAbilityManager_) { - kernalAbilityManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); + if (useNewMission_) { + if (kernalAbilityManager_) { + kernalAbilityManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); + } + } else { + if (systemAppManager_) { + systemAppManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); + } } if (currentStackManager_) { currentStackManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, eventId); @@ -2189,8 +2284,14 @@ void AbilityManagerService::HandleInactiveTimeOut(int64_t eventId) void AbilityManagerService::HandleForegroundNewTimeOut(int64_t eventId) { HILOG_DEBUG("Handle ForegroundNew timeout."); - if (kernalAbilityManager_) { - kernalAbilityManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); + if (useNewMission_) { + if (kernalAbilityManager_) { + kernalAbilityManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); + } + } else { + if (systemAppManager_) { + systemAppManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); + } } if (currentStackManager_) { currentStackManager_->OnTimeOut(AbilityManagerService::FOREGROUNDNEW_TIMEOUT_MSG, eventId); @@ -2200,8 +2301,14 @@ void AbilityManagerService::HandleForegroundNewTimeOut(int64_t eventId) void AbilityManagerService::HandleBackgroundNewTimeOut(int64_t eventId) { HILOG_DEBUG("Handle BackgroundNew timeout."); - if (kernalAbilityManager_) { - kernalAbilityManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); + if (useNewMission_) { + if (kernalAbilityManager_) { + kernalAbilityManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); + } + } else { + if (systemAppManager_) { + systemAppManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); + } } if (currentStackManager_) { currentStackManager_->OnTimeOut(AbilityManagerService::BACKGROUNDNEW_TIMEOUT_MSG, eventId); @@ -2213,16 +2320,26 @@ bool AbilityManagerService::VerificationToken(const sptr &token) HILOG_INFO("Verification token."); CHECK_POINTER_RETURN_BOOL(dataAbilityManager_); CHECK_POINTER_RETURN_BOOL(connectManager_); - + CHECK_POINTER_RETURN_BOOL(currentStackManager_); + CHECK_POINTER_RETURN_BOOL(systemAppManager_); CHECK_POINTER_RETURN_BOOL(currentMissionListManager_); CHECK_POINTER_RETURN_BOOL(kernalAbilityManager_); - if (currentMissionListManager_->GetAbilityRecordByToken(token)) { - return true; - } + if (useNewMission_) { + if (currentMissionListManager_->GetAbilityRecordByToken(token)) { + return true; + } + if (currentMissionListManager_->GetAbilityFromTerminateList(token)) { + return true; + } + } else { + if (currentStackManager_->GetAbilityRecordByToken(token)) { + return true; + } - if (currentMissionListManager_->GetAbilityFromTerminateList(token)) { - return true; + if (currentStackManager_->GetAbilityFromTerminateList(token)) { + return true; + } } if (dataAbilityManager_->GetAbilityRecordByToken(token)) { @@ -2233,8 +2350,14 @@ bool AbilityManagerService::VerificationToken(const sptr &token) return true; } - if (kernalAbilityManager_->GetAbilityRecordByToken(token)) { - return true; + if (useNewMission_) { + if (kernalAbilityManager_->GetAbilityRecordByToken(token)) { + return true; + } + } else { + if (systemAppManager_->GetAbilityRecordByToken(token)) { + return true; + } } HILOG_ERROR("Failed to verify token."); @@ -2374,6 +2497,7 @@ void AbilityManagerService::RestartAbility(const sptr &token) HILOG_INFO("%{public}s called", __func__); CHECK_POINTER(currentStackManager_); CHECK_POINTER(kernalAbilityManager_); + CHECK_POINTER(systemAppManager_); if (!VerificationToken(token)) { return; } @@ -2382,7 +2506,11 @@ void AbilityManagerService::RestartAbility(const sptr &token) CHECK_POINTER(abilityRecord); if (IsSystemUiApp(abilityRecord->GetAbilityInfo())) { - kernalAbilityManager_->RestartAbility(abilityRecord); + if (useNewMission_) { + kernalAbilityManager_->RestartAbility(abilityRecord); + } else { + systemAppManager_->RestartAbility(abilityRecord); + } return; } diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index d07294c6092eec52388127216bfcd2cb1c37a3bf..31b20b5d7207dc2d546219bda90cb518db134a77 100644 --- a/services/abilitymgr/src/ability_record.cpp +++ b/services/abilitymgr/src/ability_record.cpp @@ -138,7 +138,7 @@ bool AbilityRecord::Init() int AbilityRecord::LoadAbility() { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("%s", __func__); startTime_ = AbilityUtil::SystemTimeMillis(); CHECK_POINTER_AND_RETURN(token_, ERR_INVALID_VALUE); @@ -165,6 +165,7 @@ int AbilityRecord::LoadAbility() void AbilityRecord::ForegroundAbility() { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("ForegroundAbility."); CHECK_POINTER(lifecycleDeal_); @@ -703,7 +704,7 @@ void AbilityRecord::RemoveConnectRecordFromList(const std::shared_ptr &callerToken, int requestCode) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Add caller record."); auto abilityRecord = Token::GetAbilityRecordByToken(callerToken); CHECK_POINTER(abilityRecord); @@ -1225,6 +1226,11 @@ void AbilityRecord::SetMissionList(const std::shared_ptr &missionLi missionList_ = missionList; } +void AbilityRecord::SetUseNewMission() +{ + lifeCycleStateInfo_.useNewMission = true; +} + void AbilityRecord::SetMission(const std::shared_ptr &mission) { if (mission) { diff --git a/services/abilitymgr/src/ability_stack_manager.cpp b/services/abilitymgr/src/ability_stack_manager.cpp index c849d7f7139ad5252dc9fe471ea80f91f688bcf8..a40e31ddad79ecfeb6f7696516e5d07da1bcb6d8 100644 --- a/services/abilitymgr/src/ability_stack_manager.cpp +++ b/services/abilitymgr/src/ability_stack_manager.cpp @@ -125,7 +125,7 @@ int AbilityStackManager::StartAbility(const AbilityRequest &abilityRequest) int AbilityStackManager::StartAbilityLocked( const std::shared_ptr ¤tTopAbility, const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); // lock screen state if (IsLockScreenState()) { HILOG_DEBUG("Start ability with white list ..."); @@ -200,7 +200,7 @@ int AbilityStackManager::StartAbilityAsDefaultLocked( int AbilityStackManager::StartAbilityLifeCycle(std::shared_ptr lastTopAbility, std::shared_ptr currentTopAbility, std::shared_ptr targetAbility) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); CHECK_POINTER_AND_RETURN(targetAbility, ERR_INVALID_VALUE); CHECK_POINTER_AND_RETURN(currentTopAbility, ERR_INVALID_VALUE); enum ChangeType { T_ACTIVE = 0, T_CHANGE, T_DEFAULT } changeType; @@ -310,7 +310,7 @@ int AbilityStackManager::GetTargetChangeType(bool isMissionChanged, bool isStack int AbilityStackManager::StartAbilityAsMultiWindowLocked( const std::shared_ptr ¤tTopAbility, const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Start ability as special locked."); CHECK_POINTER_AND_RETURN(currentTopAbility, INNER_ERR); @@ -397,7 +397,7 @@ int AbilityStackManager::StartAbilityAsMultiWindowLocked( int AbilityStackManager::StartAbilityByAllowListLocked( const std::shared_ptr ¤tTopAbility, const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Start ability as allow list locked."); // 1. lockscreen stack is target mission stack std::shared_ptr targetStack = GetTargetMissionStack(abilityRequest); @@ -453,7 +453,7 @@ void AbilityStackManager::SortPreMission( void AbilityStackManager::MoveMissionAndAbility(const std::shared_ptr ¤tTopAbility, std::shared_ptr &targetAbilityRecord, std::shared_ptr &targetMissionRecord) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Move mission and ability."); CHECK_POINTER(targetAbilityRecord); CHECK_POINTER(targetMissionRecord); diff --git a/services/abilitymgr/src/ams_configuration_parameter.cpp b/services/abilitymgr/src/ams_configuration_parameter.cpp index 99ec0ec2509dcdad557bfd91e714a918bc087cee..0c132a94d5ea930f254e4cc7d8b37495b732d8aa 100644 --- a/services/abilitymgr/src/ams_configuration_parameter.cpp +++ b/services/abilitymgr/src/ams_configuration_parameter.cpp @@ -77,6 +77,11 @@ std::string AmsConfigurationParameter::GetOrientation() const return orientation_; } +bool AmsConfigurationParameter::IsUseNewMission() const +{ + return useNewMission_; +} + int AmsConfigurationParameter::LoadAmsConfiguration(const std::string &filePath) { HILOG_DEBUG("%{public}s", __func__); @@ -137,6 +142,9 @@ int AmsConfigurationParameter::LoadAppConfigurationForStartUpService(nlohmann::j canStartContacts = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_CONTACTS).get(); canStartMms = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_MMS).get(); missionSaveTime_ = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::MISSION_SAVE_TIME).get(); + if (Object.at(AmsConfig::SERVICE_ITEM_AMS).contains(AmsConfig::USE_NEW_MISSION)) { + useNewMission_ = Object.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::USE_NEW_MISSION).get(); + } HILOG_INFO("get ams service config succes!"); ret = 0; } diff --git a/services/abilitymgr/src/app_scheduler.cpp b/services/abilitymgr/src/app_scheduler.cpp index 6d8c49c463c461c19f9d9f4607cde87bb70d54f0..7a6b868ad66eaaca594474a60245f28eac17425e 100644 --- a/services/abilitymgr/src/app_scheduler.cpp +++ b/services/abilitymgr/src/app_scheduler.cpp @@ -56,7 +56,6 @@ bool AppScheduler::Init(const std::weak_ptr &callback) int AppScheduler::LoadAbility(const sptr &token, const sptr &preToken, const AppExecFwk::AbilityInfo &abilityInfo, const AppExecFwk::ApplicationInfo &applicationInfo) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); HILOG_DEBUG("Load ability."); CHECK_POINTER_AND_RETURN(appMgrClient_, INNER_ERR); /* because the errcode type of AppMgr Client API will be changed to int, @@ -71,7 +70,7 @@ int AppScheduler::LoadAbility(const sptr &token, const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Terminate ability."); CHECK_POINTER_AND_RETURN(appMgrClient_, INNER_ERR); /* because the errcode type of AppMgr Client API will be changed to int, @@ -86,7 +85,7 @@ int AppScheduler::TerminateAbility(const sptr &token) void AppScheduler::MoveToForground(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Move to forground."); CHECK_POINTER(appMgrClient_); appMgrClient_->UpdateAbilityState(token, AppExecFwk::AbilityState::ABILITY_STATE_FOREGROUND); @@ -94,7 +93,7 @@ void AppScheduler::MoveToForground(const sptr &token) void AppScheduler::MoveToBackground(const sptr &token) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_DEBUG("Move to background."); CHECK_POINTER(appMgrClient_); appMgrClient_->UpdateAbilityState(token, AppExecFwk::AbilityState::ABILITY_STATE_BACKGROUND); @@ -152,7 +151,7 @@ AppAbilityState AppScheduler::GetAbilityState() const void AppScheduler::OnAbilityRequestDone(const sptr &token, const AppExecFwk::AbilityState state) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("On ability request done, state:%{public}d", static_cast(state)); auto callback = callback_.lock(); CHECK_POINTER(callback); @@ -210,7 +209,7 @@ int AppScheduler::CompelVerifyPermission(const std::string &permission, int pid, void AppScheduler::OnAppStateChanged(const AppExecFwk::AppProcessData &appData) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); auto callback = callback_.lock(); CHECK_POINTER(callback); AppInfo info; diff --git a/services/abilitymgr/src/kernal_ability_manager.cpp b/services/abilitymgr/src/kernal_ability_manager.cpp index d1dd3963e8257cfa5a333f40d42b9f853398b085..6e1059d2c281f7d4356c9421ca2ed69cd9505f4f 100644 --- a/services/abilitymgr/src/kernal_ability_manager.cpp +++ b/services/abilitymgr/src/kernal_ability_manager.cpp @@ -200,6 +200,7 @@ void KernalAbilityManager::GetOrCreateAbilityRecord( return; } targetAbility = AbilityRecord::CreateAbilityRecord(abilityRequest); + targetAbility->SetUseNewMission(); abilities_.push_front(targetAbility); } diff --git a/services/abilitymgr/src/kernal_system_app_manager.cpp b/services/abilitymgr/src/kernal_system_app_manager.cpp index 0198a55b6c6f385394eae9bc87845771bbd00b1b..fca9ab857553ceda4c0a141bb1f9eab3e3bea6a1 100644 --- a/services/abilitymgr/src/kernal_system_app_manager.cpp +++ b/services/abilitymgr/src/kernal_system_app_manager.cpp @@ -32,7 +32,7 @@ KernalSystemAppManager::~KernalSystemAppManager() int KernalSystemAppManager::StartAbility(const AbilityRequest &abilityRequest) { - BYTRACE(BYTRACE_TAG_ABILITY_MANAGER); + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("start kernal systerm ability."); std::lock_guard guard(stackLock_); if (!waittingAbilityQueue_.empty()) { diff --git a/services/abilitymgr/src/lifecycle_state_info.cpp b/services/abilitymgr/src/lifecycle_state_info.cpp index 1070cb1a0521c18cc102fb04f2b5a8235009c62c..62df134bd64976720b4829cf1abb93fa90342c47 100644 --- a/services/abilitymgr/src/lifecycle_state_info.cpp +++ b/services/abilitymgr/src/lifecycle_state_info.cpp @@ -43,6 +43,7 @@ bool LifeCycleStateInfo::ReadFromParcel(Parcel &parcel) return false; } launchParam = *launchInfo; + useNewMission = parcel.ReadBool(); return true; } @@ -90,6 +91,10 @@ bool LifeCycleStateInfo::Marshalling(Parcel &parcel) const if (!parcel.WriteParcelable(&launchParam)) { return false; } + // write useNewMission + if (!parcel.WriteBool(useNewMission)) { + return false; + } return true; } } // namespace AAFwk diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index dc6995bcac16b360f95edcdb861983b823a35be3..c934493732e873220a6fd281aee0fd0d352fba87 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -18,6 +18,7 @@ #include "ability_manager_errors.h" #include "ability_manager_service.h" #include "ability_util.h" +#include "bytrace.h" #include "errors.h" #include "hilog_wrapper.h" #include "mission_info_mgr.h" @@ -25,6 +26,7 @@ namespace OHOS { namespace AAFwk { namespace { +constexpr uint32_t NEXTABILITY_TIMEOUT = 1000; // ms std::string Time2str(time_t time) { std::stringstream str; @@ -289,6 +291,7 @@ void MissionListManager::GetTargetMissionAndAbility(const AbilityRequest &abilit } targetRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); targetMission = std::make_shared(info.missionInfo.id, targetRecord, missionName); + targetRecord->SetUseNewMission(); targetRecord->SetMission(targetMission); if (abilityRequest.abilityInfo.applicationInfo.isLauncherApp) { @@ -661,6 +664,7 @@ int MissionListManager::DispatchForegroundNew(const std::shared_ptr &abilityRecord) { + BYTRACE_NAME(BYTRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); std::lock_guard guard(managerLock_); CHECK_POINTER(abilityRecord); @@ -700,7 +704,7 @@ void MissionListManager::CompleteForegroundNew(const std::shared_ptrPostTask(startWaittingAbilityTask, "startWaittingAbility"); + handler->PostTask(startWaittingAbilityTask, "startWaittingAbility", NEXTABILITY_TIMEOUT); } int MissionListManager::DispatchBackground(const std::shared_ptr &abilityRecord) @@ -804,7 +808,7 @@ int MissionListManager::TerminateAbilityLocked(const std::shared_ptrSendResultToCallers(); // 1. if the ability was foregorund, first should find wether there is other ability foregorund - if (abilityRecord->IsActiveState()) { + if (abilityRecord->IsAbilityState(FOREGROUND_NEW) || abilityRecord->IsAbilityState(FOREGROUNDING_NEW)) { HILOG_DEBUG("current ability is active"); if (abilityRecord->GetNextAbilityRecord()) { abilityRecord->GetNextAbilityRecord()->ProcessForegroundAbility(); @@ -855,13 +859,14 @@ void MissionListManager::RemoveTerminatingAbility(const std::shared_ptrSetNextAbilityRecord(nullptr); // 2. if the ability to terminate is background, just background - if (!abilityRecord->IsActiveState()) { + if (!(abilityRecord->IsAbilityState(FOREGROUND_NEW) || abilityRecord->IsAbilityState(FOREGROUNDING_NEW))) { HILOG_DEBUG("ability state is %{public}d, just return", abilityRecord->GetAbilityState()); return; } // 3. if the launcher is foreground, just background std::shared_ptr launcherRoot = launcherList_->GetLauncherRoot(); - if (launcherRoot->IsActiveState()) { + if (launcherRoot + && (launcherRoot->IsAbilityState(FOREGROUND_NEW) || launcherRoot->IsAbilityState(FOREGROUNDING_NEW))) { HILOG_DEBUG("launcherRoot state is %{public}d, no need to schedule next", launcherRoot->GetAbilityState()); return; } @@ -869,7 +874,7 @@ void MissionListManager::RemoveTerminatingAbility(const std::shared_ptrIsEmpty()) { HILOG_DEBUG("missionList is empty, next is launcher"); - abilityRecord->SetNextAbilityRecord(launcherList_->GetTopAbility()); + abilityRecord->SetNextAbilityRecord(GetCurrentTopAbilityLocked()); } else { std::shared_ptr needTopAbility = missionList->GetTopAbility(); abilityRecord->SetNextAbilityRecord(needTopAbility); @@ -1144,8 +1149,10 @@ std::shared_ptr MissionListManager::GetAbilityRecordByEventId(int void MissionListManager::OnAbilityDied(std::shared_ptr abilityRecord) { + HILOG_INFO("On ability died."); if (!abilityRecord) { HILOG_ERROR("OnAbilityDied come, abilityRecord is nullptr."); + return; } std::string element = abilityRecord->GetWant().GetElement().GetURI(); HILOG_DEBUG("OnAbilityDied come, ability is %{public}s", element.c_str()); @@ -1153,6 +1160,8 @@ void MissionListManager::OnAbilityDied(std::shared_ptr abilityRec HILOG_ERROR("Ability type is not page."); return; } + std::lock_guard guard(managerLock_); + HandleAbilityDied(abilityRecord); } std::shared_ptr MissionListManager::GetTargetMissionList(int missionId, std::shared_ptr &mission) @@ -1209,6 +1218,7 @@ std::shared_ptr MissionListManager::GetTargetMissionList(int missio } auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest); + abilityRecord->SetUseNewMission(); mission = std::make_shared(innerMissionInfo.missionInfo.id, abilityRecord, innerMissionInfo.missionName); abilityRecord->SetMission(mission); std::shared_ptr newMissionList = std::make_shared(); @@ -1268,6 +1278,122 @@ void MissionListManager::PostStartWaittingAbility() handler->PostTask(startWaittingAbilityTask, "startWaittingAbility"); } +void MissionListManager::HandleAbilityDied(std::shared_ptr abilityRecord) +{ + HILOG_INFO("Handle Ability Died."); + CHECK_POINTER(abilityRecord); + if (abilityRecord->IsLauncherAbility()) { + HandleLauncherDied(abilityRecord); + return; + } + HandleAbilityDiedByDefault(abilityRecord); +} + +void MissionListManager::HandleLauncherDied(std::shared_ptr ability) +{ + HILOG_INFO("Handle launcher Ability Died."); + auto mission = ability->GetMission(); + CHECK_POINTER_LOG(mission, "Fail to get launcher mission."); + auto missionList = mission->GetMissionList(); + if (launcherList_ != missionList) { + HILOG_ERROR("not launcher missionList."); + return; + } + + bool isForeground = ability->IsAbilityState(FOREGROUND_NEW) || ability->IsAbilityState(FOREGROUNDING_NEW); + if (ability->IsLauncherRoot()) { + HILOG_INFO("launcher root Ability died, state: INITIAL, %{public}d", __LINE__); + ability->SetAbilityState(AbilityState::INITIAL); + } else { + HILOG_INFO("launcher Ability died, remove, %{public}d", __LINE__); + missionList->RemoveMission(mission); + } + if (isForeground) { + HILOG_INFO("active launchrer ability died, start launcher, %{public}d", __LINE__); + DelayedStartLauncher(); + } +} + +void MissionListManager::HandleAbilityDiedByDefault(std::shared_ptr ability) +{ + HILOG_INFO("Handle Ability DiedByDefault."); + auto mission = ability->GetMission(); + CHECK_POINTER_LOG(mission, "Fail to get mission."); + auto missionList = mission->GetMissionList(); + CHECK_POINTER_LOG(missionList, "Fail to get mission list."); + + std::shared_ptr launcherRoot = launcherList_->GetLauncherRoot(); + bool isLauncherActive = (launcherRoot && + (launcherRoot->IsAbilityState(FOREGROUND_NEW) || launcherRoot->IsAbilityState(FOREGROUNDING_NEW))); + bool isForeground = ability->IsAbilityState(FOREGROUND_NEW) || ability->IsAbilityState(FOREGROUNDING_NEW); + + // remove from mission list. + missionList->RemoveMission(mission); + if (missionList->GetType() == MissionListType::CURRENT && missionList->IsEmpty()) { + RemoveMissionList(missionList); + } + + // update running state. + InnerMissionInfo info; + if (DelayedSingleton::GetInstance()->GetInnerMissionInfoById(mission->GetMissionId(), info) == 0) { + info.missionInfo.runningState = -1; + DelayedSingleton::GetInstance()->UpdateMissionInfo(info); + } + + // start launcher + if (isForeground && !isLauncherActive) { + HILOG_INFO("active ability died, start launcher later, %{public}d", __LINE__); + DelayedStartLauncher(); + } +} + +void MissionListManager::DelayedStartLauncher() +{ + auto ams = DelayedSingleton::GetInstance(); + CHECK_POINTER(ams); + auto handler = ams->GetEventHandler(); + CHECK_POINTER(handler); + std::weak_ptr wpListMgr = shared_from_this(); + auto timeoutTask = [wpListMgr]() { + HILOG_DEBUG("The launcher needs to be restarted."); + auto listMgr = wpListMgr.lock(); + if (listMgr) { + listMgr->BackToLauncher(); + } + }; + handler->PostTask(timeoutTask, "Launcher_Restart"); +} + +void MissionListManager::BackToLauncher() +{ + HILOG_INFO("Back to launcher."); + std::lock_guard guard(managerLock_); + CHECK_POINTER(launcherList_); + + auto currentTop = GetCurrentTopAbilityLocked(); + if (currentTop && (currentTop->IsAbilityState(AbilityState::FOREGROUND_NEW) || + currentTop->IsAbilityState(AbilityState::FOREGROUNDING_NEW))) { + HILOG_WARN("Current top ability is already foreground, no need to start launcher."); + return; + } + + auto launcherRootAbility = launcherList_->GetLauncherRoot(); + CHECK_POINTER_LOG(launcherRootAbility, "There is no root launcher ability, back to launcher failed."); + auto launcherRootMission = launcherRootAbility->GetMission(); + CHECK_POINTER_LOG(launcherRootMission, "There is no root launcher mission, back to launcher failed."); + if (launcherRootAbility->IsAbilityState(AbilityState::FOREGROUND_NEW) || + launcherRootAbility->IsAbilityState(AbilityState::FOREGROUNDING_NEW)) { + HILOG_WARN("launcher is already foreground, no need to start launcher."); + return; + } + std::queue emptyQueue; + std::swap(waittingAbilityQueue_, emptyQueue); + + launcherList_->AddMissionToTop(launcherRootMission); + MoveMissionListToTop(launcherList_); + launcherRootAbility->ProcessForegroundAbility(); +} + void MissionListManager::Dump(std::vector &info) { std::lock_guard guard(managerLock_); diff --git a/services/abilitymgr/src/stop_user_callback_stub.cpp b/services/abilitymgr/src/stop_user_callback_stub.cpp index b61aa8c5f56f17019bb33347486b66c8f33b90a1..320953fdd073e8fce3cade7886127526dbe6fe7a 100755 --- a/services/abilitymgr/src/stop_user_callback_stub.cpp +++ b/services/abilitymgr/src/stop_user_callback_stub.cpp @@ -45,7 +45,7 @@ int StopUserCallbackStub::OnRemoteRequest( return ERR_INVALID_STATE; } - if (code < StopUserCallbackCmd::ON_STOP_USER_DONE && code >= 0) { + if (code < StopUserCallbackCmd::CMD_MAX && code >= 0) { auto memberFunc = vecMemberFunc_[code]; return (this->*memberFunc)(data, reply); } @@ -53,4 +53,4 @@ int StopUserCallbackStub::OnRemoteRequest( return IPCObjectStub::OnRemoteRequest(code, data, reply, option); } } // namespace AAFwk -} // namespace OHOS \ No newline at end of file +} // namespace OHOS