diff --git a/frameworks/native/ability/native/ability.cpp b/frameworks/native/ability/native/ability.cpp index 714968fede7325d09284dbbf6bb8159da349a3a9..6e56382128da0f3093305758dee22161af3676b6 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 ba44f321f50060835148c60991a6ec3e6a621868..c1c8bee5102f6ff0ff374b4a8ee182a987213457 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 c581c62484a372df7d36a6dde5c6de8186979f70..1f35d865056c5539f81f437b0d170080f470ee9e 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 5634277d2c67abcc7accf68eb8283cb9d632681d..926f9824dfc633f67e209f0253748698c103984b 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 505f3e1df194d5520c0fbf91c1d8005d2a9f4f04..b7dac1f89a7e97446059db391c791adf3669c8c7 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 605fc5542fea256576793374283179e8e4c43091..91260ebc80ac593b7b2e6dda740a98a1d888f1c3 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. @@ -300,6 +308,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. * @@ -616,6 +632,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 19232ae3cb3328fa0324984918f26ae5b365d76a..cf2deb8d78d7152be2c3d30d0f718dc48e256418 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. * @@ -256,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. * @@ -311,6 +333,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. * @@ -1128,6 +1161,12 @@ public: ABILITY_RECOVERY_ENABLE = 3011, QUERY_MISSION_VAILD = 3012, + + START_ABILITY_BY_LAUNCHER = 4000, + GET_TOKEN_BY_SCENE_SESSION = 4001, + MINIMIZE_BY_BOARD = 4002, + CLOSE_ABILITY_BY_BOARD = 4003; + }; }; } // namespace AAFwk diff --git a/services/abilitymgr/abilitymgr.gni b/services/abilitymgr/abilitymgr.gni index 1f69c84237429526fce8947364b553a4fe207284..ad7a4048c5b045acd563fbc53c6876137d384fe3 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 7b112c141b3e3ac333b2ddb2a643432fb2eab64d..0ba66f91d9fb03bad16e972d348eb5d13258a69f 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. * @@ -193,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) * @@ -242,6 +256,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 bd8c29c4f01581f9985c10fce0ab6cd22b4dca51..b63ca36026ef7546674965a035b08efb4cd96433 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. * @@ -236,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. * @@ -285,6 +300,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. * @@ -1307,6 +1330,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_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h index ce23a5ec71ace6c9851cf80e0cec4586a3aff1e7..0800c97bbe77df11df0aa6c9ce355ecfc587ca4d 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); @@ -200,6 +201,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/ability_record.h b/services/abilitymgr/include/ability_record.h index 74603a4882d2ed489ee8823de76e37ce49bab163..6745fe9d201906bbba884771cf8989017703651a 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 0000000000000000000000000000000000000000..9edf4915435399284433c9f57696c1d8d87e40ed --- /dev/null +++ b/services/abilitymgr/include/ui_ability_manager.h @@ -0,0 +1,102 @@ +/* + * 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); + + /** + * MoveToBackground, 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); + + /** + * 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 GetUIAbilityRecordBySessionInfo(const sptr &sessionInfo); + + /** + * RemoveAbilityRecordFromSessionItems + * + * @param abilityRecord the ability to remove + */ + void RemoveAbilityRecordFromSessionItems(const std::shared_ptr &abilityRecord); + +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); + 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_; + 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 5e5366ee012b48566bf739a4a8bdfbe6517395ff..685c6ab916f2f90cc370915bffb34d7d02857ecd 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(); @@ -248,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__); @@ -266,6 +299,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("call"); + 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 516738d98846b31e792c4b525e24f16648b18ebf..86387ec64394251042e03e294cd0229a0b6cb150 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) { @@ -585,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; @@ -1145,6 +1265,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("failed, Remote() is NULL"); + return INNER_ERR; + } + + error = remote->SendRequest(IAbilityManager::MINIMIZE_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::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 b85a3fcf09961699f7b87ac71da98656c6cf4dff..3249c92e6506f422000b0090d4f8b7171d9fd6b2 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 @@ -1388,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__); @@ -1625,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) { @@ -1646,6 +1761,31 @@ 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("call"); + if (sessionInfo->callerToken != nullptr && !VerificationAllToken(sessionInfo->callerToken)) { + return ERR_INVALID_CALLER; + } + 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 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) { @@ -2548,7 +2688,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 +2722,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 +3269,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 +3922,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; + } } } } @@ -3890,6 +4040,7 @@ std::shared_ptr AbilityManagerService::GetConnectManagerB return nullptr; } + std::shared_ptr AbilityManagerService::GetDataAbilityManagerByToken( const sptr &token) { @@ -3917,6 +4068,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 +4381,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 +4396,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 +4504,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 +4741,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 +4766,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 +4776,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 +4827,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 69f21a5949e84fe23d137bb5d6160d713038cb54..7ffdcb65c1cf157711731b39e8187fbef19b6257 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -83,6 +83,10 @@ 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; + requestFuncMap_[CLOSE_ABILITY_BY_BOARD] = &AbilityManagerStub::CloseAbilityByBoardInner; } void AbilityManagerStub::SecondStepInit() @@ -711,6 +715,76 @@ 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::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::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/ability_record.cpp b/services/abilitymgr/src/ability_record.cpp index 49e746e1d84ccd8528eb9aaafe0a1133e1b28eaa..d520d5f375ec63e4865de64a5ef7c4b3a34b23b0 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 3bf494d474398ece69bb36998a0bbea423bc358e..410e9fb0b03a47b5a48336cb30a282e7f6c5ee5a 100644 --- a/services/abilitymgr/src/mission_list_manager.cpp +++ b/services/abilitymgr/src/mission_list_manager.cpp @@ -1371,6 +1371,7 @@ void MissionListManager::RemoveTerminatingAbility(const std::shared_ptrSetNextAbilityRecord(nullptr); + // 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 0000000000000000000000000000000000000000..f2569ea64f5c359206511fadd39e58c8c5ef8d75 --- /dev/null +++ b/services/abilitymgr/src/ui_ability_manager.cpp @@ -0,0 +1,423 @@ +/* + * 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; +} + +std::shared_ptr UIAbilityManager::GetUIAbilityRecordBySessionInfo(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("failed, input token is not a sessionToken, token->GetDescriptor(): %{public}s", + descriptor.c_str()); + return nullptr; + } + + auto IsMatch = [sessionInfo](auto sessionItem) { + if (!sessionItem.first || !sessionItem.first->GetSessionInfo()) { + return false; + } + uint64_t srcPersistentId = sessionItem.first->GetSessionInfo()->persistentId; + return srcPersistentId == sessionInfo->persistentId; + }; + auto sessionItem = std::find_if(sessionItems_.begin(), sessionItems_.end(), IsMatch); + if (sessionItem != sessionItems_.end()) { + return sessionItem->second; + } + return nullptr; +} + +void UIAbilityManager::RemoveAbilityRecordFromSessionItems(const std::shared_ptr &abilityRecord) +{ + 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; + } + } + HILOG_ERROR("failed"); +} + +int UIAbilityManager::MinimizeByBoard(const std::shared_ptr &abilityRecord) +{ + 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("failed, ability record is null"); + return ERR_INVALID_VALUE; + } + HILOG_INFO("call, from abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str()); + abilityRecord->SetPendingState(AbilityState::BACKGROUND); + if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) { + HILOG_ERROR("failed, 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("failed, ability record is null"); + return; + } + 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("failed, ability is nullptr"); + return; + } + + AppExecFwk::RunningProcessInfo processInfo = {}; + DelayedSingleton::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo); + if (processInfo.pid_ == 0) { + HILOG_ERROR("failed, 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()); +} + +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_); + 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 de1d7cc55de82899ec28a63608cd4f8105368079..a54fe84dfeb6838db99f7eaa6674330cf986efec 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) { diff --git a/services/common/include/event_report.h b/services/common/include/event_report.h index 71f73fbae06ceb8821cf417dcb47effc32737478..0ce4e413aa120f09113f055f5b45ace41b4dab88 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,