diff --git a/frameworks/native/ability/native/ability_runtime/js_ability.cpp b/frameworks/native/ability/native/ability_runtime/js_ability.cpp index 28838a7bf030e0e9a4355537b5892eb1c8f92738..85a651d38aa7e97e5519fb26ce65c554bc6ff6ff 100644 --- a/frameworks/native/ability/native/ability_runtime/js_ability.cpp +++ b/frameworks/native/ability/native/ability_runtime/js_ability.cpp @@ -230,6 +230,10 @@ void JsAbility::OnStart(const Want &want, sptr sessionInfo) obj->SetProperty("launchWant", jsWant); obj->SetProperty("lastRequestWant", jsWant); + if (Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) { + AbilityContinuationOrRecover(want); + } + NativeValue *argv[] = { jsWant, CreateJsLaunchParam(nativeEngine, GetLaunchParam()), 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 e0ee75af032645191fecf08539d21de08d74b6b0..9364f9b4518f8dd8b477860bb5f34dd80f6b7125 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_client.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_client.h @@ -311,6 +311,14 @@ public: */ ErrCode MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false); + /** + * MinimizeUIAbilityBySCB, minimize the special ability by scb. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + ErrCode MinimizeUIAbilityBySCB(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 795fc29dc69ff3505c80f3535f3fabcf640eef45..d001229fb795aa87dcbce046b6b56348f9d914da 100644 --- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h +++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h @@ -325,6 +325,17 @@ public: return 0; }; + /** + * MinimizeUIAbilityBySCB, minimize the special ui ability by scb. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeUIAbilityBySCB(const sptr &sessionInfo) + { + return 0; + }; + /** * ConnectAbility, connect session with service ability. * @@ -1162,6 +1173,9 @@ public: START_UI_ABILITY_BY_SCB, + // ipc id for minimize ui ability by scb + MINIMIZE_UI_ABILITY_BY_SCB, + // ipc id for continue ability(1101) START_CONTINUATION = 1101, diff --git a/services/abilitymgr/include/ability_manager_proxy.h b/services/abilitymgr/include/ability_manager_proxy.h index 4e1166bac2b2bbee7d119f370e7b033f7e339bd3..4321392a445f4b2dda910be81784a905ebf04246 100644 --- a/services/abilitymgr/include/ability_manager_proxy.h +++ b/services/abilitymgr/include/ability_manager_proxy.h @@ -253,6 +253,14 @@ public: virtual int MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false) override; + /** + * MinimizeUIAbilityBySCB, minimize the special ability by scb. + * + * @param sessionInfo the session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeUIAbilityBySCB(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 fd5cb065f455cec26631f69a4873249443c6ca94..d9e9f3b2eaac243ce7506293d5126ef84a314cff 100644 --- a/services/abilitymgr/include/ability_manager_service.h +++ b/services/abilitymgr/include/ability_manager_service.h @@ -303,6 +303,14 @@ public: virtual int MinimizeUIExtensionAbility(const sptr &extensionSessionInfo, bool fromUser = false) override; + /** + * MinimizeUIAbilityBySCB, minimize the special ability by scb. + * + * @param sessionInfo the extension session info of the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + virtual int MinimizeUIAbilityBySCB(const sptr &sessionInfo) override; + /** * ConnectAbility, connect session with service ability. * @@ -1354,6 +1362,7 @@ private: std::shared_ptr currentMissionListManager_; std::shared_ptr freeInstallManager_; + std::shared_ptr uiAbilityLifecycleManager_; std::shared_ptr userController_; diff --git a/services/abilitymgr/include/ability_manager_stub.h b/services/abilitymgr/include/ability_manager_stub.h index c369ca06d3aaed9cb0bb6e0f25a5d6dadafd3a97..b40c167c592b26a1dfe3168a537523976955aa51 100644 --- a/services/abilitymgr/include/ability_manager_stub.h +++ b/services/abilitymgr/include/ability_manager_stub.h @@ -72,6 +72,7 @@ private: int TerminateAbilityByCallerInner(MessageParcel &data, MessageParcel &reply); int MinimizeAbilityInner(MessageParcel &data, MessageParcel &reply); int MinimizeUIExtensionAbilityInner(MessageParcel &data, MessageParcel &reply); + int MinimizeUIAbilityBySCBInner(MessageParcel &data, MessageParcel &reply); int AttachAbilityThreadInner(MessageParcel &data, MessageParcel &reply); int AbilityTransitionDoneInner(MessageParcel &data, MessageParcel &reply); int ScheduleConnectAbilityDoneInner(MessageParcel &data, MessageParcel &reply); diff --git a/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h b/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h index 11bc5d2d6838a2a43c515366c402b69025494cc8..c44aac8ab1e54e534525018876321c9ec9ff758a 100644 --- a/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h +++ b/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h @@ -72,6 +72,21 @@ public: */ bool IsContainsAbility(const sptr &token) const; + /** + * MinimizeUIAbility, minimize the special ability by board. + * + * @param abilityRecord, the ability to minimize. + * @return Returns ERR_OK on success, others on failure. + */ + int MinimizeUIAbility(const std::shared_ptr &abilityRecord); + + /** + * GetServiceRecordBySessionInfo. + * + * @param sessionToken, service ability's session token. + * @return Returns AbilityRecord shared_ptr. + */ + std::shared_ptr GetUIAbilityRecordBySessionInfo(const sptr &sessionInfo); private: std::shared_ptr GetAbilityRecordByToken(const sptr &token) const; void UpdateAbilityRecordLaunchReason(const AbilityRequest &abilityRequest, @@ -88,10 +103,12 @@ private: AbilityState state = AbilityState::INITIAL); void HandleTimeoutAndResumeAbility(const std::shared_ptr &ability, AbilityState state = AbilityState::INITIAL); - void MoveToBackgroundTask(const std::shared_ptr &abilityRecord); + void MoveToBackground(const std::shared_ptr &abilityRecord); + void CompleteBackground(const std::shared_ptr &abilityRecord); + void PrintTimeOutLog(const std::shared_ptr &ability, uint32_t msgId); mutable std::recursive_mutex sessionLock_; - std::map, std::shared_ptr> sessionAbilityMap_; + std::map> sessionAbilityMap_; }; } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/src/ability_manager_client.cpp b/services/abilitymgr/src/ability_manager_client.cpp index 8c9d25d1a7858b7b4a5751864c3569329a4f041c..0735d4c9bfee5f606d552298768db52dfce6f1eb 100644 --- a/services/abilitymgr/src/ability_manager_client.cpp +++ b/services/abilitymgr/src/ability_manager_client.cpp @@ -279,6 +279,19 @@ ErrCode AbilityManagerClient::MinimizeUIExtensionAbility(const sptr return abms->MinimizeUIExtensionAbility(extensionSessionInfo, fromUser); } +ErrCode AbilityManagerClient::MinimizeUIAbilityBySCB(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (sessionInfo == nullptr) { + HILOG_ERROR("failed, sessionInfo is nullptr"); + return ERR_INVALID_VALUE; + } + auto abms = GetAbilityManager(); + CHECK_POINTER_RETURN_NOT_CONNECTED(abms); + HILOG_DEBUG("call"); + return abms->MinimizeUIAbilityBySCB(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 6c826366f8ee26e714f140d8ab4e3ad87f47490e..ba4800660d19667ce90edfdc45ce220e5a8e60da 100644 --- a/services/abilitymgr/src/ability_manager_proxy.cpp +++ b/services/abilitymgr/src/ability_manager_proxy.cpp @@ -1238,6 +1238,42 @@ int AbilityManagerProxy::MinimizeUIExtensionAbility(const sptr &ext return reply.ReadInt32(); } +int AbilityManagerProxy::MinimizeUIAbilityBySCB(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_UI_ABILITY_BY_SCB, 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, const sptr &token) { int error; diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index 886b5208417f6ceacf5a39d2bddaa809da0c7e9a..8df6c232b4ddd825e822b710f2e3adb481c65e39 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -1842,6 +1842,41 @@ int AbilityManagerService::MinimizeUIExtensionAbility(const sptr &e return connectManager->MinimizeUIExtensionAbility(abilityRecord->GetToken(), fromUser); } +int AbilityManagerService::MinimizeUIAbilityBySCB(const sptr &sessionInfo) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + HILOG_DEBUG("call"); + if (sessionInfo == nullptr || sessionInfo->sessionToken == nullptr) { + HILOG_ERROR("sessionInfo is nullptr"); + return ERR_INVALID_VALUE; + } + + if (!CheckCallingTokenId(BUNDLE_NAME_SCENEBOARD, U0_USER_ID)) { + HILOG_ERROR("Not sceneboard called, not allowed."); + return ERR_WRONG_INTERFACE_CALL; + } + + if (sessionInfo->callerToken != nullptr && !VerificationAllToken(sessionInfo->callerToken)) { + return ERR_INVALID_CALLER; + } + if (!uiAbilityLifecycleManager_) { + HILOG_ERROR("failed, uiAbilityLifecycleManager is nullptr"); + return ERR_INVALID_VALUE; + } + auto abilityRecord = uiAbilityLifecycleManager_->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 uiAbilityLifecycleManager_->MinimizeUIAbility(abilityRecord); +} + int AbilityManagerService::ConnectAbility( const Want &want, const sptr &connect, const sptr &callerToken, int32_t userId) { diff --git a/services/abilitymgr/src/ability_manager_stub.cpp b/services/abilitymgr/src/ability_manager_stub.cpp index c427afe96d9bf6bbd17478b46f670ca2e54f5c4d..9ff7fb9af76392071f5d79e97cb3b0ca54092b55 100644 --- a/services/abilitymgr/src/ability_manager_stub.cpp +++ b/services/abilitymgr/src/ability_manager_stub.cpp @@ -83,6 +83,7 @@ void AbilityManagerStub::FirstStepInit() requestFuncMap_[CONNECT_ABILITY_WITH_TYPE] = &AbilityManagerStub::ConnectAbilityWithTypeInner; requestFuncMap_[ABILITY_RECOVERY] = &AbilityManagerStub::ScheduleRecoverAbilityInner; requestFuncMap_[ABILITY_RECOVERY_ENABLE] = &AbilityManagerStub::EnableRecoverAbilityInner; + requestFuncMap_[MINIMIZE_UI_ABILITY_BY_SCB] = &AbilityManagerStub::MinimizeUIAbilityBySCBInner; } void AbilityManagerStub::SecondStepInit() @@ -288,6 +289,17 @@ int AbilityManagerStub::MinimizeUIExtensionAbilityInner(MessageParcel &data, Mes return NO_ERROR; } +int AbilityManagerStub::MinimizeUIAbilityBySCBInner(MessageParcel &data, MessageParcel &reply) +{ + sptr sessionInfo = nullptr; + if (data.ReadBool()) { + sessionInfo = data.ReadParcelable(); + } + int32_t result = MinimizeUIAbilityBySCB(sessionInfo); + reply.WriteInt32(result); + return NO_ERROR; +} + int AbilityManagerStub::AttachAbilityThreadInner(MessageParcel &data, MessageParcel &reply) { auto scheduler = iface_cast(data.ReadRemoteObject()); diff --git a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp index dd6e15eccb3c7112bec2cf57b83d65aa66a46468..d03b30b7101e07549244d3e832b747a470f782fc 100644 --- a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp +++ b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp @@ -24,6 +24,13 @@ namespace OHOS { namespace AAFwk { +namespace { +constexpr char EVENT_KEY_UID[] = "UID"; +constexpr char EVENT_KEY_PID[] = "PID"; +constexpr char EVENT_KEY_MESSAGE[] = "MSG"; +constexpr char EVENT_KEY_PACKAGE_NAME[] = "PACKAGE_NAME"; +constexpr char EVENT_KEY_PROCESS_NAME[] = "PROCESS_NAME"; +} int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sptr sessionInfo) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); @@ -33,20 +40,20 @@ int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sp HILOG_ERROR("sessionInfo is invalid."); return ERR_INVALID_VALUE; } - // for uri permission, go to optimize - abilityRequest.callerAccessTokenId = IPCSkeleton::GetCallingTokenID(); + auto descriptor = Str16ToStr8(sessionInfo->sessionToken->GetDescriptor()); + if (descriptor != "OHOS.ISession") { + HILOG_ERROR("token's Descriptor: %{public}s", descriptor.c_str()); + return ERR_INVALID_VALUE; + } + std::shared_ptr uiAbilityRecord = nullptr; - auto iter = sessionAbilityMap_.find(sessionInfo->sessionToken); + auto iter = sessionAbilityMap_.find(sessionInfo->persistentId); if (iter != sessionAbilityMap_.end()) { uiAbilityRecord = iter->second; } else { uiAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest, sessionInfo); } - - if (uiAbilityRecord == nullptr) { - HILOG_ERROR("Failed to get ability record."); - return ERR_INVALID_VALUE; - } + CHECK_POINTER_AND_RETURN(uiAbilityRecord, ERR_INVALID_VALUE); if (uiAbilityRecord->IsTerminating()) { HILOG_ERROR("%{public}s is terminating.", uiAbilityRecord->GetAbilityInfo().name.c_str()); @@ -57,7 +64,7 @@ int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sp HILOG_DEBUG("pending state is FOREGROUND."); uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND); if (iter == sessionAbilityMap_.end()) { - sessionAbilityMap_.emplace(sessionInfo->sessionToken, uiAbilityRecord); + sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord); } return ERR_OK; } else { @@ -74,7 +81,7 @@ int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sp uiAbilityRecord->ProcessForegroundAbility(); if (iter == sessionAbilityMap_.end()) { - sessionAbilityMap_.emplace(sessionInfo->sessionToken, uiAbilityRecord); + sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord); } return ERR_OK; } @@ -211,7 +218,22 @@ int UIAbilityLifecycleManager::DispatchForeground(const std::shared_ptr &abilityRecord) { - return 0; + auto handler = DelayedSingleton::GetInstance()->GetEventHandler(); + CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler."); + CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE); + + if (!abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING)) { + HILOG_ERROR("Ability transition life state error. actual %{public}d", abilityRecord->GetAbilityState()); + return ERR_INVALID_VALUE; + } + + // remove background timeout task. + handler->RemoveTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId())); + auto self(shared_from_this()); + auto task = [self, abilityRecord]() { self->CompleteBackground(abilityRecord); }; + handler->PostTask(task); + + return ERR_OK; } int UIAbilityLifecycleManager::DispatchTerminate(const std::shared_ptr &abilityRecord) @@ -233,7 +255,7 @@ void UIAbilityLifecycleManager::CompleteForegroundSuccess(const std::shared_ptr< if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) { abilityRecord->SetMinimizeReason(true); - MoveToBackgroundTask(abilityRecord); + MoveToBackground(abilityRecord); } else if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) { HILOG_DEBUG("not continuous startup."); abilityRecord->SetPendingState(AbilityState::INITIAL); @@ -304,8 +326,6 @@ void UIAbilityLifecycleManager::HandleTimeoutAndResumeAbility(const std::shared_ } } -void UIAbilityLifecycleManager::MoveToBackgroundTask(const std::shared_ptr &abilityRecord) {} - std::shared_ptr UIAbilityLifecycleManager::GetAbilityRecordByToken(const sptr &token) const { @@ -369,5 +389,138 @@ void UIAbilityLifecycleManager::UpdateAbilityRecordLaunchReason( abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_START_ABILITY); return; } + +std::shared_ptr UIAbilityLifecycleManager::GetUIAbilityRecordBySessionInfo( + const sptr &sessionInfo) +{ + std::lock_guard guard(sessionLock_); + 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 iter = sessionAbilityMap_.find(sessionInfo->persistentId); + if (iter != sessionAbilityMap_.end()) { + return iter->second; + } + return nullptr; +} + +int UIAbilityLifecycleManager::MinimizeUIAbility(const std::shared_ptr &abilityRecord) +{ + HILOG_DEBUG("call"); + std::lock_guard guard(sessionLock_); + if (abilityRecord == nullptr) { + HILOG_ERROR("ability record is null"); + return ERR_INVALID_VALUE; + } + HILOG_INFO("abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str()); + abilityRecord->SetPendingState(AbilityState::BACKGROUND); + if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) { + HILOG_ERROR("ability state is not foreground"); + return ERR_OK; + } + MoveToBackground(abilityRecord); + return ERR_OK; +} + +void UIAbilityLifecycleManager::MoveToBackground(const std::shared_ptr &abilityRecord) +{ + HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (abilityRecord == nullptr) { + HILOG_ERROR("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("UIAbilityLifecycleManager is invalid"); + return; + } + HILOG_ERROR("UIAbilityLifecycleManager move to background timeout"); + selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG); + selfObj->CompleteBackground(abilityRecord); + }; + abilityRecord->BackgroundAbility(task); +} + +void UIAbilityLifecycleManager::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 UIAbilityLifecycleManager::CompleteBackground(const std::shared_ptr &abilityRecord) +{ + std::lock_guard guard(sessionLock_); + if (abilityRecord->GetAbilityState() != AbilityState::BACKGROUNDING) { + HILOG_ERROR("failed, 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()); + if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) { + DelayedSingleton::GetInstance()->MoveToForeground(abilityRecord->GetToken()); + } else if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) { + HILOG_DEBUG("not continuous startup."); + abilityRecord->SetPendingState(AbilityState::INITIAL); + } +} + } // namespace AAFwk } // namespace OHOS \ No newline at end of file