From e479a1eaa7a46af0a459c4dfae47077df938f0aa Mon Sep 17 00:00:00 2001 From: yuwenze Date: Fri, 24 Mar 2023 03:50:58 +0000 Subject: [PATCH 1/3] startAbilityByLauncher Signed-off-by: xieqiongyang Change-Id: Ief7c3394cadb16bf5dcf3c534bce8ce9a99e5c2b --- frameworks/native/ability/native/ability.cpp | 87 +++++++ .../native/ability/native/ability_impl.cpp | 3 +- .../native/ability_runtime/js_ability.cpp | 60 ++++- .../ability/native/new_ability_impl.cpp | 8 +- frameworks/native/appkit/app/main_thread.cpp | 3 + .../include/ability_manager_client.h | 5 + .../include/ability_manager_interface.h | 11 + services/abilitymgr/abilitymgr.gni | 1 + .../include/ability_manager_proxy.h | 6 + .../include/ability_manager_service.h | 8 + services/abilitymgr/include/ability_record.h | 3 +- .../abilitymgr/include/ui_ability_manager.h | 59 +++++ .../abilitymgr/src/ability_manager_client.cpp | 24 ++ .../abilitymgr/src/ability_manager_proxy.cpp | 83 +++++++ .../src/ability_manager_service.cpp | 171 ++++++++++--- .../abilitymgr/src/ability_manager_stub.cpp | 48 ++++ services/abilitymgr/src/ability_record.cpp | 6 +- .../abilitymgr/src/mission_list_manager.cpp | 4 + .../abilitymgr/src/ui_ability_manager.cpp | 224 ++++++++++++++++++ services/abilitymgr/src/user_controller.cpp | 20 +- 20 files changed, 778 insertions(+), 56 deletions(-) create mode 100644 services/abilitymgr/include/ui_ability_manager.h create mode 100644 services/abilitymgr/src/ui_ability_manager.cpp diff --git a/frameworks/native/ability/native/ability.cpp b/frameworks/native/ability/native/ability.cpp index 714968fed..6e5638212 100644 --- a/frameworks/native/ability/native/ability.cpp +++ b/frameworks/native/ability/native/ability.cpp @@ -158,6 +158,87 @@ bool Ability::IsUpdatingConfigurations() return AbilityContext::IsUpdatingConfigurations(); } +void Ability::OnStart(const Want &want, sptr sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (abilityInfo_ == nullptr) { + HILOG_ERROR("Ability::OnStart failed abilityInfo_ is nullptr."); + return; + } + + appIndex_ = want.GetIntParam(DLP_INDEX, 0); + (const_cast(want)).RemoveParam(DLP_INDEX); + securityFlag_ = want.GetBoolParam(DLP_PARAMS_SECURITY_FLAG, false); + (const_cast(want)).RemoveParam(DLP_PARAMS_SECURITY_FLAG); + SetWant(want); + SetSessionInfo(sessionInfo); + HILOG_INFO("%{public}s begin, ability is %{public}s.", __func__, abilityInfo_->name.c_str()); +#ifdef SUPPORT_GRAPHICS + if (abilityInfo_->type == AppExecFwk::AbilityType::PAGE) { + int defualtDisplayId = Rosen::WindowScene::DEFAULT_DISPLAY_ID; + int displayId = want.GetIntParam(Want::PARAM_RESV_DISPLAY_ID, defualtDisplayId); + HILOG_DEBUG("abilityName:%{public}s, displayId:%{public}d", abilityInfo_->name.c_str(), displayId); + + // Update resMgr, Configuration + sptr display = nullptr; + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + display = Rosen::DisplayManager::GetInstance().GetDisplayById(displayId); + } else { + // 待合一服务提供新的拿display的方法 + // display = Rosen::DisplayManager::GetInstance().NewMethod(displayId); + } + if (display) { + float density = display->GetVirtualPixelRatio(); + int32_t width = display->GetWidth(); + int32_t height = display->GetHeight(); + std::shared_ptr configuration = nullptr; + if (application_) { + configuration = application_->GetConfiguration(); + } + if (configuration) { + std::string direction = GetDirectionStr(height, width); + configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DIRECTION, direction); + configuration->AddItem(displayId, ConfigurationInner::APPLICATION_DENSITYDPI, GetDensityStr(density)); + configuration->AddItem(ConfigurationInner::APPLICATION_DISPLAYID, std::to_string(displayId)); + UpdateContextConfiguration(); + } + + std::unique_ptr resConfig(Global::Resource::CreateResConfig()); + if (resConfig == nullptr) { + HILOG_ERROR("%{public}s error, resConfig is nullptr.", __func__); + return; + } + auto resourceManager = GetResourceManager(); + if (resourceManager != nullptr) { + resourceManager->GetResConfig(*resConfig); + resConfig->SetScreenDensity(ConvertDensity(density)); + resConfig->SetDirection(ConvertDirection(height, width)); + resourceManager->UpdateResConfig(*resConfig); + HILOG_DEBUG("%{public}s Notify ResourceManager, Density: %{public}f, Direction: %{public}d.", __func__, + resConfig->GetScreenDensity(), resConfig->GetDirection()); + } + } + } +#endif + if (abilityLifecycleExecutor_ == nullptr) { + HILOG_ERROR("Ability::OnStart error. abilityLifecycleExecutor_ == nullptr."); + return; + } + if (!abilityInfo_->isStageBasedModel) { + abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::INACTIVE); + } else { + abilityLifecycleExecutor_->DispatchLifecycleState(AbilityLifecycleExecutor::LifecycleState::STARTED_NEW); + } + + if (lifecycle_ == nullptr) { + HILOG_ERROR("Ability::OnStart error. lifecycle_ == nullptr."); + return; + } + lifecycle_->DispatchLifecycle(LifeCycle::Event::ON_START, want); + HILOG_DEBUG("%{public}s end", __func__); +} + + void Ability::OnStart(const Want &want) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); @@ -262,6 +343,11 @@ void Ability::OnStop() if (scene_ != nullptr) { scene_->GoDestroy(); onSceneDestroyed(); + } else { + if (uiWindow_) { + HILOG_INFO("UIWindow do disconnect."); + uiWindow_->Disconnect(); + } } #endif if (abilityLifecycleExecutor_ == nullptr) { @@ -1534,6 +1620,7 @@ void Ability::OnBackground() abilityRecovery_->ScheduleSaveAbilityState(StateReason::LIFECYCLE); } } else { + // FA模型待适配 if (abilityWindow_ == nullptr) { HILOG_ERROR("Ability::OnBackground error. abilityWindow_ == nullptr."); return; diff --git a/frameworks/native/ability/native/ability_impl.cpp b/frameworks/native/ability/native/ability_impl.cpp index ba44f321f..c1c8bee51 100644 --- a/frameworks/native/ability/native/ability_impl.cpp +++ b/frameworks/native/ability/native/ability_impl.cpp @@ -168,6 +168,7 @@ void AbilityImpl::StopCallback() } #endif abilityLifecycleCallbacks_->OnAbilityStop(ability_); + // FA模型后面考虑是否需要适配 ability_->DestroyInstance(); // Release window and ability. } @@ -711,7 +712,7 @@ void AbilityImpl::Background() HILOG_ERROR("AbilityImpl::Background ability_ or abilityLifecycleCallbacks_ is nullptr"); return; } - ability_->OnLeaveForeground(); + // ability_->OnLeaveForeground(); ability_->OnBackground(); if ((ability_->GetAbilityInfo()->type == AppExecFwk::AbilityType::PAGE) && (ability_->GetAbilityInfo()->isStageBasedModel)) { diff --git a/frameworks/native/ability/native/ability_runtime/js_ability.cpp b/frameworks/native/ability/native/ability_runtime/js_ability.cpp index c581c6248..1f35d8650 100644 --- a/frameworks/native/ability/native/ability_runtime/js_ability.cpp +++ b/frameworks/native/ability/native/ability_runtime/js_ability.cpp @@ -201,7 +201,17 @@ void JsAbility::OnStart(const Want &want) HandleScope handleScope(jsRuntime_); auto &nativeEngine = jsRuntime_.GetNativeEngine(); - + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + HILOG_INFO("sessionInfo is%{public}s null", sessionInfo == nullptr ? "" : " not"); + if (sessionInfo) { + uiWindow_ = Ace::NG::UIWindow::CreateWindowScene(abilityContext_, + sessionInfo->sessionToken, sessionInfo->surfaceNode); + if (uiWindow_ != nullptr) { + uiWindow_->RegisterSessionStageStateListener(sceneSessionStageListener_); + uiWindow_->Connect(); + } + } + } NativeValue *value = jsAbilityObj_->Get(); NativeObject *obj = ConvertNativeValueTo(value); if (obj == nullptr) { @@ -410,7 +420,11 @@ void JsAbility::OnForeground(const Want &want) NativeValue *jsWant = reinterpret_cast(napiWant); obj->SetProperty("lastRequestWant", jsWant); - + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + if (GetState() == AppExecFwk::AbilityLifecycleExecutor::STARTED_NEW) { + AbilityContinuationOrRecover(want); + } + } CallObjectMethod("onForeground", &jsWant, 1); auto delegator = AppExecFwk::AbilityDelegatorRegistry::GetAbilityDelegator(); @@ -514,6 +528,18 @@ void JsAbility::AbilityContinuationOrRecover(const Want &want) void JsAbility::DoOnForeground(const Want &want) { + HILOG_ERROR("chy ========test"); + std::string testName = want.GetBundle(); + HILOG_ERROR("chy BundleName: %{public}s beforeForeground", testName.c_str()); + auto testType = Ability::GetAbilityInfo()->type; + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + if (uiWindow_) { + HILOG_ERROR("chy ablitytype: %{public}d", static_cast(testType)); + uiWindow_->Foreground(); + } + return; + } + HILOG_ERROR("chy BundleName: %{public}s doOnForegound", testName.c_str()); if (scene_ == nullptr) { if ((abilityContext_ == nullptr) || (sceneListener_ == nullptr)) { HILOG_ERROR("Ability::OnForeground error. abilityContext_ or sceneListener_ is nullptr!"); @@ -572,17 +598,24 @@ void JsAbility::DoOnForeground(const Want &want) void JsAbility::RequestFocus(const Want &want) { HILOG_DEBUG("%{public}s called.", __func__); - if (scene_ == nullptr) { - return; - } - auto window = scene_->GetMainWindow(); - if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) { - auto windowMode = want.GetIntParam(Want::PARAM_RESV_WINDOW_MODE, - AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED); - window->SetWindowMode(static_cast(windowMode)); - HILOG_DEBUG("set window mode = %{public}d.", windowMode); + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + if (uiWindow_ != nullptr) { + // 待UIWindow提供对应的接口 + // uiWindow_->Focus(); + } + } else { + if (scene_ == nullptr) { + return; + } + auto window = scene_->GetMainWindow(); + if (window != nullptr && want.HasParameter(Want::PARAM_RESV_WINDOW_MODE)) { + auto windowMode = want.GetIntParam(Want::PARAM_RESV_WINDOW_MODE, + AAFwk::AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_UNDEFINED); + window->SetWindowMode(static_cast(windowMode)); + HILOG_DEBUG("set window mode = %{public}d.", windowMode); + } + scene_->GoForeground(Ability::sceneFlag_); } - scene_->GoForeground(Ability::sceneFlag_); } void JsAbility::ContinuationRestore(const Want &want) @@ -755,6 +788,9 @@ void JsAbility::OnNewWant(const Want &want) if (scene_) { scene_->OnNewWant(want); } + if (uiWindow_ != nullptr) { + // uiWindow_->OnNewWant(want); + } #endif HandleScope handleScope(jsRuntime_); diff --git a/frameworks/native/ability/native/new_ability_impl.cpp b/frameworks/native/ability/native/new_ability_impl.cpp index 5634277d2..926f9824d 100644 --- a/frameworks/native/ability/native/new_ability_impl.cpp +++ b/frameworks/native/ability/native/new_ability_impl.cpp @@ -48,13 +48,13 @@ void NewAbilityImpl::HandleAbilityTransaction(const Want &want, const AAFwk::Lif return; } #endif - SetLifeCycleStateInfo(targetState); + // SetLifeCycleStateInfo(targetState); if (ability_ != nullptr) { ability_->SetLaunchParam(targetState.launchParam); if (lifecycleState_ == AAFwk::ABILITY_STATE_INITIAL) { - ability_->SetStartAbilitySetting(targetState.setting); - Start(want); - CheckAndRestore(); + // ability_->SetStartAbilitySetting(targetState.setting); + Start(want, sessionInfo); + // CheckAndRestore(); } } diff --git a/frameworks/native/appkit/app/main_thread.cpp b/frameworks/native/appkit/app/main_thread.cpp index 505f3e1df..b7dac1f89 100644 --- a/frameworks/native/appkit/app/main_thread.cpp +++ b/frameworks/native/appkit/app/main_thread.cpp @@ -584,6 +584,9 @@ void MainThread::ScheduleLaunchAbility(const AbilityInfo &info, const sptr &want) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (token == nullptr) { + HILOG_ERROR("ywz token is nullptr"); + } HILOG_DEBUG("schedule launch ability %{public}s, type is %{public}d.", info.name.c_str(), info.type); std::shared_ptr abilityInfo = std::make_shared(info); diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_client.h b/interfaces/inner_api/ability_manager/include/ability_manager_client.h index 605fc5542..167bf4935 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_client.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_client.h @@ -616,6 +616,11 @@ public: */ ErrCode GetMissionIdByToken(const sptr &token, int32_t &missionId); + ErrCode StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, sptr sessionInfo, + int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = DEFAULT_INVAL_VALUE); + + sptr GetTokenBySceneSession(uint64_t persistentId); + /** * Start Ability, connect session with common ability. * diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h index 19232ae3c..3595db28a 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h @@ -76,6 +76,17 @@ public: int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = DEFAULT_INVAL_VALUE) = 0; + virtual int StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = DEFAULT_INVAL_VALUE) + { + return 0; + } + + virtual sptr GetTokenBySceneSession(uint64_t persistentId) + { + return 0; + } + /** * StartAbility with want, send want to ability manager service. * diff --git a/services/abilitymgr/abilitymgr.gni b/services/abilitymgr/abilitymgr.gni index 1f69c8423..ad7a4048c 100644 --- a/services/abilitymgr/abilitymgr.gni +++ b/services/abilitymgr/abilitymgr.gni @@ -70,6 +70,7 @@ abilityms_files = [ "src/remote_mission_listener_stub.cpp", "src/mission_list_manager.cpp", "src/mission_list.cpp", + "src/ui_ability_manager.cpp", #connection observer "src/connection_observer_controller.cpp", diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index 7b112c141..f7c934776 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -62,6 +62,12 @@ public: int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = DEFAULT_INVAL_VALUE) override; + + virtual int StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) override; + + virtual sptr GetTokenBySceneSession(uint64_t persistentId) override; /** * Starts a new ability with specific start settings. * diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index bd8c29c4f..19f1c937a 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -46,6 +46,7 @@ #include "parameter.h" #include "pending_want_manager.h" #include "ams_configuration_parameter.h" +#include "ui_ability_manager.h" #include "user_controller.h" #include "resident_process_manager.h" #ifdef SUPPORT_GRAPHICS @@ -88,6 +89,12 @@ public: virtual int StartAbility( const Want &want, int32_t userId = DEFAULT_INVAL_VALUE, int requestCode = DEFAULT_INVAL_VALUE) override; + virtual int StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId = DEFAULT_INVAL_VALUE, + int requestCode = DEFAULT_INVAL_VALUE) override; + + virtual sptr GetTokenBySceneSession(uint64_t persistentId) override; + /** * StartAbility with want, send want to ability manager service. * @@ -1307,6 +1314,7 @@ private: std::shared_ptr currentMissionListManager_; std::shared_ptr freeInstallManager_; + std::unique_ptr uiAbilityManager_; std::shared_ptr userController_; sptr abilityController_ = nullptr; diff --git a/services/abilitymgr/include/ability_record.h b/services/abilitymgr/include/ability_record.h index 74603a488..6745fe9d2 100644 --- a/services/abilitymgr/include/ability_record.h +++ b/services/abilitymgr/include/ability_record.h @@ -279,7 +279,8 @@ public: * @param abilityRequest,create ability record. * @return Returns ability record ptr. */ - static std::shared_ptr CreateAbilityRecord(const AbilityRequest &abilityRequest); + static std::shared_ptr CreateAbilityRecord(const AbilityRequest &abilityRequest, + sptr sessionInfo = nullptr); /** * Init ability record. diff --git a/services/abilitymgr/include/ui_ability_manager.h b/services/abilitymgr/include/ui_ability_manager.h new file mode 100644 index 000000000..e9dfacdf7 --- /dev/null +++ b/services/abilitymgr/include/ui_ability_manager.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_ABILITY_RUNTIME_UI_ABILITY_MANAGER_H +#define OHOS_ABILITY_RUNTIME_UI_ABILITY_MANAGER_H + +#include + +#include "ability_record.h" +#include "session_info.h" + +namespace OHOS { +namespace AAFwk { +class UIAbilityManager { +public: + UIAbilityManager() = default; + virtual ~UIAbilityManager() = default; + + void Init(); + + /** + * StartAbility with request. + * + * @param abilityRequest, the request of the service ability to start. + * @param sessionInfo, the info of scene session + * @return Returns ERR_OK on success, others on failure. + */ + int StartAbility(AbilityRequest &abilityRequest, sptr sessionInfo); + + int AttachAbilityThread(const sptr &scheduler, const sptr &token); + void OnAbilityRequestDone(const sptr &token, int32_t state) const; + sptr GetTokenBySceneSession(uint64_t persistentId); + +private: + void UpdateAbilityRecordLaunchReason(const AbilityRequest &abilityRequest, + std::shared_ptr &abilityRecord) const; + void EnqueueWaitingAbilityToFront(const AbilityRequest &abilityRequest); + bool IsContainsAbility(std::shared_ptr &abilityRecord) const; + int StartAbilityLocked(const AbilityRequest &abilityRequest, sptr sessionInfo); + + mutable std::recursive_mutex sessionLock_; + std::map, std::shared_ptr> sessionItems_; + std::queue waitingAbilityQueue_; +}; +} // namespace AAFwk +} // namespace OHOS +#endif // OHOS_ABILITY_RUNTIME_UI_ABILITY_MANAGER_H diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index 5e5366ee0..29e8a49fa 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -170,6 +170,30 @@ ErrCode AbilityManagerClient::StartAbilityAsCaller(const Want &want, const Start return abms->StartAbilityAsCaller(want, startOptions, callerToken, userId, requestCode); } +ErrCode AbilityManagerClient::StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId, int requestCode) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetAbilityManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + HILOG_INFO("%{public}s come, abilityName=%{public}s, userId=%{public}d.", + __func__, want.GetElement().GetAbilityName().c_str(), userId); + // 合一服务调过来的，要么不涉及沙箱，要么沙箱已被原有的startAbility处理 + // HandleDlpApp(const_cast(want)); + return abms->StartAbilityByLauncher(want, startOptions, sessionInfo, userId, requestCode); +} + +sptr AbilityManagerClient::GetTokenBySceneSession(uint64_t persistentId) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetAbilityManager(); + if (!abms) { + return nullptr; + } + HILOG_INFO("persistentId: %{public}" PRIu64 ".", persistentId); + return abms->GetTokenBySceneSession(persistentId); +} + ErrCode AbilityManagerClient::SendResultToAbility(int requestCode, int resultCode, Want& resultWant) { auto abms = GetAbilityManager(); diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp index 516738d98..96f6bbeb5 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -350,6 +350,89 @@ int AbilityManagerProxy::StartAbilityAsCaller(const Want &want, const StartOptio return reply.ReadInt32(); } +int AbilityManagerProxy::StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId, int requestCode) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return INNER_ERR; + } + if (!data.WriteParcelable(&want)) { + HILOG_ERROR("want write failed."); + return INNER_ERR; + } + if (!data.WriteParcelable(&startOptions)) { + HILOG_ERROR("startOptions write failed."); + return INNER_ERR; + } + // if (callerToken) { + // if (!data.WriteBool(true) || !data.WriteRemoteObject(callerToken)) { + // HILOG_ERROR("flag and callerToken write failed."); + // return INNER_ERR; + // } + // } else { + // if (!data.WriteBool(false)) { + // HILOG_ERROR("flag write failed."); + // return INNER_ERR; + // } + // } + + if (sessionInfo) { + if (!data.WriteBool(true) || !data.WriteParcelable(sessionInfo)) { + HILOG_ERROR("flag and sessionInfo write failed."); + return INNER_ERR; + } + } else { + if (!data.WriteBool(false)) { + HILOG_ERROR("flag write failed."); + return INNER_ERR; + } + } + + if (!data.WriteInt32(userId)) { + HILOG_ERROR("userId write failed."); + return INNER_ERR; + } + if (!data.WriteInt32(requestCode)) { + HILOG_ERROR("requestCode write failed."); + return INNER_ERR; + } + error = Remote()->SendRequest(IAbilityManager::START_ABILITY_BY_LAUNCHER, data, reply, option); + if (error != NO_ERROR) { + HILOG_ERROR("Send request error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + +sptr AbilityManagerProxy::GetTokenBySceneSession(uint64_t persistentId) +{ + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (!WriteInterfaceToken(data)) { + return nullptr; + } + if (!data.WriteUint64(persistentId)) { + HILOG_ERROR("persistentId write failed."); + return nullptr; + } + + auto error = Remote()->SendRequest(IAbilityManager::GET_TOKEN_BY_SCENE_SESSION, data, reply, option); + if (error != NO_ERROR) { + HILOG_ERROR("Send request error: %{public}d", error); + return nullptr; + } + sptr token = nullptr; + if (reply.ReadBool()) { + token = reply.ReadRemoteObject(); + } + return token; +} + int AbilityManagerProxy::StartExtensionAbility(const Want &want, const sptr &callerToken, int32_t userId, AppExecFwk::ExtensionAbilityType extensionType) { diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index b85a3fcf0..ded244174 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -281,10 +281,12 @@ bool AbilityManagerService::Init() amsConfigResolver_ = std::make_shared(); amsConfigResolver_->Parse(); HILOG_INFO("ams config parse"); - InitMissionListManager(MAIN_USER_ID, true); + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + uiAbilityManager_ = std::make_unique(); + } else { + InitMissionListManager(MAIN_USER_ID, true); + } SwitchManagers(U0_USER_ID, false); - int amsTimeOut = amsConfigResolver_->GetAMSTimeOutTime(); - HILOG_INFO("amsTimeOut is %{public}d", amsTimeOut); std::string threadName = std::string(AbilityConfig::NAME_ABILITY_MGR_SERVICE) + "(" + std::to_string(eventLoop_->GetThreadId()) + ")"; #ifdef SUPPORT_ASAN @@ -917,6 +919,90 @@ int AbilityManagerService::StartAbilityForOptionInner(const Want &want, const St return ret; } +// 1.新动效框架下UIAbilityManager不关系多用户场景 +// 2.合一服务不会启动沙箱应用？沙箱应用可以有图标吗？ +// 3.从图标点击启动，不涉及免安装、隐式启动 +// 4.加校验，只允许合一服务调用该方法 +int AbilityManagerService::StartAbilityByLauncher(const Want &want, const StartOptions &startOptions, + sptr sessionInfo, int32_t userId, int requestCode) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_DEBUG("Start ability options."); + EventInfo eventInfo = BuildEventInfo(want, userId); + EventReport::SendAbilityEvent(EventName::START_ABILITY, HiSysEventType::BEHAVIOR, eventInfo); + + if (sessionInfo->callerToken != nullptr && !VerificationAllToken(sessionInfo->callerToken)) { + return ERR_INVALID_CALLER; + } + + // 合一服务起的也有可能是众测应用，要加判断 + auto result = interceptorExecuter_ == nullptr ? ERR_INVALID_VALUE : + interceptorExecuter_->DoProcess(want, requestCode, GetUserId(), true); + if (result != ERR_OK) { + HILOG_ERROR("interceptorExecuter_ is nullptr or DoProcess return error."); + eventInfo.errCode = result; + EventReport::SendAbilityEvent(EventName::START_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo); + return result; + } + + int32_t oriValidUserId = GetValidUserId(userId); + int32_t validUserId = oriValidUserId; + + if (!JudgeMultiUserConcurrency(validUserId)) { + HILOG_ERROR("Multi-user non-concurrent mode is not satisfied."); + return ERR_CROSS_USER; + } + + AbilityRequest abilityRequest; + result = GenerateAbilityRequest(want, requestCode, abilityRequest, sessionInfo->callerToken, validUserId); + if (result != ERR_OK) { + HILOG_ERROR("Generate ability request local error."); + return result; + } + + auto abilityInfo = abilityRequest.abilityInfo; + // singleton应用可以非常驻？ + validUserId = abilityInfo.applicationInfo.singleton ? U0_USER_ID : validUserId; + HILOG_DEBUG("userId : %{public}d, singleton is : %{public}d", + validUserId, static_cast(abilityInfo.applicationInfo.singleton)); + + if (abilityInfo.type != AppExecFwk::AbilityType::PAGE) { + HILOG_ERROR("Only support for page type ability."); + return ERR_INVALID_VALUE; + } + + if (!AbilityUtil::IsSystemDialogAbility(abilityInfo.bundleName, abilityInfo.name)) { + result = PreLoadAppDataAbilities(abilityInfo.bundleName, validUserId); + if (result != ERR_OK) { + HILOG_ERROR("StartAbility: App data ability preloading failed, '%{public}s', %{public}d", + abilityInfo.bundleName.c_str(), result); + return result; + } + } + + // if (!IsAbilityControllerStart(want, abilityInfo.bundleName)) { + // return ERR_WOULD_BLOCK; + // } + abilityRequest.want.SetParam(Want::PARAM_RESV_DISPLAY_ID, startOptions.GetDisplayID()); + abilityRequest.want.SetParam(Want::PARAM_RESV_WINDOW_MODE, startOptions.GetWindowMode()); + if (uiAbilityManager_ == nullptr) { + HILOG_ERROR("uiAbilityManager_ is nullptr"); + return ERR_INVALID_VALUE; + } + +#ifdef SUPPORT_GRAPHICS + if (abilityInfo.isStageBasedModel && !CheckWindowMode(startOptions.GetWindowMode(), abilityInfo.windowModes)) { + return ERR_AAFWK_INVALID_WINDOW_MODE; + } +#endif + return uiAbilityManager_->StartAbility(abilityRequest, sessionInfo); +} + +sptr AbilityManagerService::GetTokenBySceneSession(uint64_t persistentId) +{ + return uiAbilityManager_->GetTokenBySceneSession(persistentId); +} + bool AbilityManagerService::IsBackgroundTaskUid(const int uid) { #ifdef BGTASKMGR_CONTINUOUS_TASK_ENABLE @@ -2548,7 +2634,7 @@ int AbilityManagerService::AttachAbilityThread( HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); HILOG_INFO("Attach ability thread."); CHECK_POINTER_AND_RETURN(scheduler, ERR_INVALID_VALUE); - if (!VerificationAllToken(token)) { + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled() && !VerificationAllToken(token)) { return ERR_INVALID_VALUE; } auto abilityRecord = Token::GetAbilityRecordByToken(token); @@ -2582,13 +2668,17 @@ int AbilityManagerService::AttachAbilityThread( } returnCode = dataAbilityManager->AttachAbilityThread(scheduler, token); } else { - int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId(); - auto missionListManager = GetListManagerByUserId(ownerMissionUserId); - if (!missionListManager) { - HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId); - return ERR_INVALID_VALUE; + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + returnCode = uiAbilityManager_->AttachAbilityThread(scheduler, token); + } else { + int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId(); + auto missionListManager = GetListManagerByUserId(ownerMissionUserId); + if (!missionListManager) { + HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId); + return ERR_INVALID_VALUE; + } + returnCode = missionListManager->AttachAbilityThread(scheduler, token); } - returnCode = missionListManager->AttachAbilityThread(scheduler, token); } return returnCode; } @@ -3125,13 +3215,17 @@ void AbilityManagerService::OnAbilityRequestDone(const sptr &toke break; } default: { - int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId(); - auto missionListManager = GetListManagerByUserId(ownerMissionUserId); - if (!missionListManager) { - HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId); - return; + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + uiAbilityManager_->OnAbilityRequestDone(token, state); + } else { + int32_t ownerMissionUserId = abilityRecord->GetOwnerMissionUserId(); + auto missionListManager = GetListManagerByUserId(ownerMissionUserId); + if (!missionListManager) { + HILOG_ERROR("missionListManager is Null. userId=%{public}d", ownerMissionUserId); + return; + } + missionListManager->OnAbilityRequestDone(token, state); } - missionListManager->OnAbilityRequestDone(token, state); break; } } @@ -3774,14 +3868,16 @@ bool AbilityManagerService::VerificationAllToken(const sptr &toke HILOG_INFO("VerificationAllToken."); std::shared_lock lock(managersMutex_); { - HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "VerificationAllToken::SearchMissionListManagers"); - for (auto item: missionListManagers_) { - if (item.second && item.second->GetAbilityRecordByToken(token)) { - return true; - } + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, "VerificationAllToken::SearchMissionListManagers"); + for (auto item: missionListManagers_) { + if (item.second && item.second->GetAbilityRecordByToken(token)) { + return true; + } - if (item.second && item.second->GetAbilityFromTerminateList(token)) { - return true; + if (item.second && item.second->GetAbilityFromTerminateList(token)) { + return true; + } } } } @@ -3917,6 +4013,14 @@ void AbilityManagerService::StartResidentApps() } HILOG_INFO("StartResidentApps GetBundleInfos size: %{public}zu", bundleInfos.size()); + if (Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + for (auto iter = bundleInfos.begin(); iter != bundleInfos.end(); iter++) { + if (iter->name == BUNDLE_NAME_SYSTEMUI) { + bundleInfos.erase(iter); + break; + } + } + } DelayedSingleton::GetInstance()->StartResidentProcessWithMainElement(bundleInfos); if (!bundleInfos.empty()) { @@ -4222,6 +4326,7 @@ bool AbilityManagerService::CheckCallerEligibility(const AppExecFwk::AbilityInfo int AbilityManagerService::StartUser(int userId) { HILOG_DEBUG("%{public}s, userId:%{public}d", __func__, userId); + // 判断是合一服务也放行 if (IPCSkeleton::GetCallingUid() != ACCOUNT_MGR_SERVICE_UID) { HILOG_ERROR("%{public}s: Permission verification failed, not account process", __func__); return CHECK_PERMISSION_FAILED; @@ -4236,6 +4341,7 @@ int AbilityManagerService::StartUser(int userId) int AbilityManagerService::StopUser(int userId, const sptr &callback) { HILOG_DEBUG("%{public}s", __func__); + // 判断是合一服务也放行 if (IPCSkeleton::GetCallingUid() != ACCOUNT_MGR_SERVICE_UID) { HILOG_ERROR("%{public}s: Permission verification failed, not account process", __func__); return CHECK_PERMISSION_FAILED; @@ -4343,7 +4449,9 @@ void AbilityManagerService::ClearUserData(int32_t userId) { HILOG_DEBUG("%{public}s", __func__); std::unique_lock lock(managersMutex_); - missionListManagers_.erase(userId); + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + missionListManagers_.erase(userId); + } connectManagers_.erase(userId); dataAbilityManagers_.erase(userId); pendingWantManagers_.erase(userId); @@ -4578,7 +4686,9 @@ void AbilityManagerService::UserStarted(int32_t userId) { HILOG_INFO("%{public}s", __func__); InitConnectManager(userId, false); - InitMissionListManager(userId, false); + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + InitMissionListManager(userId, false); + } InitDataAbilityManager(userId, false); InitPendWantManager(userId, false); } @@ -4601,7 +4711,7 @@ void AbilityManagerService::SwitchManagers(int32_t userId, bool switchUser) { HILOG_INFO("%{public}s, SwitchManagers:%{public}d-----begin", __func__, userId); InitConnectManager(userId, switchUser); - if (userId != U0_USER_ID) { + if (userId != U0_USER_ID && !Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { InitMissionListManager(userId, switchUser); } InitDataAbilityManager(userId, switchUser); @@ -4611,8 +4721,10 @@ void AbilityManagerService::SwitchManagers(int32_t userId, bool switchUser) void AbilityManagerService::PauseOldUser(int32_t userId) { - HILOG_INFO("%{public}s, PauseOldUser:%{public}d-----begin", __func__, userId); - PauseOldMissionListManager(userId); + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + HILOG_INFO("PauseOldUser:%{public}d-----begin", userId); + PauseOldMissionListManager(userId); + } HILOG_INFO("%{public}s, PauseOldUser:%{public}d-----end", __func__, userId); } @@ -4660,7 +4772,8 @@ void AbilityManagerService::PauseOldConnectManager(int32_t userId) void AbilityManagerService::StartUserApps(int32_t userId, bool isBoot) { HILOG_INFO("StartUserApps, userId:%{public}d, currentUserId:%{public}d", userId, GetUserId()); - if (currentMissionListManager_ && currentMissionListManager_->IsStarted()) { + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled() && currentMissionListManager_ && + currentMissionListManager_->IsStarted()) { HILOG_INFO("missionListManager ResumeManager"); currentMissionListManager_->ResumeManager(); } diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index 69f21a594..a2be1cfa3 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -711,6 +711,54 @@ int AbilityManagerStub::StartAbilityForOptionsInner(MessageParcel &data, Message return NO_ERROR; } +int AbilityManagerStub::StartAbilityByLauncherInner(MessageParcel &data, MessageParcel &reply) +{ + Want *want = data.ReadParcelable(); + if (want == nullptr) { + HILOG_ERROR("want is nullptr"); + return ERR_INVALID_VALUE; + } + StartOptions *startOptions = data.ReadParcelable(); + if (startOptions == nullptr) { + HILOG_ERROR("startOptions is nullptr"); + delete want; + return ERR_INVALID_VALUE; + } + // sptr callerToken = nullptr; + // if (data.ReadBool()) { + // callerToken = data.ReadRemoteObject(); + // } + sptr sessionInfo = nullptr; + if (data.ReadBool()) { + sessionInfo = data.ReadParcelable(); + } + int32_t userId = data.ReadInt32(); + int requestCode = data.ReadInt32(); + int32_t result = StartAbilityByLauncher(*want, *startOptions, sessionInfo, userId, requestCode); + reply.WriteInt32(result); + delete want; + delete startOptions; + return NO_ERROR; +} + +int AbilityManagerStub::GetTokenBySceneSessionInner(MessageParcel &data, MessageParcel &reply) +{ + uint64_t persistentId = data.ReadUint64(); + sptr token = GetTokenBySceneSession(persistentId); + if (token) { + if (!reply.WriteBool(true) || !reply.WriteRemoteObject(token)) { + HILOG_ERROR("flag and token write failed."); + return ERR_INVALID_VALUE; + } + } else { + if (!reply.WriteBool(false)) { + HILOG_ERROR("flag write failed."); + return ERR_INVALID_VALUE; + } + } + return NO_ERROR; +} + int AbilityManagerStub::GetWantSenderInner(MessageParcel &data, MessageParcel &reply) { std::unique_ptr wantSenderInfo(data.ReadParcelable()); diff --git a/services/abilitymgr/src/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index 49e746e1d..d520d5f37 100644 --- a/services/abilitymgr/src/ability_record.cpp +++ b/services/abilitymgr/src/ability_record.cpp @@ -124,9 +124,11 @@ std::shared_ptr Token::GetAbilityRecordByToken(const sptr theToken = iface_cast(token); if (!theToken) { + HILOG_ERROR("ywz fail to iface_cast."); return nullptr; } if (theToken->GetDescriptor() != u"ohos.aafwk.AbilityToken") { + HILOG_ERROR("ywz fail to GetDescriptor."); return nullptr; } @@ -164,7 +166,8 @@ AbilityRecord::~AbilityRecord() } } -std::shared_ptr AbilityRecord::CreateAbilityRecord(const AbilityRequest &abilityRequest) +std::shared_ptr AbilityRecord::CreateAbilityRecord(const AbilityRequest &abilityRequest, + sptr sessionInfo) { std::shared_ptr abilityRecord = std::make_shared( abilityRequest.want, abilityRequest.abilityInfo, abilityRequest.appInfo, abilityRequest.requestCode); @@ -172,6 +175,7 @@ std::shared_ptr AbilityRecord::CreateAbilityRecord(const AbilityR abilityRecord->SetUid(abilityRequest.uid); abilityRecord->SetAppIndex(abilityRequest.want.GetIntParam(DLP_INDEX, 0)); abilityRecord->SetCallerAccessTokenId(abilityRequest.callerAccessTokenId); + abilityRecord->sessionInfo_ = sessionInfo; if (!abilityRecord->Init()) { HILOG_ERROR("failed to init new ability record"); return nullptr; diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index 3bf494d47..53e25e87a 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -1371,6 +1371,10 @@ void MissionListManager::RemoveTerminatingAbility(const std::shared_ptrSetNextAbilityRecord(nullptr); +<<<<<<< HEAD +======= + +>>>>>>> 813faa4e4... support startAbilityByLauncher // 2. if the ability to terminate is background, just background if (!(abilityRecord->IsAbilityState(FOREGROUND) || abilityRecord->IsAbilityState(FOREGROUNDING))) { HILOG_DEBUG("Ability state is %{public}d, just return.", abilityRecord->GetAbilityState()); diff --git a/services/abilitymgr/src/ui_ability_manager.cpp b/services/abilitymgr/src/ui_ability_manager.cpp new file mode 100644 index 000000000..e8435ee65 --- /dev/null +++ b/services/abilitymgr/src/ui_ability_manager.cpp @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2021-2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "ui_ability_manager.h" + +#include "ability_manager_service.h" +#include "ability_util.h" +#include "errors.h" +#include "hilog_wrapper.h" +#include "hitrace_meter.h" +#include "iability_info_callback.h" + +namespace OHOS { +namespace AAFwk { +void UIAbilityManager::Init() +{ +} + +// 所有的ability都是从合一服务调过来的，还需要callerAccessTokenId吗？ +int UIAbilityManager::StartAbility(AbilityRequest &abilityRequest, sptr sessionInfo) +{ + std::lock_guard guard(sessionLock_); + + abilityRequest.callerAccessTokenId = IPCSkeleton::GetCallingTokenID(); + auto isSpecified = (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED); + if (isSpecified) { + EnqueueWaitingAbilityToFront(abilityRequest); + DelayedSingleton::GetInstance()->StartSpecifiedAbility( + abilityRequest.want, abilityRequest.abilityInfo); + return 0; + } + + return StartAbilityLocked(abilityRequest, sessionInfo); +} + +// 还需要再abilityRecord中记录callerAbility吗？ +int UIAbilityManager::StartAbilityLocked(const AbilityRequest &abilityRequest, sptr sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_DEBUG("Start ability locked."); + std::shared_ptr targetAbilityRecord = nullptr; + auto iter = sessionItems_.find(sessionInfo); + if (iter != sessionItems_.end()) { + targetAbilityRecord = iter->second; + } else { + targetAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest, sessionInfo); + } + + if (targetAbilityRecord == nullptr) { + HILOG_ERROR("Failed to get ability record."); + return ERR_INVALID_VALUE; + } + + // handle specified + if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) { + targetAbilityRecord->SetSpecifiedFlag(abilityRequest.specifiedFlag); + } + + if (targetAbilityRecord->IsTerminating()) { + HILOG_ERROR("%{public}s is terminating.", targetAbilityRecord->GetAbilityInfo().name.c_str()); + return ERR_INVALID_VALUE; + } + + if (targetAbilityRecord->GetPendingState() == AbilityState::FOREGROUND) { + HILOG_DEBUG("pending state is FOREGROUND."); + targetAbilityRecord->SetPendingState(AbilityState::FOREGROUND); + if (iter == sessionItems_.end()) { + sessionItems_.emplace(sessionInfo, targetAbilityRecord); + } + return ERR_OK; + } else { + HILOG_DEBUG("pending state is not FOREGROUND."); + targetAbilityRecord->SetPendingState(AbilityState::FOREGROUND); + } + + UpdateAbilityRecordLaunchReason(abilityRequest, targetAbilityRecord); + // 跨设备场景后续支持，单独落需求。从合一服务起存不存在跨设备场景？ + + sptr abilityInfoCallback + = iface_cast(abilityRequest.abilityInfoCallback); + if (abilityInfoCallback != nullptr) { + abilityInfoCallback->NotifyAbilityToken(targetAbilityRecord->GetToken(), abilityRequest.want); + } + + targetAbilityRecord->ProcessForegroundAbility(); + if (iter == sessionItems_.end()) { + sessionItems_.emplace(sessionInfo, targetAbilityRecord); + } + return ERR_OK; +} + +int UIAbilityManager::AttachAbilityThread(const sptr &scheduler, const sptr &token) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + std::lock_guard guard(sessionLock_); + auto&& abilityRecord = Token::GetAbilityRecordByToken(token); + CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); + + HILOG_DEBUG("AbilityMS attach abilityThread, name is %{public}s.", abilityRecord->GetAbilityInfo().name.c_str()); + + auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); + CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler."); + handler->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetEventId()); + + if (!IsContainsAbility(abilityRecord)) { + return ERR_INVALID_VALUE; + } + + abilityRecord->SetScheduler(scheduler); + + // byCall后面单独考虑 + // if (abilityRecord->IsStartedByCall()) { + // if (abilityRecord->GetWant().GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) { + // abilityRecord->SetStartToForeground(true); + // DelayedSingleton::GetInstance()->MoveToForeground(token); + // } else { + // abilityRecord->SetStartToBackground(true); + // MoveToBackgroundTask(abilityRecord); + // } + // return ERR_OK; + // } + + // if (abilityRecord->IsNeedToCallRequest()) { + // abilityRecord->CallRequest(); + // } + + DelayedSingleton::GetInstance()->MoveToForeground(token); + return ERR_OK; +} + +void UIAbilityManager::OnAbilityRequestDone(const sptr &token, int32_t state) const +{ + HILOG_DEBUG("Ability request state %{public}d done.", state); + std::lock_guard guard(sessionLock_); + AppAbilityState abilityState = DelayedSingleton::GetInstance()->ConvertToAppAbilityState(state); + if (abilityState == AppAbilityState::ABILITY_STATE_FOREGROUND) { + // 判断abilityRecord是否在map中 + auto&& abilityRecord = Token::GetAbilityRecordByToken(token); + CHECK_POINTER(abilityRecord); + if (IsContainsAbility(abilityRecord)) { + std::string element = abilityRecord->GetWant().GetElement().GetURI(); + HILOG_DEBUG("Ability is %{public}s, start to foreground.", element.c_str()); + abilityRecord->ForegroundAbility(); + } + } +} + +sptr UIAbilityManager::GetTokenBySceneSession(uint64_t persistentId) +{ + std::lock_guard guard(sessionLock_); + for (auto iter = sessionItems_.begin(); iter != sessionItems_.end(); iter++) { + auto sessionInfo = iter->first; + if (sessionInfo == nullptr) { + continue; + } + if (sessionInfo->persistentId == persistentId) { + if (iter->second != nullptr) { + return iter->second->GetToken(); + } + } + } + return nullptr; +} + +bool UIAbilityManager::IsContainsAbility(std::shared_ptr &abilityRecord) const +{ + std::lock_guard guard(sessionLock_); + for (auto iter = sessionItems_.begin(); iter != sessionItems_.end(); iter++) { + if (iter->second == abilityRecord) { + return true; + } + } + return false; +} + +void UIAbilityManager::EnqueueWaitingAbilityToFront(const AbilityRequest &abilityRequest) +{ + std::lock_guard guard(sessionLock_); + waitingAbilityQueue_.push(abilityRequest); + // std::queue abilityQueue; + // abilityQueue.push(abilityRequest); + // waitingAbilityQueue_.swap(abilityQueue); + // while (!abilityQueue.empty()) { + // AbilityRequest tempAbilityRequest = abilityQueue.front(); + // abilityQueue.pop(); + // waitingAbilityQueue_.push(tempAbilityRequest); + // } +} + +void UIAbilityManager::UpdateAbilityRecordLaunchReason( + const AbilityRequest &abilityRequest, std::shared_ptr &abilityRecord) const +{ + if (abilityRecord == nullptr) { + HILOG_ERROR("input record is nullptr."); + return; + } + + if (abilityRequest.IsContinuation()) { + abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CONTINUATION); + return; + } + + if (abilityRequest.IsAppRecovery() || abilityRecord->GetRecoveryInfo()) { + abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_APP_RECOVERY); + return; + } + + abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_START_ABILITY); + return; +} +} +} diff --git a/services/abilitymgr/src/user_controller.cpp b/services/abilitymgr/src/user_controller.cpp index de1d7cc55..a54fe84df 100644 --- a/services/abilitymgr/src/user_controller.cpp +++ b/services/abilitymgr/src/user_controller.cpp @@ -17,8 +17,10 @@ #include "ability_manager_service.h" #include "hilog_wrapper.h" +#include "in_process_call_wrapper.h" #include "ipc_skeleton.h" #include "os_account_manager_wrapper.h" +#include "session_info.h" #include "task_data_persistence_mgr.h" namespace OHOS { @@ -95,7 +97,7 @@ int32_t UserController::StartUser(int32_t userId, bool isForeground) return -1; } - if (isForeground && GetCurrentUserId() != USER_ID_NO_HEAD) { + if (isForeground && GetCurrentUserId() != USER_ID_NO_HEAD && !Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { // start freezing screen DelayedSingleton::GetInstance()->StartFreezingScreen(); } @@ -120,7 +122,7 @@ int32_t UserController::StartUser(int32_t userId, bool isForeground) SendSystemUserStart(userId); } - if (isForeground) { + if (isForeground && !Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { SendSystemUserCurrent(oldUserId, userId); SendReportUserSwitch(oldUserId, userId, userItem); SendUserSwitchTimeout(oldUserId, userId, userItem); @@ -162,14 +164,16 @@ int32_t UserController::StopUser(int32_t userId) HILOG_ERROR("appScheduler is null"); return -1; } - appScheduler->KillProcessesByUserId(userId); + IN_PROCESS_CALL_WITHOUT_RET(appScheduler->KillProcessesByUserId(userId)); - auto taskDataPersistenceMgr = DelayedSingleton::GetInstance(); - if (!taskDataPersistenceMgr) { - HILOG_ERROR("taskDataPersistenceMgr is null"); - return -1; + if (!Rosen::WindowSceneJudgement::IsWindowSceneEnabled()) { + auto taskDataPersistenceMgr = DelayedSingleton::GetInstance(); + if (!taskDataPersistenceMgr) { + HILOG_ERROR("taskDataPersistenceMgr is null"); + return -1; + } + taskDataPersistenceMgr->RemoveUserDir(userId); } - taskDataPersistenceMgr->RemoveUserDir(userId); auto abilityManagerService = DelayedSingleton::GetInstance(); if (!abilityManagerService) { -- Gitee From b8c432d24d4aa9740079504d17ebc699f4b990ac Mon Sep 17 00:00:00 2001 From: xieqiongyang Date: Mon, 24 Apr 2023 12:21:46 +0000 Subject: [PATCH 2/3] minimizeByBoard Signed-off-by: xieqiongyang Change-Id: Ia11d715d84b7feebf8a890dc65d75fa25ab62803 Signed-off-by: xieqiongyang --- .../include/ability_manager_client.h | 8 + .../include/ability_manager_interface.h | 16 ++ .../include/ability_manager_proxy.h | 8 + .../include/ability_manager_service.h | 9 + .../abilitymgr/include/ability_manager_stub.h | 3 + .../abilitymgr/include/ui_ability_manager.h | 29 ++++ .../abilitymgr/src/ability_manager_client.cpp | 9 + .../abilitymgr/src/ability_manager_proxy.cpp | 36 ++++ .../src/ability_manager_service.cpp | 39 +++++ .../abilitymgr/src/ability_manager_stub.cpp | 14 ++ .../abilitymgr/src/mission_list_manager.cpp | 3 - .../abilitymgr/src/ui_ability_manager.cpp | 155 ++++++++++++++++++ 12 files changed, 326 insertions(+), 3 deletions(-) diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_client.h b/interfaces/inner_api/ability_manager/include/ability_manager_client.h index 167bf4935..4f464f5b3 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_client.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_client.h @@ -300,6 +300,14 @@ public: */ ErrCode MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false); + /** + * MinimizeByBoard, minimize the special ability by board. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MinimizeByBoard(const sptr &sessionInfo); + /** * ConnectAbility, connect session with service ability. * diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h index 3595db28a..547101ca8 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h @@ -322,6 +322,17 @@ public: return 0; }; + /** + * MinimizeByBoard, minimize the special ui ability. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeByBoard(const sptr &sessionInfo) + { + return 0; + }; + /** * ConnectAbility, connect session with service ability. * @@ -1139,6 +1150,11 @@ public: ABILITY_RECOVERY_ENABLE = 3011, QUERY_MISSION_VAILD = 3012, + + START_ABILITY_BY_LAUNCHER = 4000, + GET_TOKEN_BY_SCENE_SESSION = 4001, + MINIMIZE_BY_BOARD = 4002, + }; }; } // namespace AAFwk diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index f7c934776..c53f91c14 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -248,6 +248,14 @@ public: virtual int MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false) override; + /** + * MinimizeByBoard, minimize the special ability by board. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeByBoard(const sptr &sessionInfo) override; + /** * ConnectAbility, connect session with service ability. * diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index 19f1c937a..34bc62611 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -292,6 +292,14 @@ public: virtual int MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false) override; + /** + * MinimizeByBoard, minimize the special ability by board. + * + * @param sessionInfo the extension session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeByBoard(const sptr &sessionInfo) override; + /** * ConnectAbility, connect session with service ability. * @@ -1314,6 +1322,7 @@ private: std::shared_ptr currentMissionListManager_; std::shared_ptr freeInstallManager_; + std::unordered_map> uiAbilityManagers_; std::unique_ptr uiAbilityManager_; std::shared_ptr userController_; diff --git a/services/abilitymgr/include/ability_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h index ce23a5ec7..db12cfed3 100644 --- a/services/abilitymgr/include/ability_manager_stub.h +++ b/services/abilitymgr/include/ability_manager_stub.h @@ -200,6 +200,9 @@ private: int GetTopAbilityInner(MessageParcel &data, MessageParcel &reply); int DumpAbilityInfoDoneInner(MessageParcel &data, MessageParcel &reply); int32_t IsValidMissionIdsInner(MessageParcel &data, MessageParcel &reply); + int StartAbilityByLauncherInner(MessageParcel &data, MessageParcel &reply); + int GetTokenBySceneSessionInner(MessageParcel &data, MessageParcel &reply); + int MinimizeByBoardInner(MessageParcel &data, MessageParcel &reply); }; } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/include/ui_ability_manager.h b/services/abilitymgr/include/ui_ability_manager.h index e9dfacdf7..53acafe6d 100644 --- a/services/abilitymgr/include/ui_ability_manager.h +++ b/services/abilitymgr/include/ui_ability_manager.h @@ -43,12 +43,41 @@ public: void OnAbilityRequestDone(const sptr &token, int32_t state) const; sptr GetTokenBySceneSession(uint64_t persistentId); + /** + * @brief schedule to background + * + * @param abilityRecord the ability to move + */ + void MoveToBackground(const std::shared_ptr &abilityRecord); + + /** + * MinimizeByBoard, minimize the special ability by board. + * + * @param abilityRecord, the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + int MinimizeByBoard(const std::shared_ptr &abilityRecord); + + /** + * GetServiceRecordBySessionInfo. + * + * @param sessionToken, service ability's session token. + * @return Returns AbilityRecord shared_ptr. + */ + std::shared_ptr GetServiceRecordBySessionInfo(const sptr &sessionInfo); + std::shared_ptr GetUIAbilityByTokenFromSeriveMap(const sptr &token); + + private: void UpdateAbilityRecordLaunchReason(const AbilityRequest &abilityRequest, std::shared_ptr &abilityRecord) const; void EnqueueWaitingAbilityToFront(const AbilityRequest &abilityRequest); bool IsContainsAbility(std::shared_ptr &abilityRecord) const; int StartAbilityLocked(const AbilityRequest &abilityRequest, sptr sessionInfo); + int MinimizeByBoardLocked(const std::shared_ptr &abilityRecord); + void PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId); + void CompleteBackground(const std::shared_ptr &abilityRecord); + mutable std::recursive_mutex sessionLock_; std::map, std::shared_ptr> sessionItems_; diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index 29e8a49fa..7ad6444b5 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -290,6 +290,15 @@ ErrCode AbilityManagerClient::MinimizeUIExtensionAbility(const sptr return abms->MinimizeUIExtensionAbility(extensionSessionInfo, fromUser); } +ErrCode AbilityManagerClient::MinimizeByBoard(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetAbilityManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + HILOG_INFO("Minimize ability by board."); + return abms->MinimizeByBoard(sessionInfo); +} + ErrCode AbilityManagerClient::ConnectAbility(const Want &want, const sptr &connect, int32_t userId) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp index 96f6bbeb5..e9264441c 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -1228,6 +1228,42 @@ int AbilityManagerProxy::MinimizeUIExtensionAbility(const sptr &ext return reply.ReadInt32(); } +int AbilityManagerProxy::MinimizeByBoard(const sptr &sessionInfo) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INNER_ERR; + } + if (sessionInfo) { + if (!data.WriteBool(true) || !data.WriteParcelable(sessionInfo)) { + HILOG_ERROR("flag and sessionInfo write failed."); + return INNER_ERR; + } + } else { + if (!data.WriteBool(false)) { + HILOG_ERROR("flag write failed."); + return INNER_ERR; + } + } + + sptr remote = Remote(); + if (remote == nullptr) { + HILOG_ERROR("Remote() is NULL"); + return INNER_ERR; + } + + error = remote->SendRequest(IAbilityManager::MINIMIZE_BY_BOARD, data, reply, option); + if (error != NO_ERROR) { + HILOG_ERROR("Send request error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + int AbilityManagerProxy::StopServiceAbility(const Want &want, int32_t userId) { int error; diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index ded244174..e94e926c7 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -1732,6 +1732,32 @@ int AbilityManagerService::MinimizeUIExtensionAbility(const sptr &e return connectManager->MinimizeUIExtensionAbility(abilityRecord->GetToken(), fromUser); } +int AbilityManagerService::MinimizeByBoard(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_INFO("Minimize ability by board."); + if (sessionInfo->callerToken != nullptr && !VerificationAllToken(sessionInfo->callerToken)) { + return ERR_INVALID_CALLER; + } + auto uiAbilityManager = GetUIAbilityManagerBySessionInfo(sessionInfo); + if (!uiAbilityManager) { + HILOG_ERROR("uiAbilityManager is nullptr."); + return ERR_INVALID_VALUE; + } + auto abilityRecord = uiAbilityManager->GetServiceRecordBySessionInfo(sessionInfo); + CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); + auto type = abilityRecord->GetAbilityInfo().type; + if (type != AppExecFwk::AbilityType::PAGE) { + HILOG_ERROR("Cannot minimize except page ability."); + return ERR_WRONG_INTERFACE_CALL; + } + if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) { + return ERR_WOULD_BLOCK; + } + + return uiAbilityManager->MinimizeByBoard(abilityRecord); +} + int AbilityManagerService::ConnectAbility( const Want &want, const sptr &connect, const sptr &callerToken, int32_t userId) { @@ -3986,6 +4012,19 @@ std::shared_ptr AbilityManagerService::GetConnectManagerB return nullptr; } +std::shared_ptr AbilityManagerService::GetUIAbilityManagerBySessionInfo( + const sptr &sessionInfo) +{ + std::shared_lock lock(managersMutex_); + for (auto item: uiAbilityManagers_) { + if (item.second && item.second->GetServiceRecordBySessionInfo(sessionInfo)) { + return item.second; + } + } + + return nullptr; +} + std::shared_ptr AbilityManagerService::GetDataAbilityManagerByToken( const sptr &token) { diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index a2be1cfa3..9ec781d5e 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -83,6 +83,9 @@ void AbilityManagerStub::FirstStepInit() requestFuncMap_[CONNECT_ABILITY_WITH_TYPE] = &AbilityManagerStub::ConnectAbilityWithTypeInner; requestFuncMap_[ABILITY_RECOVERY] = &AbilityManagerStub::ScheduleRecoverAbilityInner; requestFuncMap_[ABILITY_RECOVERY_ENABLE] = &AbilityManagerStub::EnableRecoverAbilityInner; + requestFuncMap_[START_ABILITY_BY_LAUNCHER] = &AbilityManagerStub::StartAbilityByLauncherInner; + requestFuncMap_[GET_TOKEN_BY_SCENE_SESSION] = &AbilityManagerStub::GetTokenBySceneSessionInner; + requestFuncMap_[MINIMIZE_BY_BOARD] = &AbilityManagerStub::MinimizeByBoardInner; } void AbilityManagerStub::SecondStepInit() @@ -759,6 +762,17 @@ int AbilityManagerStub::GetTokenBySceneSessionInner(MessageParcel &data, Message return NO_ERROR; } +int AbilityManagerStub::MinimizeByBoardInner(MessageParcel &data, MessageParcel &reply) +{ + sptr sessionInfo = nullptr; + if (data.ReadBool()) { + sessionInfo = data.ReadParcelable(); + } + int32_t result = MinimizeByBoard(sessionInfo); + reply.WriteInt32(result); + return NO_ERROR; +} + int AbilityManagerStub::GetWantSenderInner(MessageParcel &data, MessageParcel &reply) { std::unique_ptr wantSenderInfo(data.ReadParcelable()); diff --git a/services/abilitymgr/src/mission_list_manager.cpp b/services/abilitymgr/src/mission_list_manager.cpp index 53e25e87a..410e9fb0b 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -1371,10 +1371,7 @@ void MissionListManager::RemoveTerminatingAbility(const std::shared_ptrSetNextAbilityRecord(nullptr); -<<<<<<< HEAD -======= ->>>>>>> 813faa4e4... support startAbilityByLauncher // 2. if the ability to terminate is background, just background if (!(abilityRecord->IsAbilityState(FOREGROUND) || abilityRecord->IsAbilityState(FOREGROUNDING))) { HILOG_DEBUG("Ability state is %{public}d, just return.", abilityRecord->GetAbilityState()); diff --git a/services/abilitymgr/src/ui_ability_manager.cpp b/services/abilitymgr/src/ui_ability_manager.cpp index e8435ee65..1feafdcb9 100644 --- a/services/abilitymgr/src/ui_ability_manager.cpp +++ b/services/abilitymgr/src/ui_ability_manager.cpp @@ -174,6 +174,161 @@ sptr UIAbilityManager::GetTokenBySceneSession(uint64_t persistent return nullptr; } +std::shared_ptr UIAbilityManager::GetServiceRecordBySessionInfo(const sptr &sessionInfo) +{ + std::lock_guard guard(Lock_); + CHECK_POINTER_AND_RETURN(sessionInfo, nullptr); + sptr sessionToken = sessionInfo->sessionToken; + CHECK_POINTER_AND_RETURN(sessionToken, nullptr); + std::string descriptor = Str16ToStr8(sessionToken->GetDescriptor()); + if (descriptor != "OHOS.ISession") { + HILOG_ERROR("Input token is not a sessionToken, token->GetDescriptor(): %{public}s", + descriptor.c_str()); + return nullptr; + } + + auto IsMatch = [sessionInfo](auto service) { + if (!service.second || !service.second->GetSessionInfo()) { + return false; + } + uint64_t srcPersistentId = service.second->GetSessionInfo()->persistentId; + return srcPersistentId == sessionInfo->persistentId; + }; + auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch); + if (serviceRecord != serviceMap_.end()) { + return serviceRecord->second; + } + return nullptr; +} + +std::shared_ptr UIAbilityManager::GetUIAbilityByTokenFromSeriveMap(const sptr &token) +{ + std::lock_guard guard(Lock_); + auto IsMatch = [token](auto service) { + if (!service.second) { + return false; + } + sptr srcToken = service.second->GetToken(); + return srcToken == token; + }; + auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch); + if (serviceRecord != serviceMap_.end()) { + return serviceRecord->second; + } + return nullptr; +} + +int UIAbilityManager::MinimizeByBoard(const std::shared_ptr &abilityRecord) +{ + HILOG_INFO("Minimize ability by board."); + std::lock_guard guard(Lock_); + return MinimizeByBoardLocked(abilityRecord); +} + +int UIAbilityManager::MinimizeByBoardLocked(const std::shared_ptr &abilityRecord) +{ + if (abilityRecord == nullptr) { + HILOG_ERROR("Minimize ability by board failed, ability record is null."); + return ERR_INVALID_VALUE; + } + HILOG_INFO("MinimizeByBoardLocked called, ability:%{public}s.", abilityRecord->GetAbilityInfo().name.c_str()); + abilityRecord->SetPendingState(AbilityState::BACKGROUND); + if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) { + HILOG_ERROR("Fail to minimize ability by board, ability state is not foreground."); + return ERR_OK; + } + MoveToBackground(abilityRecord); + return ERR_OK; +} + +void UIAbilityManager::MoveToBackground(const std::shared_ptr &abilityRecord) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (abilityRecord == nullptr) { + HILOG_ERROR("Move the ability to background failed, ability record is null."); + return; + } + HILOG_DEBUG("Move the ability to background, ability:%{public}s.", abilityRecord->GetAbilityInfo().name.c_str()); + abilityRecord->SetIsNewWant(false); + + auto self(weak_from_this()); + auto task = [abilityRecord, self]() { + auto selfObj = self.lock(); + if (selfObj == nullptr) { + HILOG_WARN("UIAbilityManager is invalid."); + return; + } + HILOG_ERROR("UIAbilityManager move to background timeout."); + selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG); + selfObj->CompleteBackground(abilityRecord); + }; + abilityRecord->BackgroundAbility(task); +} + +void UIAbilityManager::PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId) +{ + if (ability == nullptr) { + HILOG_ERROR("ability is nullptr"); + return; + } + + AppExecFwk::RunningProcessInfo processInfo = {}; + DelayedSingleton::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo); + if (processInfo.pid_ == 0) { + HILOG_ERROR("error: the ability[%{public}s], app may fork fail or not running.", + ability->GetAbilityInfo().name.data()); + return; + } + std::string msgContent = "ability:" + ability->GetAbilityInfo().name + " "; + switch (msgId) { + case AbilityManagerService::LOAD_TIMEOUT_MSG: + msgContent += "load timeout"; + break; + case AbilityManagerService::ACTIVE_TIMEOUT_MSG: + msgContent += "active timeout"; + break; + case AbilityManagerService::INACTIVE_TIMEOUT_MSG: + msgContent += "inactive timeout"; + break; + case AbilityManagerService::FOREGROUND_TIMEOUT_MSG: + msgContent += "foreground timeout"; + break; + case AbilityManagerService::BACKGROUND_TIMEOUT_MSG: + msgContent += "background timeout"; + break; + case AbilityManagerService::TERMINATE_TIMEOUT_MSG: + msgContent += "terminate timeout"; + break; + default: + return; + } + std::string eventType = "LIFECYCLE_TIMEOUT"; + HiSysEventWrite(OHOS::HiviewDFX::HiSysEvent::Domain::AAFWK, eventType, + OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, + EVENT_KEY_UID, processInfo.uid_, + EVENT_KEY_PID, processInfo.pid_, + EVENT_KEY_PACKAGE_NAME, ability->GetAbilityInfo().bundleName, + EVENT_KEY_PROCESS_NAME, processInfo.processName_, + EVENT_KEY_MESSAGE, msgContent); + + HILOG_WARN("LIFECYCLE_TIMEOUT: uid: %{public}d, pid: %{public}d, bundleName: %{public}s, abilityName: %{public}s," + "msg: %{public}s", processInfo.uid_, processInfo.pid_, ability->GetAbilityInfo().bundleName.c_str(), + ability->GetAbilityInfo().name.c_str(), msgContent.c_str()); +} + +void UIAbilityManager::CompleteBackground(const std::shared_ptr &abilityRecord) +{ + std::lock_guard guard(Lock_); + if (abilityRecord->GetAbilityState() != AbilityState::BACKGROUNDING) { + HILOG_ERROR("Ability state is %{public}d, it can't complete background.", abilityRecord->GetAbilityState()); + return; + } + abilityRecord->SetAbilityState(AbilityState::BACKGROUND); + // send application state to AppMS. + // notify AppMS to update application state. + DelayedSingleton::GetInstance()->MoveToBackground(abilityRecord->GetToken()); +} + bool UIAbilityManager::IsContainsAbility(std::shared_ptr &abilityRecord) const { std::lock_guard guard(sessionLock_); -- Gitee From f4cb7e5cfb62fd7e711d31c83cbb6c037538652e Mon Sep 17 00:00:00 2001 From: xieqiongyang Date: Thu, 27 Apr 2023 12:03:24 +0000 Subject: [PATCH 3/3] closeAbilityByBoard Signed-off-by: xieqiongyang Change-Id: Ib25b11f480dc207149e66bb6d5b3a5a4c2dbdd22 Signed-off-by: xieqiongyang --- .../include/ability_manager_client.h | 8 ++ .../include/ability_manager_interface.h | 12 ++ .../include/ability_manager_proxy.h | 8 ++ .../include/ability_manager_service.h | 9 +- .../abilitymgr/include/ability_manager_stub.h | 1 + .../abilitymgr/include/ui_ability_manager.h | 24 +++- .../abilitymgr/src/ability_manager_client.cpp | 11 +- .../abilitymgr/src/ability_manager_proxy.cpp | 41 ++++++- .../src/ability_manager_service.cpp | 56 +++++---- .../abilitymgr/src/ability_manager_stub.cpp | 12 ++ .../abilitymgr/src/ui_ability_manager.cpp | 106 +++++++++++++----- services/common/include/event_report.h | 2 + 12 files changed, 230 insertions(+), 60 deletions(-) diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_client.h b/interfaces/inner_api/ability_manager/include/ability_manager_client.h index 4f464f5b3..91260ebc8 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_client.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_client.h @@ -239,6 +239,14 @@ public: */ ErrCode TerminateUIExtensionAbility(const sptr &extensionSessionInfo, int resultCode = DEFAULT_INVAL_VALUE, const Want *resultWant = nullptr); + + /** + * CloseAbilityByBoard, close the special ability by board. + * + * @param sessionInfo the session info of the ability to terminate. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode CloseAbilityByBoard(const sptr &sessionInfo); /** * SendResultToAbility with want, return resultWant from ability manager service. diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h index 547101ca8..cf2deb8d7 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h @@ -267,6 +267,17 @@ public: return 0; } + /** + * CloseAbilityByBoard, close the special ability by board. + * + * @param sessionInfo the session info of the ability to terminate. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CloseAbilityByBoard(const sptr &sessionInfo) + { + return 0; + } + /** * SendResultToAbility, send the result to ability. * @@ -1154,6 +1165,7 @@ public: START_ABILITY_BY_LAUNCHER = 4000, GET_TOKEN_BY_SCENE_SESSION = 4001, MINIMIZE_BY_BOARD = 4002, + CLOSE_ABILITY_BY_BOARD = 4003; }; }; diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index c53f91c14..0ba66f91d 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -199,6 +199,14 @@ public: virtual int TerminateUIExtensionAbility(const sptr &extensionSessionInfo, int resultCode, const Want *resultWant) override; + /** + * CloseAbilityByBoard, close the special ability by board. + * + * @param sessionInfo the session info of the ability to terminate. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CloseAbilityByBoard(const sptr &sessionInfo) override; + /** * SendResultToAbility with want, return want from ability manager service.(Only used for dms) * diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h index 34bc62611..b63ca3602 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -243,6 +243,14 @@ public: virtual int TerminateUIExtensionAbility(const sptr &extensionSessionInfo, int resultCode = DEFAULT_INVAL_VALUE, const Want *resultWant = nullptr) override; + /** + * CloseAbilityByBoard, close the special ability by board. + * + * @param sessionInfo the session info of the ability to terminate. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int CloseAbilityByBoard(const sptr &sessionInfo) override; + /** * SendResultToAbility with want, return want from ability manager service. * @@ -1322,7 +1330,6 @@ private: std::shared_ptr currentMissionListManager_; std::shared_ptr freeInstallManager_; - std::unordered_map> uiAbilityManagers_; std::unique_ptr uiAbilityManager_; std::shared_ptr userController_; diff --git a/services/abilitymgr/include/ability_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h index db12cfed3..0800c97bb 100644 --- a/services/abilitymgr/include/ability_manager_stub.h +++ b/services/abilitymgr/include/ability_manager_stub.h @@ -68,6 +68,7 @@ private: void ThirdStepInit(); int TerminateAbilityInner(MessageParcel &data, MessageParcel &reply); int TerminateUIExtensionAbilityInner(MessageParcel &data, MessageParcel &reply); + int CloseAbilityByBoardInner(MessageParcel &data, MessageParcel &reply); int SendResultToAbilityInner(MessageParcel &data, MessageParcel &reply); int TerminateAbilityByCallerInner(MessageParcel &data, MessageParcel &reply); int MinimizeAbilityInner(MessageParcel &data, MessageParcel &reply); diff --git a/services/abilitymgr/include/ui_ability_manager.h b/services/abilitymgr/include/ui_ability_manager.h index 53acafe6d..9edf49154 100644 --- a/services/abilitymgr/include/ui_ability_manager.h +++ b/services/abilitymgr/include/ui_ability_manager.h @@ -44,7 +44,7 @@ public: sptr GetTokenBySceneSession(uint64_t persistentId); /** - * @brief schedule to background + * MoveToBackground, schedule to background * * @param abilityRecord the ability to move */ @@ -59,14 +59,27 @@ public: int MinimizeByBoard(const std::shared_ptr &abilityRecord); /** - * GetServiceRecordBySessionInfo. + * CloseAbilityByBoard, close the special ability by board. + * + * @param abilityRecord, the ability to close. + * @return Returns ERR_OK on success, others on failure. + */ + int CloseAbilityByBoard(const std::shared_ptr &abilityRecord); + + /** + * GetUIAbilityRecordBySessionInfo. * * @param sessionToken, service ability's session token. * @return Returns AbilityRecord shared_ptr. */ - std::shared_ptr GetServiceRecordBySessionInfo(const sptr &sessionInfo); - std::shared_ptr GetUIAbilityByTokenFromSeriveMap(const sptr &token); + std::shared_ptr GetUIAbilityRecordBySessionInfo(const sptr &sessionInfo); + /** + * RemoveAbilityRecordFromSessionItems + * + * @param abilityRecord the ability to remove + */ + void RemoveAbilityRecordFromSessionItems(const std::shared_ptr &abilityRecord); private: void UpdateAbilityRecordLaunchReason(const AbilityRequest &abilityRequest, @@ -75,9 +88,10 @@ private: bool IsContainsAbility(std::shared_ptr &abilityRecord) const; int StartAbilityLocked(const AbilityRequest &abilityRequest, sptr sessionInfo); int MinimizeByBoardLocked(const std::shared_ptr &abilityRecord); + int CloseAbilityByBoardLocked(const std::shared_ptr &abilityRecord); void PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId); void CompleteBackground(const std::shared_ptr &abilityRecord); - + void CloseAbilityByBoardDone(const std::shared_ptr &abilityRecord); mutable std::recursive_mutex sessionLock_; std::map, std::shared_ptr> sessionItems_; diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index 7ad6444b5..685c6ab91 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -272,6 +272,15 @@ ErrCode AbilityManagerClient::CloseAbility(const sptr &token, int return abms->CloseAbility(token, resultCode, resultWant); } +ErrCode AbilityManagerClient::CloseAbilityByBoard(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + auto abms = GetAbilityManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + HILOG_INFO("call"); + return abms->CloseAbilityByBoard(sessionInfo); +} + ErrCode AbilityManagerClient::MinimizeAbility(const sptr &token, bool fromUser) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); @@ -295,7 +304,7 @@ ErrCode AbilityManagerClient::MinimizeByBoard(const sptr &sessionIn HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); auto abms = GetAbilityManager(); CHECK_POINTER_RETURN_NOT_CONNECTED(abms); - HILOG_INFO("Minimize ability by board."); + HILOG_INFO("call"); return abms->MinimizeByBoard(sessionInfo); } diff --git a/services/abilitymgr/src/ability_manager_proxy.cpp b/services/abilitymgr/src/ability_manager_proxy.cpp index e9264441c..86387ec64 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -668,6 +668,43 @@ int AbilityManagerProxy::TerminateUIExtensionAbility(const sptr &ex return reply.ReadInt32(); } +int AbilityManagerProxy::CloseAbilityByBoard(const sptr &sessionInfo) +{ + int error; + MessageParcel data; + MessageParcel reply; + MessageOption option; + + if (!WriteInterfaceToken(data)) { + return INNER_ERR; + } + + if (sessionInfo) { + if (!data.WriteBool(true) || !data.WriteParcelable(sessionInfo)) { + HILOG_ERROR("flag and sessionInfo write failed."); + return INNER_ERR; + } + } else { + if (!data.WriteBool(false)) { + HILOG_ERROR("flag write failed."); + return INNER_ERR; + } + } + + sptr remote = Remote(); + if (remote == nullptr) { + HILOG_ERROR("failed, Remote() is NULL"); + return INNER_ERR; + } + + error = remote->SendRequest(IAbilityManager::CLOSE_ABILITY_BY_BOARD, data, reply, option); + if (error != NO_ERROR) { + HILOG_ERROR("failed, Send request error: %{public}d", error); + return error; + } + return reply.ReadInt32(); +} + int AbilityManagerProxy::SendResultToAbility(int32_t requestCode, int32_t resultCode, Want& resultWant) { int error; @@ -1252,13 +1289,13 @@ int AbilityManagerProxy::MinimizeByBoard(const sptr &sessionInfo) sptr remote = Remote(); if (remote == nullptr) { - HILOG_ERROR("Remote() is NULL"); + HILOG_ERROR("failed, Remote() is NULL"); return INNER_ERR; } error = remote->SendRequest(IAbilityManager::MINIMIZE_BY_BOARD, data, reply, option); if (error != NO_ERROR) { - HILOG_ERROR("Send request error: %{public}d", error); + HILOG_ERROR("failed, Send request error: %{public}d", error); return error; } return reply.ReadInt32(); diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index e94e926c7..3249c92e6 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -1474,6 +1474,35 @@ int AbilityManagerService::TerminateUIExtensionAbility(const sptr & return eventInfo.errCode; } +int AbilityManagerService::CloseAbilityByBoard(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_INFO("call"); + if (!uiAbilityManager_) { + HILOG_ERROR("failed, uiAbilityManager_ is nullptr"); + return ERR_INVALID_VALUE; + } + auto abilityRecord = uiAbilityManager_->GetUIAbilityRecordBySessionInfo(sessionInfo); + CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); + auto type = abilityRecord->GetAbilityInfo().type; + if (type != AppExecFwk::AbilityType::PAGE) { + HILOG_ERROR("failed, cannot close except page ability"); + return ERR_WRONG_INTERFACE_CALL; + } + if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) { + return ERR_WOULD_BLOCK; + } + EventInfo eventInfo; + eventInfo.bundleName = abilityRecord->GetAbilityInfo().bundleName; + eventInfo.abilityName = abilityRecord->GetAbilityInfo().name; + EventReport::SendAbilityEvent(EventName::CLOSE_ABILITY_BY_BOARD, HiSysEventType::BEHAVIOR, eventInfo); + eventInfo.errCode = uiAbilityManager_->CloseAbilityByBoard(abilityRecord); + if (eventInfo.errCode != ERR_OK) { + EventReport::SendAbilityEvent(EventName::CLOSE_ABILITY_BY_BOARD_ERROR, HiSysEventType::FAULT, eventInfo); + } + return eventInfo.errCode; +} + int AbilityManagerService::SendResultToAbility(int32_t requestCode, int32_t resultCode, Want &resultWant) { HILOG_INFO("%{public}s", __func__); @@ -1711,7 +1740,7 @@ int AbilityManagerService::MinimizeUIExtensionAbility(const sptr &e HILOG_ERROR("connectManager is nullptr."); return ERR_INVALID_VALUE; } - auto abilityRecord = connectManager->GetServiceRecordBySessionInfo(extensionSessionInfo); + auto abilityRecord = connectManager->GetUIAbilityRecordBySessionInfo(extensionSessionInfo); CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); int result = JudgeAbilityVisibleControl(abilityRecord->GetAbilityInfo()); if (result != ERR_OK) { @@ -1735,27 +1764,26 @@ int AbilityManagerService::MinimizeUIExtensionAbility(const sptr &e int AbilityManagerService::MinimizeByBoard(const sptr &sessionInfo) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); - HILOG_INFO("Minimize ability by board."); + HILOG_INFO("call"); if (sessionInfo->callerToken != nullptr && !VerificationAllToken(sessionInfo->callerToken)) { return ERR_INVALID_CALLER; } - auto uiAbilityManager = GetUIAbilityManagerBySessionInfo(sessionInfo); - if (!uiAbilityManager) { - HILOG_ERROR("uiAbilityManager is nullptr."); + if (!uiAbilityManager_) { + HILOG_ERROR("failed, uiAbilityManager_ is nullptr"); return ERR_INVALID_VALUE; } - auto abilityRecord = uiAbilityManager->GetServiceRecordBySessionInfo(sessionInfo); + auto abilityRecord = uiAbilityManager_->GetUIAbilityRecordBySessionInfo(sessionInfo); CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); auto type = abilityRecord->GetAbilityInfo().type; if (type != AppExecFwk::AbilityType::PAGE) { - HILOG_ERROR("Cannot minimize except page ability."); + HILOG_ERROR("failed, cannot minimize except page ability"); return ERR_WRONG_INTERFACE_CALL; } if (!IsAbilityControllerForeground(abilityRecord->GetAbilityInfo().bundleName)) { return ERR_WOULD_BLOCK; } - return uiAbilityManager->MinimizeByBoard(abilityRecord); + return uiAbilityManager_->MinimizeByBoard(abilityRecord); } int AbilityManagerService::ConnectAbility( @@ -4012,18 +4040,6 @@ std::shared_ptr AbilityManagerService::GetConnectManagerB return nullptr; } -std::shared_ptr AbilityManagerService::GetUIAbilityManagerBySessionInfo( - const sptr &sessionInfo) -{ - std::shared_lock lock(managersMutex_); - for (auto item: uiAbilityManagers_) { - if (item.second && item.second->GetServiceRecordBySessionInfo(sessionInfo)) { - return item.second; - } - } - - return nullptr; -} std::shared_ptr AbilityManagerService::GetDataAbilityManagerByToken( const sptr &token) diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index 9ec781d5e..7ffdcb65c 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -86,6 +86,7 @@ void AbilityManagerStub::FirstStepInit() requestFuncMap_[START_ABILITY_BY_LAUNCHER] = &AbilityManagerStub::StartAbilityByLauncherInner; requestFuncMap_[GET_TOKEN_BY_SCENE_SESSION] = &AbilityManagerStub::GetTokenBySceneSessionInner; requestFuncMap_[MINIMIZE_BY_BOARD] = &AbilityManagerStub::MinimizeByBoardInner; + requestFuncMap_[CLOSE_ABILITY_BY_BOARD] = &AbilityManagerStub::CloseAbilityByBoardInner; } void AbilityManagerStub::SecondStepInit() @@ -773,6 +774,17 @@ int AbilityManagerStub::MinimizeByBoardInner(MessageParcel &data, MessageParcel return NO_ERROR; } +int AbilityManagerStub::CloseAbilityByBoardInner(MessageParcel &data, MessageParcel &reply) +{ + sptr sessionInfo = nullptr; + if (data.ReadBool()) { + sessionInfo = data.ReadParcelable(); + } + int32_t result = CloseAbilityByBoard(sessionInfo); + reply.WriteInt32(result); + return NO_ERROR; +} + int AbilityManagerStub::GetWantSenderInner(MessageParcel &data, MessageParcel &reply) { std::unique_ptr wantSenderInfo(data.ReadParcelable()); diff --git a/services/abilitymgr/src/ui_ability_manager.cpp b/services/abilitymgr/src/ui_ability_manager.cpp index 1feafdcb9..f2569ea64 100644 --- a/services/abilitymgr/src/ui_ability_manager.cpp +++ b/services/abilitymgr/src/ui_ability_manager.cpp @@ -174,7 +174,7 @@ sptr UIAbilityManager::GetTokenBySceneSession(uint64_t persistent return nullptr; } -std::shared_ptr UIAbilityManager::GetServiceRecordBySessionInfo(const sptr &sessionInfo) +std::shared_ptr UIAbilityManager::GetUIAbilityRecordBySessionInfo(const sptr &sessionInfo) { std::lock_guard guard(Lock_); CHECK_POINTER_AND_RETURN(sessionInfo, nullptr); @@ -182,59 +182,91 @@ std::shared_ptr UIAbilityManager::GetServiceRecordBySessionInfo(c CHECK_POINTER_AND_RETURN(sessionToken, nullptr); std::string descriptor = Str16ToStr8(sessionToken->GetDescriptor()); if (descriptor != "OHOS.ISession") { - HILOG_ERROR("Input token is not a sessionToken, token->GetDescriptor(): %{public}s", + HILOG_ERROR("failed, input token is not a sessionToken, token->GetDescriptor(): %{public}s", descriptor.c_str()); return nullptr; } - auto IsMatch = [sessionInfo](auto service) { - if (!service.second || !service.second->GetSessionInfo()) { + auto IsMatch = [sessionInfo](auto sessionItem) { + if (!sessionItem.first || !sessionItem.first->GetSessionInfo()) { return false; } - uint64_t srcPersistentId = service.second->GetSessionInfo()->persistentId; + uint64_t srcPersistentId = sessionItem.first->GetSessionInfo()->persistentId; return srcPersistentId == sessionInfo->persistentId; }; - auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch); - if (serviceRecord != serviceMap_.end()) { - return serviceRecord->second; + auto sessionItem = std::find_if(sessionItems_.begin(), sessionItems_.end(), IsMatch); + if (sessionItem != sessionItems_.end()) { + return sessionItem->second; } return nullptr; } -std::shared_ptr UIAbilityManager::GetUIAbilityByTokenFromSeriveMap(const sptr &token) +void UIAbilityManager::RemoveAbilityRecordFromSessionItems(const std::shared_ptr &abilityRecord) { - std::lock_guard guard(Lock_); - auto IsMatch = [token](auto service) { - if (!service.second) { - return false; + HILOG_INFO("call"); + std::lock_guard guard(sessionLock_); + for (auto iter = sessionItems_.begin(); iter != sessionItems_.end(); iter++) { + if (iter->second == abilityRecord) { + sessionItems_.erase(iter); + return; } - sptr srcToken = service.second->GetToken(); - return srcToken == token; - }; - auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch); - if (serviceRecord != serviceMap_.end()) { - return serviceRecord->second; } - return nullptr; + HILOG_ERROR("failed"); } int UIAbilityManager::MinimizeByBoard(const std::shared_ptr &abilityRecord) { - HILOG_INFO("Minimize ability by board."); + HILOG_INFO("call"); std::lock_guard guard(Lock_); return MinimizeByBoardLocked(abilityRecord); } +int UIAbilityManager::CloseAbilityByBoard(const std::shared_ptr &abilityRecord) +{ + HILOG_INFO("call"); + std::lock_guard guard(Lock_); + return CloseAbilityByBoardLocked(abilityRecord); +} + +int UIAbilityManager::CloseAbilityByBoardLocked(const std::shared_ptr &abilityRecord) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); + std::string element = abilityRecord->GetWant().GetElement().GetURI(); + HILOG_INFO("call, from ability: %{public}s", element.c_str()); + if (abilityRecord->IsTerminating() && !abilityRecord->IsForeground()) { + HILOG_INFO("ability is on terminating"); + return ERR_OK; + } + abilityRecord->SetTerminatingState(); + if (abilityRecord->IsAbilityState(FOREGROUND) || abilityRecord->IsAbilityState(FOREGROUNDING)) { + HILOG_DEBUG("current ability is active"); + abilityRecord->SetPendingState(AbilityState::BACKGROUND); + MoveToBackground(abilityRecord); + return ERR_OK; + } + + if (abilityRecord->GetAbilityState() == AbilityState::BACKGROUND) { + auto self(shared_from_this()); + auto task = [abilityRecord, self]() { + HILOG_WARN("close ability by board timeout"); + self->CloseAbilityByBoardDone(abilityRecord); + }; + abilityRecord->Terminate(task); + } + return ERR_OK; +} + int UIAbilityManager::MinimizeByBoardLocked(const std::shared_ptr &abilityRecord) { if (abilityRecord == nullptr) { - HILOG_ERROR("Minimize ability by board failed, ability record is null."); + HILOG_ERROR("failed, ability record is null"); return ERR_INVALID_VALUE; } - HILOG_INFO("MinimizeByBoardLocked called, ability:%{public}s.", abilityRecord->GetAbilityInfo().name.c_str()); + HILOG_INFO("call, from abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str()); abilityRecord->SetPendingState(AbilityState::BACKGROUND); if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) { - HILOG_ERROR("Fail to minimize ability by board, ability state is not foreground."); + HILOG_ERROR("failed, ability state is not foreground"); return ERR_OK; } MoveToBackground(abilityRecord); @@ -245,20 +277,18 @@ void UIAbilityManager::MoveToBackground(const std::shared_ptr &ab { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); if (abilityRecord == nullptr) { - HILOG_ERROR("Move the ability to background failed, ability record is null."); + HILOG_ERROR("failed, ability record is null"); return; } - HILOG_DEBUG("Move the ability to background, ability:%{public}s.", abilityRecord->GetAbilityInfo().name.c_str()); abilityRecord->SetIsNewWant(false); - auto self(weak_from_this()); auto task = [abilityRecord, self]() { auto selfObj = self.lock(); if (selfObj == nullptr) { - HILOG_WARN("UIAbilityManager is invalid."); + HILOG_WARN("UIAbilityManager is invalid"); return; } - HILOG_ERROR("UIAbilityManager move to background timeout."); + HILOG_ERROR("UIAbilityManager move to background timeout"); selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG); selfObj->CompleteBackground(abilityRecord); }; @@ -268,14 +298,14 @@ void UIAbilityManager::MoveToBackground(const std::shared_ptr &ab void UIAbilityManager::PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId) { if (ability == nullptr) { - HILOG_ERROR("ability is nullptr"); + HILOG_ERROR("failed, ability is nullptr"); return; } AppExecFwk::RunningProcessInfo processInfo = {}; DelayedSingleton::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo); if (processInfo.pid_ == 0) { - HILOG_ERROR("error: the ability[%{public}s], app may fork fail or not running.", + HILOG_ERROR("failed, error: the ability[%{public}s], app may fork fail or not running.", ability->GetAbilityInfo().name.data()); return; } @@ -329,6 +359,20 @@ void UIAbilityManager::CompleteBackground(const std::shared_ptr & DelayedSingleton::GetInstance()->MoveToBackground(abilityRecord->GetToken()); } +void UIAbilityManager::CloseAbilityByBoardDone(const std::shared_ptr &abilityRecord) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (!abilityRecord->IsAbilityState(AbilityState::TERMINATING)) { + std::string expect = AbilityRecord::ConvertAbilityState(AbilityState::TERMINATING); + std::string actual = AbilityRecord::ConvertAbilityState(abilityRecord->GetAbilityState()); + HILOG_ERROR( + "Transition life state error. expect %{public}s, actual %{public}s", expect.c_str(), actual.c_str()); + return; + } + DelayedSingleton::GetInstance()->TerminateAbility(abilityRecord->GetToken(), false); + RemoveAbilityRecordFromSessionItems(abilityRecord); +} + bool UIAbilityManager::IsContainsAbility(std::shared_ptr &abilityRecord) const { std::lock_guard guard(sessionLock_); diff --git a/services/common/include/event_report.h b/services/common/include/event_report.h index 71f73fbae..0ce4e413a 100644 --- a/services/common/include/event_report.h +++ b/services/common/include/event_report.h @@ -52,11 +52,13 @@ enum class EventName { STOP_EXTENSION_ERROR, CONNECT_SERVICE_ERROR, DISCONNECT_SERVICE_ERROR, + CLOSE_ABILITY_BY_BOARD_ERROR, // ability behavior event START_ABILITY, TERMINATE_ABILITY, CLOSE_ABILITY, + CLOSE_ABILITY_BY_BOARD, ABILITY_ONFOREGROUND, ABILITY_ONBACKGROUND, ABILITY_ONACTIVE, -- Gitee