1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "scene_board/ui_ability_lifecycle_manager.h"
17
18 #include "ability_manager_service.h"
19 #include "ability_running_info.h"
20 #include "ability_util.h"
21 #include "appfreeze_manager.h"
22 #include "app_exit_reason_data_manager.h"
23 #include "errors.h"
24 #include "hilog_wrapper.h"
25 #include "hitrace_meter.h"
26 #include "iability_info_callback.h"
27 #include "mission_info.h"
28 #include "session_info.h"
29
30 namespace OHOS {
31 using AbilityRuntime::FreezeUtil;
32 namespace AAFwk {
33 namespace {
34 constexpr char EVENT_KEY_UID[] = "UID";
35 constexpr char EVENT_KEY_PID[] = "PID";
36 constexpr char EVENT_KEY_MESSAGE[] = "MSG";
37 constexpr char EVENT_KEY_PACKAGE_NAME[] = "PACKAGE_NAME";
38 constexpr char EVENT_KEY_PROCESS_NAME[] = "PROCESS_NAME";
39 const std::string DLP_INDEX = "ohos.dlp.params.index";
40 constexpr int32_t PREPARE_TERMINATE_TIMEOUT_MULTIPLE = 10;
41 const std::string PARAM_MISSION_AFFINITY_KEY = "ohos.anco.param.missionAffinity";
42 const std::string DMS_SRC_NETWORK_ID = "dmsSrcNetworkId";
43 const std::string DMS_MISSION_ID = "dmsMissionId";
44 const int DEFAULT_DMS_MISSION_ID = -1;
45 const std::string PARAM_SPECIFIED_PROCESS_FLAG = "ohoSpecifiedProcessFlag";
46 #ifdef SUPPORT_ASAN
47 const int KILL_TIMEOUT_MULTIPLE = 45;
48 #else
49 const int KILL_TIMEOUT_MULTIPLE = 3;
50 #endif
51 constexpr int32_t DEFAULT_USER_ID = 0;
52 const std::unordered_map<uint32_t, FreezeUtil::TimeoutState> stateMap = {
53 { AbilityManagerService::LOAD_TIMEOUT_MSG, FreezeUtil::TimeoutState::LOAD },
54 { AbilityManagerService::FOREGROUND_TIMEOUT_MSG, FreezeUtil::TimeoutState::FOREGROUND },
55 { AbilityManagerService::BACKGROUND_TIMEOUT_MSG, FreezeUtil::TimeoutState::BACKGROUND }
56 };
57
__anon08a393e30202(const sptr<Token> &token, FreezeUtil::TimeoutState state) 58 auto g_deleteLifecycleEventTask = [](const sptr<Token> &token, FreezeUtil::TimeoutState state) {
59 CHECK_POINTER_LOG(token, "token is nullptr.");
60 FreezeUtil::LifecycleFlow flow = { token->AsObject(), state };
61 FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
62 };
63 }
64
StartUIAbility(AbilityRequest & abilityRequest,sptr<SessionInfo> sessionInfo)65 int UIAbilityLifecycleManager::StartUIAbility(AbilityRequest &abilityRequest, sptr<SessionInfo> sessionInfo)
66 {
67 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
68 std::lock_guard<ffrt::mutex> guard(sessionLock_);
69 if (!CheckSessionInfo(sessionInfo)) {
70 HILOG_ERROR("sessionInfo is invalid.");
71 return ERR_INVALID_VALUE;
72 }
73 abilityRequest.sessionInfo = sessionInfo;
74
75 HILOG_INFO("session id: %{public}d. bundle: %{public}s, ability: %{public}s", sessionInfo->persistentId,
76 abilityRequest.abilityInfo.bundleName.c_str(), abilityRequest.abilityInfo.name.c_str());
77 std::shared_ptr<AbilityRecord> uiAbilityRecord = nullptr;
78 auto iter = sessionAbilityMap_.find(sessionInfo->persistentId);
79 if (iter != sessionAbilityMap_.end()) {
80 HILOG_INFO("isNewWant: %{public}d.", sessionInfo->isNewWant);
81 uiAbilityRecord = iter->second;
82 uiAbilityRecord->SetIsNewWant(sessionInfo->isNewWant);
83 if (sessionInfo->isNewWant) {
84 uiAbilityRecord->SetWant(abilityRequest.want);
85 }
86 } else {
87 uiAbilityRecord = CreateAbilityRecord(abilityRequest, sessionInfo);
88 }
89 CHECK_POINTER_AND_RETURN(uiAbilityRecord, ERR_INVALID_VALUE);
90
91 if (uiAbilityRecord->GetPendingState() == AbilityState::FOREGROUND) {
92 HILOG_DEBUG("pending state is FOREGROUND.");
93 uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND);
94 return ERR_OK;
95 } else {
96 HILOG_DEBUG("pending state is not FOREGROUND.");
97 uiAbilityRecord->SetPendingState(AbilityState::FOREGROUND);
98 if (uiAbilityRecord->IsLoading()) {
99 HILOG_INFO("ability: %{public}s is loading.", abilityRequest.abilityInfo.name.c_str());
100 return ERR_OK;
101 }
102 }
103 if (iter == sessionAbilityMap_.end()) {
104 sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord);
105 }
106
107 UpdateAbilityRecordLaunchReason(abilityRequest, uiAbilityRecord);
108 NotifyAbilityToken(uiAbilityRecord->GetToken(), abilityRequest);
109 AddCallerRecord(abilityRequest, sessionInfo, uiAbilityRecord);
110 uiAbilityRecord->ProcessForegroundAbility(sessionInfo->callingTokenId);
111 CheckSpecified(abilityRequest, uiAbilityRecord);
112 SendKeyEvent(abilityRequest);
113 return ERR_OK;
114 }
115
CheckSessionInfo(sptr<SessionInfo> sessionInfo) const116 bool UIAbilityLifecycleManager::CheckSessionInfo(sptr<SessionInfo> sessionInfo) const
117 {
118 if (sessionInfo == nullptr || sessionInfo->sessionToken == nullptr) {
119 HILOG_ERROR("sessionInfo is invalid.");
120 return false;
121 }
122 auto sessionToken = iface_cast<Rosen::ISession>(sessionInfo->sessionToken);
123 auto descriptor = Str16ToStr8(sessionToken->GetDescriptor());
124 if (descriptor != "OHOS.ISession") {
125 HILOG_ERROR("token's Descriptor: %{public}s", descriptor.c_str());
126 return false;
127 }
128 return true;
129 }
130
CreateAbilityRecord(AbilityRequest & abilityRequest,sptr<SessionInfo> sessionInfo) const131 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManager::CreateAbilityRecord(AbilityRequest &abilityRequest,
132 sptr<SessionInfo> sessionInfo) const
133 {
134 if (sessionInfo->startSetting != nullptr) {
135 HILOG_DEBUG("startSetting is valid.");
136 abilityRequest.startSetting = sessionInfo->startSetting;
137 }
138 auto uiAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
139 if (uiAbilityRecord == nullptr) {
140 HILOG_ERROR("uiAbilityRecord is invalid.");
141 return nullptr;
142 }
143 HILOG_DEBUG("user id: %{public}d.", sessionInfo->userId);
144 uiAbilityRecord->SetOwnerMissionUserId(sessionInfo->userId);
145 SetRevicerInfo(abilityRequest, uiAbilityRecord);
146 SetLastExitReason(uiAbilityRecord);
147 return uiAbilityRecord;
148 }
149
AddCallerRecord(AbilityRequest & abilityRequest,sptr<SessionInfo> sessionInfo,std::shared_ptr<AbilityRecord> uiAbilityRecord) const150 void UIAbilityLifecycleManager::AddCallerRecord(AbilityRequest &abilityRequest, sptr<SessionInfo> sessionInfo,
151 std::shared_ptr<AbilityRecord> uiAbilityRecord) const
152 {
153 if (sessionInfo == nullptr) {
154 HILOG_ERROR("sessionInfo is invalid.");
155 return;
156 }
157 CHECK_POINTER(uiAbilityRecord);
158 std::string srcAbilityId = "";
159 if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_FOR_RESULT, false)) {
160 std::string srcDeviceId = abilityRequest.want.GetStringParam(DMS_SRC_NETWORK_ID);
161 int missionId = abilityRequest.want.GetIntParam(DMS_MISSION_ID, DEFAULT_DMS_MISSION_ID);
162 HILOG_DEBUG("Get srcNetWorkId = %{public}s, missionId = %{public}d", srcDeviceId.c_str(), missionId);
163 Want *newWant = const_cast<Want*>(&abilityRequest.want);
164 newWant->RemoveParam(DMS_SRC_NETWORK_ID);
165 newWant->RemoveParam(DMS_MISSION_ID);
166 newWant->RemoveParam(Want::PARAM_RESV_FOR_RESULT);
167 srcAbilityId = srcDeviceId + "_" + std::to_string(missionId);
168 }
169 uiAbilityRecord->AddCallerRecord(sessionInfo->callerToken,
170 sessionInfo->requestCode, srcAbilityId, sessionInfo->callingTokenId);
171 }
172
CheckSpecified(AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> uiAbilityRecord)173 void UIAbilityLifecycleManager::CheckSpecified(AbilityRequest &abilityRequest,
174 std::shared_ptr<AbilityRecord> uiAbilityRecord)
175 {
176 if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED && !specifiedInfoQueue_.empty()) {
177 SpecifiedInfo specifiedInfo = specifiedInfoQueue_.front();
178 specifiedInfoQueue_.pop();
179 uiAbilityRecord->SetSpecifiedFlag(specifiedInfo.flag);
180 specifiedAbilityMap_.emplace(specifiedInfo, uiAbilityRecord);
181 }
182 }
183
SendKeyEvent(AbilityRequest & abilityRequest) const184 void UIAbilityLifecycleManager::SendKeyEvent(AbilityRequest &abilityRequest) const
185 {
186 if (abilityRequest.abilityInfo.visible == false) {
187 EventInfo eventInfo;
188 eventInfo.abilityName = abilityRequest.abilityInfo.name;
189 eventInfo.bundleName = abilityRequest.abilityInfo.bundleName;
190 eventInfo.moduleName = abilityRequest.abilityInfo.moduleName;
191 EventReport::SendKeyEvent(EventName::START_PRIVATE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
192 }
193 }
194
AttachAbilityThread(const sptr<IAbilityScheduler> & scheduler,const sptr<IRemoteObject> & token)195 int UIAbilityLifecycleManager::AttachAbilityThread(const sptr<IAbilityScheduler> &scheduler,
196 const sptr<IRemoteObject> &token)
197 {
198 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
199 std::lock_guard<ffrt::mutex> guard(sessionLock_);
200 if (!IsContainsAbilityInner(token)) {
201 HILOG_WARN("Not in running list");
202 return ERR_INVALID_VALUE;
203 }
204 auto&& abilityRecord = Token::GetAbilityRecordByToken(token);
205 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
206 HILOG_INFO("Lifecycle: name is %{public}s.", abilityRecord->GetAbilityInfo().name.c_str());
207
208 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
209 CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler.");
210 handler->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
211 abilityRecord->SetLoading(false);
212 FreezeUtil::LifecycleFlow flow = {token, FreezeUtil::TimeoutState::LOAD};
213 FreezeUtil::GetInstance().DeleteLifecycleEvent(flow);
214
215 abilityRecord->SetScheduler(scheduler);
216 if (abilityRecord->IsStartedByCall()) {
217 if (abilityRecord->GetWant().GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
218 abilityRecord->SetStartToForeground(true);
219 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(token);
220 } else {
221 abilityRecord->SetStartToBackground(true);
222 MoveToBackground(abilityRecord);
223 }
224 return ERR_OK;
225 }
226
227 if (abilityRecord->IsNeedToCallRequest()) {
228 abilityRecord->CallRequest();
229 }
230
231 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(token);
232 return ERR_OK;
233 }
234
OnAbilityRequestDone(const sptr<IRemoteObject> & token,int32_t state) const235 void UIAbilityLifecycleManager::OnAbilityRequestDone(const sptr<IRemoteObject> &token, int32_t state) const
236 {
237 HILOG_DEBUG("Ability request state %{public}d done.", state);
238 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
239 std::lock_guard<ffrt::mutex> guard(sessionLock_);
240 AppAbilityState abilityState = DelayedSingleton<AppScheduler>::GetInstance()->ConvertToAppAbilityState(state);
241 if (abilityState == AppAbilityState::ABILITY_STATE_FOREGROUND) {
242 auto abilityRecord = GetAbilityRecordByToken(token);
243 CHECK_POINTER(abilityRecord);
244 std::string element = abilityRecord->GetElementName().GetURI();
245 HILOG_DEBUG("Ability is %{public}s, start to foreground.", element.c_str());
246 abilityRecord->ForegroundAbility();
247 }
248 }
249
AbilityTransactionDone(const sptr<IRemoteObject> & token,int state,const PacMap & saveData)250 int UIAbilityLifecycleManager::AbilityTransactionDone(const sptr<IRemoteObject> &token, int state,
251 const PacMap &saveData)
252 {
253 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
254 int targetState = AbilityRecord::ConvertLifeCycleToAbilityState(static_cast<AbilityLifeCycleState>(state));
255 std::string abilityState = AbilityRecord::ConvertAbilityState(static_cast<AbilityState>(targetState));
256 HILOG_DEBUG("AbilityTransactionDone, state: %{public}s.", abilityState.c_str());
257
258 std::lock_guard<ffrt::mutex> guard(sessionLock_);
259 auto abilityRecord = GetAbilityRecordByToken(token);
260 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
261
262 std::string element = abilityRecord->GetElementName().GetURI();
263 HILOG_DEBUG("ability: %{public}s, state: %{public}s", element.c_str(), abilityState.c_str());
264
265 if (targetState == AbilityState::BACKGROUND) {
266 abilityRecord->SaveAbilityState(saveData);
267 }
268
269 return DispatchState(abilityRecord, targetState);
270 }
271
NotifySCBToStartUIAbility(const AbilityRequest & abilityRequest,int32_t userId)272 int UIAbilityLifecycleManager::NotifySCBToStartUIAbility(const AbilityRequest &abilityRequest, int32_t userId)
273 {
274 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
275 std::lock_guard<ffrt::mutex> guard(sessionLock_);
276 auto abilityInfo = abilityRequest.abilityInfo;
277 bool isUIAbility = (abilityInfo.type == AppExecFwk::AbilityType::PAGE && abilityInfo.isStageBasedModel);
278 if (abilityInfo.isolationProcess && isPcDevice_ && isUIAbility) {
279 HILOG_INFO("StartSpecifiedProcess");
280 EnqueueAbilityToFront(abilityRequest);
281 DelayedSingleton<AppScheduler>::GetInstance()->StartSpecifiedProcess(abilityRequest.want, abilityInfo);
282 return ERR_OK;
283 }
284 auto isSpecified = (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED);
285 if (isSpecified) {
286 EnqueueAbilityToFront(abilityRequest);
287 DelayedSingleton<AppScheduler>::GetInstance()->StartSpecifiedAbility(
288 abilityRequest.want, abilityRequest.abilityInfo);
289 return ERR_OK;
290 }
291 auto sessionInfo = CreateSessionInfo(abilityRequest);
292 sessionInfo->requestCode = abilityRequest.requestCode;
293 sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse, userId);
294 sessionInfo->userId = userId;
295 HILOG_INFO("Reused sessionId: %{public}d, userId: %{public}d.", sessionInfo->persistentId, userId);
296 return NotifySCBPendingActivation(sessionInfo, abilityRequest);
297 }
298
DispatchState(const std::shared_ptr<AbilityRecord> & abilityRecord,int state)299 int UIAbilityLifecycleManager::DispatchState(const std::shared_ptr<AbilityRecord> &abilityRecord, int state)
300 {
301 switch (state) {
302 case AbilityState::INITIAL: {
303 return DispatchTerminate(abilityRecord);
304 }
305 case AbilityState::BACKGROUND:
306 case AbilityState::BACKGROUND_FAILED: {
307 return DispatchBackground(abilityRecord);
308 }
309 case AbilityState::FOREGROUND: {
310 return DispatchForeground(abilityRecord, true);
311 }
312 case AbilityState::FOREGROUND_FAILED:
313 case AbilityState::FOREGROUND_INVALID_MODE:
314 case AbilityState::FOREGROUND_WINDOW_FREEZED: {
315 return DispatchForeground(abilityRecord, false, static_cast<AbilityState>(state));
316 }
317 default: {
318 HILOG_WARN("Don't support transiting state: %{public}d", state);
319 return ERR_INVALID_VALUE;
320 }
321 }
322 }
323
DispatchForeground(const std::shared_ptr<AbilityRecord> & abilityRecord,bool success,AbilityState state)324 int UIAbilityLifecycleManager::DispatchForeground(const std::shared_ptr<AbilityRecord> &abilityRecord, bool success,
325 AbilityState state)
326 {
327 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
328 CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler.");
329 auto taskHandler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
330 CHECK_POINTER_AND_RETURN_LOG(taskHandler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler.");
331 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
332
333 if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) {
334 HILOG_ERROR("DispatchForeground Ability transition life state error. expect %{public}d, actual %{public}d",
335 AbilityState::FOREGROUNDING, abilityRecord->GetAbilityState());
336 return ERR_INVALID_VALUE;
337 }
338
339 HILOG_DEBUG("ForegroundLifecycle: end.");
340 handler->RemoveEvent(AbilityManagerService::FOREGROUND_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
341 g_deleteLifecycleEventTask(abilityRecord->GetToken(), FreezeUtil::TimeoutState::FOREGROUND);
342 auto self(weak_from_this());
343 if (success) {
344 HILOG_DEBUG("foreground succeeded.");
345 auto task = [self, abilityRecord]() {
346 auto selfObj = self.lock();
347 if (!selfObj) {
348 HILOG_WARN("mgr is invalid.");
349 return;
350 }
351 selfObj->CompleteForegroundSuccess(abilityRecord);
352 };
353 taskHandler->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
354 } else {
355 auto task = [self, abilityRecord, state]() {
356 auto selfObj = self.lock();
357 if (!selfObj) {
358 HILOG_WARN("Mission list mgr is invalid.");
359 return;
360 }
361 if (state == AbilityState::FOREGROUND_WINDOW_FREEZED) {
362 HILOG_INFO("Window was freezed.");
363 if (abilityRecord != nullptr) {
364 abilityRecord->SetAbilityState(AbilityState::BACKGROUND);
365 DelayedSingleton<AppScheduler>::GetInstance()->MoveToBackground(abilityRecord->GetToken());
366 }
367 return;
368 }
369 selfObj->HandleForegroundFailed(abilityRecord, state);
370 };
371 taskHandler->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
372 }
373 return ERR_OK;
374 }
375
DispatchBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)376 int UIAbilityLifecycleManager::DispatchBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
377 {
378 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
379 CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler.");
380 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
381
382 if (!abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING)) {
383 HILOG_ERROR("Ability transition life state error. actual %{public}d", abilityRecord->GetAbilityState());
384 return ERR_INVALID_VALUE;
385 }
386
387 HILOG_DEBUG("end.");
388 // remove background timeout task.
389 handler->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId()));
390 g_deleteLifecycleEventTask(abilityRecord->GetToken(), FreezeUtil::TimeoutState::BACKGROUND);
391 auto self(shared_from_this());
392 auto task = [self, abilityRecord]() { self->CompleteBackground(abilityRecord); };
393 handler->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
394
395 return ERR_OK;
396 }
397
DispatchTerminate(const std::shared_ptr<AbilityRecord> & abilityRecord)398 int UIAbilityLifecycleManager::DispatchTerminate(const std::shared_ptr<AbilityRecord> &abilityRecord)
399 {
400 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
401 if (abilityRecord->GetAbilityState() != AbilityState::TERMINATING) {
402 HILOG_ERROR("DispatchTerminate error, ability state is %{public}d", abilityRecord->GetAbilityState());
403 return INNER_ERR;
404 }
405
406 // remove terminate timeout task.
407 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
408 CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityTaskHandler.");
409 handler->CancelTask("terminate_" + std::to_string(abilityRecord->GetAbilityRecordId()));
410 auto self(shared_from_this());
411 auto task = [self, abilityRecord]() { self->CompleteTerminate(abilityRecord); };
412 handler->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
413
414 return ERR_OK;
415 }
416
CompleteForegroundSuccess(const std::shared_ptr<AbilityRecord> & abilityRecord)417 void UIAbilityLifecycleManager::CompleteForegroundSuccess(const std::shared_ptr<AbilityRecord> &abilityRecord)
418 {
419 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
420 std::lock_guard<ffrt::mutex> guard(sessionLock_);
421
422 CHECK_POINTER(abilityRecord);
423 // ability do not save window mode
424 abilityRecord->RemoveWindowMode();
425 std::string element = abilityRecord->GetElementName().GetURI();
426 HILOG_DEBUG("ability: %{public}s", element.c_str());
427 abilityRecord->SetAbilityState(AbilityState::FOREGROUND);
428
429 // new version. started by caller, scheduler call request
430 if (abilityRecord->IsStartedByCall() && abilityRecord->IsStartToForeground() && abilityRecord->IsReady()) {
431 HILOG_DEBUG("call request after completing foreground state");
432 abilityRecord->CallRequest();
433 abilityRecord->SetStartToForeground(false);
434 }
435
436 if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) {
437 abilityRecord->SetMinimizeReason(true);
438 MoveToBackground(abilityRecord);
439 } else if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) {
440 HILOG_DEBUG("not continuous startup.");
441 abilityRecord->SetPendingState(AbilityState::INITIAL);
442 }
443 if (handler_ != nullptr && abilityRecord->GetSessionInfo() != nullptr) {
444 handler_->OnSessionMovedToFront(abilityRecord->GetSessionInfo()->persistentId);
445 }
446 }
447
HandleForegroundFailed(const std::shared_ptr<AbilityRecord> & ability,AbilityState state)448 void UIAbilityLifecycleManager::HandleForegroundFailed(const std::shared_ptr<AbilityRecord> &ability,
449 AbilityState state)
450 {
451 HILOG_DEBUG("state: %{public}d.", static_cast<int32_t>(state));
452 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
453 std::lock_guard<ffrt::mutex> guard(sessionLock_);
454 if (ability == nullptr) {
455 HILOG_ERROR("ability record is nullptr.");
456 return;
457 }
458
459 if (!ability->IsAbilityState(AbilityState::FOREGROUNDING)) {
460 HILOG_ERROR("this ability is not foregrounding state.");
461 return;
462 }
463
464 NotifySCBToHandleException(ability,
465 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleForegroundTimeout");
466
467 CloseUIAbilityInner(ability, 0, nullptr, false);
468 }
469
GetAbilityRecordByToken(const sptr<IRemoteObject> & token) const470 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManager::GetAbilityRecordByToken(const sptr<IRemoteObject> &token)
471 const
472 {
473 if (token == nullptr) {
474 HILOG_ERROR("nullptr.");
475 return nullptr;
476 }
477
478 for (auto ability : terminateAbilityList_) {
479 if (ability && token == ability->GetToken()->AsObject()) {
480 return ability;
481 }
482 }
483
484 for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) {
485 if (iter->second != nullptr && iter->second->GetToken()->AsObject() == token) {
486 return iter->second;
487 }
488 }
489 return nullptr;
490 }
491
IsContainsAbility(const sptr<IRemoteObject> & token) const492 bool UIAbilityLifecycleManager::IsContainsAbility(const sptr<IRemoteObject> &token) const
493 {
494 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
495 std::lock_guard<ffrt::mutex> guard(sessionLock_);
496 return IsContainsAbilityInner(token);
497 }
498
IsContainsAbilityInner(const sptr<IRemoteObject> & token) const499 bool UIAbilityLifecycleManager::IsContainsAbilityInner(const sptr<IRemoteObject> &token) const
500 {
501 for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) {
502 if (iter->second != nullptr && iter->second->GetToken()->AsObject() == token) {
503 return true;
504 }
505 }
506 return false;
507 }
508
EraseAbilityRecord(const std::shared_ptr<AbilityRecord> & abilityRecord)509 void UIAbilityLifecycleManager::EraseAbilityRecord(const std::shared_ptr<AbilityRecord> &abilityRecord)
510 {
511 if (abilityRecord == nullptr) {
512 return;
513 }
514
515 for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) {
516 if (iter->second != nullptr && iter->second->GetToken()->AsObject() == abilityRecord->GetToken()->AsObject()) {
517 sessionAbilityMap_.erase(iter);
518 break;
519 }
520 }
521 }
522
EraseSpecifiedAbilityRecord(const std::shared_ptr<AbilityRecord> & abilityRecord)523 void UIAbilityLifecycleManager::EraseSpecifiedAbilityRecord(const std::shared_ptr<AbilityRecord> &abilityRecord)
524 {
525 for (auto iter = specifiedAbilityMap_.begin(); iter != specifiedAbilityMap_.end(); iter++) {
526 auto abilityInfo = abilityRecord->GetAbilityInfo();
527 if (iter->second != nullptr && iter->second->GetToken()->AsObject() == abilityRecord->GetToken()->AsObject() &&
528 iter->first.abilityName == abilityInfo.name && iter->first.bundleName == abilityInfo.bundleName &&
529 iter->first.flag == abilityRecord->GetSpecifiedFlag()) {
530 specifiedAbilityMap_.erase(iter);
531 break;
532 }
533 }
534 }
535
UpdateAbilityRecordLaunchReason(const AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> & abilityRecord) const536 void UIAbilityLifecycleManager::UpdateAbilityRecordLaunchReason(
537 const AbilityRequest &abilityRequest, std::shared_ptr<AbilityRecord> &abilityRecord) const
538 {
539 if (abilityRecord == nullptr) {
540 HILOG_WARN("input record is nullptr.");
541 return;
542 }
543
544 if (abilityRequest.IsContinuation()) {
545 abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CONTINUATION);
546 return;
547 }
548
549 if (abilityRequest.IsAppRecovery() || abilityRecord->GetRecoveryInfo()) {
550 abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_APP_RECOVERY);
551 return;
552 }
553
554 if (abilityRequest.IsAcquireShareData()) {
555 abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_SHARE);
556 return;
557 }
558
559 abilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_START_ABILITY);
560 return;
561 }
562
GetUIAbilityRecordBySessionInfo(const sptr<SessionInfo> & sessionInfo)563 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManager::GetUIAbilityRecordBySessionInfo(
564 const sptr<SessionInfo> &sessionInfo)
565 {
566 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
567 std::lock_guard<ffrt::mutex> guard(sessionLock_);
568 CHECK_POINTER_AND_RETURN(sessionInfo, nullptr);
569 CHECK_POINTER_AND_RETURN(sessionInfo->sessionToken, nullptr);
570 auto sessionToken = iface_cast<Rosen::ISession>(sessionInfo->sessionToken);
571 std::string descriptor = Str16ToStr8(sessionToken->GetDescriptor());
572 if (descriptor != "OHOS.ISession") {
573 HILOG_ERROR("failed, input token is not a sessionToken, token->GetDescriptor(): %{public}s",
574 descriptor.c_str());
575 return nullptr;
576 }
577
578 auto iter = sessionAbilityMap_.find(sessionInfo->persistentId);
579 if (iter != sessionAbilityMap_.end()) {
580 return iter->second;
581 }
582 return nullptr;
583 }
584
MinimizeUIAbility(const std::shared_ptr<AbilityRecord> & abilityRecord,bool fromUser)585 int UIAbilityLifecycleManager::MinimizeUIAbility(const std::shared_ptr<AbilityRecord> &abilityRecord, bool fromUser)
586 {
587 HILOG_DEBUG("call");
588 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
589 std::lock_guard<ffrt::mutex> guard(sessionLock_);
590 if (abilityRecord == nullptr) {
591 HILOG_ERROR("ability record is null");
592 return ERR_INVALID_VALUE;
593 }
594 HILOG_INFO("abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str());
595 abilityRecord->SetMinimizeReason(fromUser);
596 abilityRecord->SetPendingState(AbilityState::BACKGROUND);
597 if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) {
598 HILOG_ERROR("ability state is not foreground");
599 return ERR_OK;
600 }
601 MoveToBackground(abilityRecord);
602 return ERR_OK;
603 }
604
MoveToBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)605 void UIAbilityLifecycleManager::MoveToBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
606 {
607 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
608 if (abilityRecord == nullptr) {
609 HILOG_ERROR("ability record is null");
610 return;
611 }
612 abilityRecord->SetIsNewWant(false);
613 auto self(weak_from_this());
614 auto task = [abilityRecord, self]() {
615 auto selfObj = self.lock();
616 if (selfObj == nullptr) {
617 HILOG_WARN("UIAbilityLifecycleManager is invalid");
618 return;
619 }
620 HILOG_ERROR("UIAbilityLifecycleManager move to background timeout");
621 selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG);
622 selfObj->CompleteBackground(abilityRecord);
623 };
624 abilityRecord->BackgroundAbility(task);
625 }
626
ResolveLocked(const AbilityRequest & abilityRequest,int32_t userId)627 int UIAbilityLifecycleManager::ResolveLocked(const AbilityRequest &abilityRequest, int32_t userId)
628 {
629 HILOG_INFO("ability_name:%{public}s", abilityRequest.want.GetElement().GetURI().c_str());
630
631 if (!abilityRequest.IsCallType(AbilityCallType::CALL_REQUEST_TYPE)) {
632 HILOG_ERROR("%{public}s, resolve ability_name:", __func__);
633 return RESOLVE_CALL_ABILITY_INNER_ERR;
634 }
635
636 return CallAbilityLocked(abilityRequest, userId);
637 }
638
IsAbilityStarted(AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> & targetRecord,const int32_t oriValidUserId)639 bool UIAbilityLifecycleManager::IsAbilityStarted(AbilityRequest &abilityRequest,
640 std::shared_ptr<AbilityRecord> &targetRecord, const int32_t oriValidUserId)
641 {
642 HILOG_DEBUG("Call.");
643 std::lock_guard<ffrt::mutex> guard(sessionLock_);
644 bool reuse = false;
645 auto persistentId = GetPersistentIdByAbilityRequest(abilityRequest, reuse, oriValidUserId);
646 if (persistentId == 0) {
647 return false;
648 }
649 targetRecord = sessionAbilityMap_.at(persistentId);
650 if (targetRecord) {
651 targetRecord->AddCallerRecord(abilityRequest.callerToken, abilityRequest.requestCode);
652 targetRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CALL);
653 }
654 return true;
655 }
656
CallAbilityLocked(const AbilityRequest & abilityRequest,int32_t userId)657 int UIAbilityLifecycleManager::CallAbilityLocked(const AbilityRequest &abilityRequest, int32_t userId)
658 {
659 HILOG_DEBUG("Call.");
660 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
661 std::lock_guard<ffrt::mutex> guard(sessionLock_);
662
663 // Get target uiAbility record.
664 std::shared_ptr<AbilityRecord> uiAbilityRecord;
665 bool reuse = false;
666 auto persistentId = GetPersistentIdByAbilityRequest(abilityRequest, reuse, userId);
667 if (persistentId == 0) {
668 uiAbilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
669 uiAbilityRecord->SetOwnerMissionUserId(DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId());
670 SetRevicerInfo(abilityRequest, uiAbilityRecord);
671 SetLastExitReason(uiAbilityRecord);
672 } else {
673 uiAbilityRecord = sessionAbilityMap_.at(persistentId);
674 }
675 uiAbilityRecord->AddCallerRecord(abilityRequest.callerToken, abilityRequest.requestCode);
676 uiAbilityRecord->SetLaunchReason(LaunchReason::LAUNCHREASON_CALL);
677 NotifyAbilityToken(uiAbilityRecord->GetToken(), abilityRequest);
678
679 // new version started by call type
680 auto ret = ResolveAbility(uiAbilityRecord, abilityRequest);
681 if (ret == ResolveResultType::OK_HAS_REMOTE_OBJ) {
682 HILOG_DEBUG("target ability has been resolved.");
683 if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
684 HILOG_DEBUG("target ability needs to be switched to foreground.");
685 auto sessionInfo = CreateSessionInfo(abilityRequest);
686 sessionInfo->persistentId = persistentId;
687 sessionInfo->state = CallToState::FOREGROUND;
688 sessionInfo->reuse = reuse;
689 sessionInfo->uiAbilityId = uiAbilityRecord->GetAbilityRecordId();
690 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(uiAbilityRecord->GetToken());
691 return NotifySCBPendingActivation(sessionInfo, abilityRequest);
692 }
693 return ERR_OK;
694 } else if (ret == ResolveResultType::NG_INNER_ERROR) {
695 HILOG_ERROR("resolve failed, error: %{public}d.", RESOLVE_CALL_ABILITY_INNER_ERR);
696 return RESOLVE_CALL_ABILITY_INNER_ERR;
697 }
698
699 auto sessionInfo = CreateSessionInfo(abilityRequest);
700 sessionInfo->persistentId = persistentId;
701 sessionInfo->reuse = reuse;
702 sessionInfo->uiAbilityId = uiAbilityRecord->GetAbilityRecordId();
703 if (abilityRequest.want.GetBoolParam(Want::PARAM_RESV_CALL_TO_FOREGROUND, false)) {
704 sessionInfo->state = CallToState::FOREGROUND;
705 } else {
706 sessionInfo->state = CallToState::BACKGROUND;
707 }
708 HILOG_DEBUG("Notify scb's abilityId is %{public}" PRIu64 ".", sessionInfo->uiAbilityId);
709 tmpAbilityMap_.emplace(uiAbilityRecord->GetAbilityRecordId(), uiAbilityRecord);
710 return NotifySCBPendingActivation(sessionInfo, abilityRequest);
711 }
712
CallUIAbilityBySCB(const sptr<SessionInfo> & sessionInfo)713 void UIAbilityLifecycleManager::CallUIAbilityBySCB(const sptr<SessionInfo> &sessionInfo)
714 {
715 HILOG_DEBUG("Call.");
716 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
717 std::lock_guard<ffrt::mutex> guard(sessionLock_);
718 if (sessionInfo == nullptr || sessionInfo->sessionToken == nullptr) {
719 HILOG_ERROR("sessionInfo is invalid.");
720 return;
721 }
722 auto sessionToken = iface_cast<Rosen::ISession>(sessionInfo->sessionToken);
723 auto descriptor = Str16ToStr8(sessionToken->GetDescriptor());
724 if (descriptor != "OHOS.ISession") {
725 HILOG_ERROR("token's Descriptor: %{public}s", descriptor.c_str());
726 return;
727 }
728
729 HILOG_DEBUG("SCB output abilityId is %{public}" PRIu64 ".", sessionInfo->uiAbilityId);
730 auto search = tmpAbilityMap_.find(sessionInfo->uiAbilityId);
731 if (search == tmpAbilityMap_.end()) {
732 HILOG_WARN("Not found UIAbility.");
733 return;
734 }
735 auto uiAbilityRecord = search->second;
736 if (uiAbilityRecord == nullptr) {
737 HILOG_ERROR("UIAbility not exist.");
738 return;
739 }
740 auto sessionSearch = sessionAbilityMap_.find(sessionInfo->persistentId);
741 if (sessionSearch != sessionAbilityMap_.end()) {
742 HILOG_ERROR("Session already exist.");
743 return;
744 }
745
746 sessionAbilityMap_.emplace(sessionInfo->persistentId, uiAbilityRecord);
747 tmpAbilityMap_.erase(search);
748 uiAbilityRecord->SetSessionInfo(sessionInfo);
749
750 uiAbilityRecord->LoadAbility();
751 }
752
CreateSessionInfo(const AbilityRequest & abilityRequest) const753 sptr<SessionInfo> UIAbilityLifecycleManager::CreateSessionInfo(const AbilityRequest &abilityRequest) const
754 {
755 sptr<SessionInfo> sessionInfo = new SessionInfo();
756 sessionInfo->callerToken = abilityRequest.callerToken;
757 sessionInfo->want = abilityRequest.want;
758 if (abilityRequest.startSetting != nullptr) {
759 sessionInfo->startSetting = abilityRequest.startSetting;
760 }
761 sessionInfo->callingTokenId = static_cast<uint32_t>(abilityRequest.want.GetIntParam(Want::PARAM_RESV_CALLER_TOKEN,
762 IPCSkeleton::GetCallingTokenID()));
763 return sessionInfo;
764 }
765
NotifySCBPendingActivation(sptr<SessionInfo> & sessionInfo,const AbilityRequest & abilityRequest) const766 int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr<SessionInfo> &sessionInfo,
767 const AbilityRequest &abilityRequest) const
768 {
769 auto abilityRecord = GetAbilityRecordByToken(abilityRequest.callerToken);
770 if (abilityRecord != nullptr) {
771 auto callerSessionInfo = abilityRecord->GetSessionInfo();
772 CHECK_POINTER_AND_RETURN(callerSessionInfo, ERR_INVALID_VALUE);
773 CHECK_POINTER_AND_RETURN(callerSessionInfo->sessionToken, ERR_INVALID_VALUE);
774 auto callerSession = iface_cast<Rosen::ISession>(callerSessionInfo->sessionToken);
775 HILOG_INFO("Call PendingSessionActivation by callerSession.");
776 return static_cast<int>(callerSession->PendingSessionActivation(sessionInfo));
777 }
778 CHECK_POINTER_AND_RETURN(rootSceneSession_, ERR_INVALID_VALUE);
779 if (sessionInfo->persistentId == 0) {
780 const auto &abilityInfo = abilityRequest.abilityInfo;
781 auto isStandard = abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD && !abilityRequest.startRecent;
782 if (!isStandard) {
783 (void)DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance()->GetAbilitySessionId(
784 abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name, sessionInfo->persistentId);
785 HILOG_INFO("session id: %{public}d.", sessionInfo->persistentId);
786 }
787 }
788 HILOG_INFO("Call PendingSessionActivation by rootSceneSession.");
789 return static_cast<int>(rootSceneSession_->PendingSessionActivation(sessionInfo));
790 }
791
ResolveAbility(const std::shared_ptr<AbilityRecord> & targetAbility,const AbilityRequest & abilityRequest) const792 int UIAbilityLifecycleManager::ResolveAbility(
793 const std::shared_ptr<AbilityRecord> &targetAbility, const AbilityRequest &abilityRequest) const
794 {
795 HILOG_DEBUG("targetAbilityRecord resolve call record.");
796 CHECK_POINTER_AND_RETURN(targetAbility, ResolveResultType::NG_INNER_ERROR);
797
798 ResolveResultType result = targetAbility->Resolve(abilityRequest);
799 switch (result) {
800 case ResolveResultType::NG_INNER_ERROR:
801 case ResolveResultType::OK_HAS_REMOTE_OBJ:
802 return result;
803 default:
804 break;
805 }
806
807 if (targetAbility->IsReady()) {
808 HILOG_DEBUG("targetAbility is ready, directly scheduler call request.");
809 targetAbility->CallRequest();
810 return ResolveResultType::OK_HAS_REMOTE_OBJ;
811 }
812
813 HILOG_DEBUG("targetAbility need to call request after lifecycle.");
814 return result;
815 }
816
NotifyAbilityToken(const sptr<IRemoteObject> & token,const AbilityRequest & abilityRequest) const817 void UIAbilityLifecycleManager::NotifyAbilityToken(const sptr<IRemoteObject> &token,
818 const AbilityRequest &abilityRequest) const
819 {
820 auto abilityInfoCallback = iface_cast<AppExecFwk::IAbilityInfoCallback>(abilityRequest.abilityInfoCallback);
821 if (abilityInfoCallback != nullptr) {
822 abilityInfoCallback->NotifyAbilityToken(token, abilityRequest.want);
823 }
824 }
825
PrintTimeOutLog(std::shared_ptr<AbilityRecord> ability,uint32_t msgId,bool isHalf)826 void UIAbilityLifecycleManager::PrintTimeOutLog(std::shared_ptr<AbilityRecord> ability, uint32_t msgId, bool isHalf)
827 {
828 if (ability == nullptr) {
829 HILOG_ERROR("failed, ability is nullptr");
830 return;
831 }
832 AppExecFwk::RunningProcessInfo processInfo = {};
833 DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo);
834 if (processInfo.pid_ == 0) {
835 HILOG_ERROR("the ability:%{public}s, app may fork fail or not running.", ability->GetAbilityInfo().name.data());
836 return;
837 }
838 int typeId = AppExecFwk::AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT;
839 std::string msgContent = "ability:" + ability->GetAbilityInfo().name + " ";
840 if (!GetContentAndTypeId(msgId, msgContent, typeId)) {
841 HILOG_WARN("msgId is invalid.");
842 return;
843 }
844
845 std::string eventName = isHalf ?
846 AppExecFwk::AppFreezeType::LIFECYCLE_HALF_TIMEOUT : AppExecFwk::AppFreezeType::LIFECYCLE_TIMEOUT;
847 HILOG_WARN("%{public}s: uid: %{public}d, pid: %{public}d, bundleName: %{public}s, abilityName: %{public}s,"
848 "msg: %{public}s", eventName.c_str(), processInfo.uid_, processInfo.pid_,
849 ability->GetAbilityInfo().bundleName.c_str(), ability->GetAbilityInfo().name.c_str(), msgContent.c_str());
850
851 AppExecFwk::AppfreezeManager::ParamInfo info = {
852 .typeId = typeId,
853 .pid = processInfo.pid_,
854 .eventName = eventName,
855 .bundleName = ability->GetAbilityInfo().bundleName,
856 };
857 FreezeUtil::TimeoutState state = FreezeUtil::TimeoutState::UNKNOWN;
858 auto search = stateMap.find(msgId);
859 if (search != stateMap.end()) {
860 state = search->second;
861 }
862 if (state != FreezeUtil::TimeoutState::UNKNOWN) {
863 auto flow = std::make_unique<FreezeUtil::LifecycleFlow>();
864 if (ability->GetToken() != nullptr) {
865 flow->token = ability->GetToken()->AsObject();
866 flow->state = state;
867 }
868 info.msg = msgContent + "\nserver:\n" + FreezeUtil::GetInstance().GetLifecycleEvent(*flow);
869 if (!isHalf) {
870 FreezeUtil::GetInstance().DeleteLifecycleEvent(*flow);
871 }
872 AppExecFwk::AppfreezeManager::GetInstance()->LifecycleTimeoutHandle(info, std::move(flow));
873 } else {
874 info.msg = msgContent;
875 AppExecFwk::AppfreezeManager::GetInstance()->LifecycleTimeoutHandle(info);
876 }
877 }
878
GetContentAndTypeId(uint32_t msgId,std::string & msgContent,int & typeId) const879 bool UIAbilityLifecycleManager::GetContentAndTypeId(uint32_t msgId, std::string &msgContent, int &typeId) const
880 {
881 switch (msgId) {
882 case AbilityManagerService::LOAD_TIMEOUT_MSG:
883 msgContent += "load timeout.";
884 typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT;
885 break;
886 case AbilityManagerService::FOREGROUND_TIMEOUT_MSG:
887 msgContent += "foreground timeout.";
888 typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT;
889 break;
890 case AbilityManagerService::BACKGROUND_TIMEOUT_MSG:
891 msgContent += "background timeout.";
892 break;
893 case AbilityManagerService::TERMINATE_TIMEOUT_MSG:
894 msgContent += "terminate timeout.";
895 break;
896 default:
897 return false;
898 }
899 return true;
900 }
901
CompleteBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)902 void UIAbilityLifecycleManager::CompleteBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
903 {
904 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
905 std::lock_guard<ffrt::mutex> guard(sessionLock_);
906 if (abilityRecord->GetAbilityState() != AbilityState::BACKGROUNDING) {
907 HILOG_ERROR("failed, ability state is %{public}d, it can't complete background.",
908 abilityRecord->GetAbilityState());
909 return;
910 }
911 abilityRecord->SetAbilityState(AbilityState::BACKGROUND);
912 // notify AppMS to update application state.
913 DelayedSingleton<AppScheduler>::GetInstance()->MoveToBackground(abilityRecord->GetToken());
914
915 if (abilityRecord->GetPendingState() == AbilityState::FOREGROUND) {
916 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(abilityRecord->GetToken());
917 } else if (abilityRecord->GetPendingState() == AbilityState::BACKGROUND) {
918 HILOG_DEBUG("not continuous startup.");
919 abilityRecord->SetPendingState(AbilityState::INITIAL);
920 }
921
922 // new version. started by caller, scheduler call request
923 if (abilityRecord->IsStartedByCall() && abilityRecord->IsStartToBackground() && abilityRecord->IsReady()) {
924 HILOG_DEBUG("call request after completing background state");
925 abilityRecord->CallRequest();
926 abilityRecord->SetStartToBackground(false);
927 }
928
929 // Abilities ahead of the one started were put in terminate list, we need to terminate them.
930 auto self(shared_from_this());
931 for (auto terminateAbility : terminateAbilityList_) {
932 if (terminateAbility->GetAbilityState() == AbilityState::BACKGROUND) {
933 auto timeoutTask = [terminateAbility, self]() {
934 HILOG_WARN("Terminate ability timeout after background.");
935 self->DelayCompleteTerminate(terminateAbility);
936 };
937 terminateAbility->Terminate(timeoutTask);
938 }
939 }
940 }
941
CloseUIAbility(const std::shared_ptr<AbilityRecord> & abilityRecord,int resultCode,const Want * resultWant,bool isClearSession)942 int UIAbilityLifecycleManager::CloseUIAbility(const std::shared_ptr<AbilityRecord> &abilityRecord,
943 int resultCode, const Want *resultWant, bool isClearSession)
944 {
945 HILOG_DEBUG("call");
946 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
947 std::lock_guard<ffrt::mutex> guard(sessionLock_);
948 return CloseUIAbilityInner(abilityRecord, resultCode, resultWant, isClearSession);
949 }
950
CloseUIAbilityInner(std::shared_ptr<AbilityRecord> abilityRecord,int resultCode,const Want * resultWant,bool isClearSession)951 int UIAbilityLifecycleManager::CloseUIAbilityInner(std::shared_ptr<AbilityRecord> abilityRecord,
952 int resultCode, const Want *resultWant, bool isClearSession)
953 {
954 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
955 std::string element = abilityRecord->GetElementName().GetURI();
956 HILOG_INFO("call, from ability: %{public}s", element.c_str());
957 if (abilityRecord->IsTerminating() && !abilityRecord->IsForeground()) {
958 HILOG_INFO("ability is on terminating");
959 return ERR_OK;
960 }
961 DelayedSingleton<AppScheduler>::GetInstance()->PrepareTerminate(abilityRecord->GetToken());
962 abilityRecord->SetTerminatingState();
963 abilityRecord->SetClearMissionFlag(isClearSession);
964 // save result to caller AbilityRecord
965 if (resultWant != nullptr) {
966 Want* newWant = const_cast<Want*>(resultWant);
967 newWant->RemoveParam(Want::PARAM_RESV_CALLER_TOKEN);
968 abilityRecord->SaveResultToCallers(resultCode, newWant);
969 } else {
970 Want want;
971 abilityRecord->SaveResultToCallers(-1, &want);
972 }
973 EraseAbilityRecord(abilityRecord);
974 if (abilityRecord->GetAbilityState() == AbilityState::INITIAL) {
975 if (abilityRecord->GetScheduler() == nullptr) {
976 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
977 CHECK_POINTER_AND_RETURN_LOG(handler, ERR_INVALID_VALUE, "Fail to get AbilityEventHandler.");
978 handler->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
979 }
980 return abilityRecord->TerminateAbility();
981 }
982
983 terminateAbilityList_.push_back(abilityRecord);
984 abilityRecord->SendResultToCallers();
985
986 if (abilityRecord->IsDebug() && isClearSession) {
987 HILOG_DEBUG("notify AppMS terminate");
988 return abilityRecord->TerminateAbility();
989 }
990
991 if (abilityRecord->IsAbilityState(FOREGROUND) || abilityRecord->IsAbilityState(FOREGROUNDING)) {
992 HILOG_DEBUG("current ability is active");
993 abilityRecord->SetPendingState(AbilityState::BACKGROUND);
994 MoveToBackground(abilityRecord);
995 return ERR_OK;
996 }
997
998 // ability on background, schedule to terminate.
999 if (abilityRecord->GetAbilityState() == AbilityState::BACKGROUND) {
1000 auto self(shared_from_this());
1001 auto task = [abilityRecord, self]() {
1002 HILOG_WARN("close ability by scb timeout");
1003 self->DelayCompleteTerminate(abilityRecord);
1004 };
1005 abilityRecord->Terminate(task);
1006 }
1007 return ERR_OK;
1008 }
1009
DelayCompleteTerminate(const std::shared_ptr<AbilityRecord> & abilityRecord)1010 void UIAbilityLifecycleManager::DelayCompleteTerminate(const std::shared_ptr<AbilityRecord> &abilityRecord)
1011 {
1012 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
1013 CHECK_POINTER(handler);
1014
1015 PrintTimeOutLog(abilityRecord, AbilityManagerService::TERMINATE_TIMEOUT_MSG);
1016
1017 auto timeoutTask = [self = shared_from_this(), abilityRecord]() {
1018 HILOG_INFO("emit delay complete terminate task!");
1019 self->CompleteTerminate(abilityRecord);
1020 };
1021 int killTimeout = AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * KILL_TIMEOUT_MULTIPLE;
1022 handler->SubmitTask(timeoutTask, "DELAY_KILL_PROCESS", killTimeout);
1023 }
1024
CompleteTerminate(const std::shared_ptr<AbilityRecord> & abilityRecord)1025 void UIAbilityLifecycleManager::CompleteTerminate(const std::shared_ptr<AbilityRecord> &abilityRecord)
1026 {
1027 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1028 CHECK_POINTER(abilityRecord);
1029 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1030
1031 if (abilityRecord->GetAbilityState() != AbilityState::TERMINATING) {
1032 HILOG_ERROR("failed, %{public}s, ability is not terminating.", __func__);
1033 return;
1034 }
1035 abilityRecord->RemoveAbilityDeathRecipient();
1036
1037 // notify AppMS terminate
1038 if (abilityRecord->TerminateAbility() != ERR_OK) {
1039 // Don't return here
1040 HILOG_ERROR("AppMS fail to terminate ability.");
1041 }
1042 abilityRecord->RevokeUriPermission();
1043 EraseSpecifiedAbilityRecord(abilityRecord);
1044 terminateAbilityList_.remove(abilityRecord);
1045 }
1046
GetPersistentIdByAbilityRequest(const AbilityRequest & abilityRequest,bool & reuse,int32_t userId) const1047 int32_t UIAbilityLifecycleManager::GetPersistentIdByAbilityRequest(const AbilityRequest &abilityRequest,
1048 bool &reuse, int32_t userId) const
1049 {
1050 if (abilityRequest.collaboratorType != CollaboratorType::DEFAULT_TYPE) {
1051 return GetReusedCollaboratorPersistentId(abilityRequest, reuse);
1052 }
1053
1054 if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED) {
1055 return GetReusedSpecifiedPersistentId(abilityRequest, reuse, userId);
1056 }
1057
1058 if (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD) {
1059 return GetReusedStandardPersistentId(abilityRequest, reuse, userId);
1060 }
1061
1062 if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::SINGLETON) {
1063 HILOG_WARN("Launch mode is not singleton.");
1064 return 0;
1065 }
1066
1067 reuse = true;
1068 for (const auto& [first, second] : sessionAbilityMap_) {
1069 if (CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::SINGLETON, userId)) {
1070 HILOG_DEBUG("SINGLETON: find.");
1071 return first;
1072 }
1073 }
1074
1075 HILOG_DEBUG("Not find existed ui ability.");
1076 return 0;
1077 }
1078
GetReusedSpecifiedPersistentId(const AbilityRequest & abilityRequest,bool & reuse,int32_t userId) const1079 int32_t UIAbilityLifecycleManager::GetReusedSpecifiedPersistentId(const AbilityRequest &abilityRequest,
1080 bool &reuse, int32_t userId) const
1081 {
1082 HILOG_DEBUG("Call.");
1083 if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::SPECIFIED) {
1084 HILOG_WARN("Not SPECIFIED.");
1085 return 0;
1086 }
1087
1088 reuse = true;
1089 // specified ability name and bundle name and module name and appIndex format is same as singleton.
1090 for (const auto& [first, second] : sessionAbilityMap_) {
1091 if (second->GetSpecifiedFlag() == abilityRequest.specifiedFlag &&
1092 CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::SPECIFIED, userId)) {
1093 HILOG_DEBUG("SPECIFIED: find.");
1094 return first;
1095 }
1096 }
1097 return 0;
1098 }
1099
GetReusedStandardPersistentId(const AbilityRequest & abilityRequest,bool & reuse,int32_t userId) const1100 int32_t UIAbilityLifecycleManager::GetReusedStandardPersistentId(const AbilityRequest &abilityRequest,
1101 bool &reuse, int32_t userId) const
1102 {
1103 HILOG_DEBUG("Call.");
1104 if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::STANDARD) {
1105 HILOG_WARN("Not STANDARD.");
1106 return 0;
1107 }
1108
1109 if (!abilityRequest.startRecent) {
1110 HILOG_WARN("startRecent is false.");
1111 return 0;
1112 }
1113
1114 reuse = true;
1115 int64_t sessionTime = 0;
1116 int32_t persistentId = 0;
1117 for (const auto& [first, second] : sessionAbilityMap_) {
1118 if (CheckProperties(second, abilityRequest, AppExecFwk::LaunchMode::STANDARD, userId) &&
1119 second->GetRestartTime() >= sessionTime) {
1120 persistentId = first;
1121 sessionTime = second->GetRestartTime();
1122 }
1123 }
1124 return persistentId;
1125 }
1126
GetReusedCollaboratorPersistentId(const AbilityRequest & abilityRequest,bool & reuse) const1127 int32_t UIAbilityLifecycleManager::GetReusedCollaboratorPersistentId(const AbilityRequest &abilityRequest,
1128 bool &reuse) const
1129 {
1130 HILOG_DEBUG("Call.");
1131
1132 reuse = false;
1133 int64_t sessionTime = 0;
1134 int32_t persistentId = 0;
1135 for (const auto& [first, second] : sessionAbilityMap_) {
1136 if (second->GetCollaboratorType() != CollaboratorType::DEFAULT_TYPE &&
1137 abilityRequest.want.GetStringParam(PARAM_MISSION_AFFINITY_KEY) == second->GetMissionAffinity() &&
1138 second->GetRestartTime() >= sessionTime) {
1139 reuse = true;
1140 persistentId = first;
1141 sessionTime = second->GetRestartTime();
1142 }
1143 }
1144 return persistentId;
1145 }
1146
CheckProperties(const std::shared_ptr<AbilityRecord> & abilityRecord,const AbilityRequest & abilityRequest,AppExecFwk::LaunchMode launchMode,int32_t userId) const1147 bool UIAbilityLifecycleManager::CheckProperties(const std::shared_ptr<AbilityRecord> &abilityRecord,
1148 const AbilityRequest &abilityRequest, AppExecFwk::LaunchMode launchMode, int32_t userId) const
1149 {
1150 if (userId != abilityRecord->GetOwnerMissionUserId()) {
1151 HILOG_WARN("userId: %{public}d, ability's userId: %{public}d", userId, abilityRecord->GetOwnerMissionUserId());
1152 return false;
1153 }
1154 const auto& abilityInfo = abilityRecord->GetAbilityInfo();
1155 return abilityInfo.launchMode == launchMode && abilityRequest.abilityInfo.name == abilityInfo.name &&
1156 abilityRequest.abilityInfo.bundleName == abilityInfo.bundleName &&
1157 abilityRequest.abilityInfo.moduleName == abilityInfo.moduleName &&
1158 abilityRequest.want.GetIntParam(DLP_INDEX, 0) == abilityRecord->GetAppIndex();
1159 }
1160
OnTimeOut(uint32_t msgId,int64_t abilityRecordId,bool isHalf)1161 void UIAbilityLifecycleManager::OnTimeOut(uint32_t msgId, int64_t abilityRecordId, bool isHalf)
1162 {
1163 HILOG_DEBUG("call, msgId is %{public}d", msgId);
1164 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1165 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1166 std::shared_ptr<AbilityRecord> abilityRecord;
1167 for (auto iter = sessionAbilityMap_.begin(); iter != sessionAbilityMap_.end(); iter++) {
1168 if (iter->second != nullptr && iter->second->GetAbilityRecordId() == abilityRecordId) {
1169 abilityRecord = iter->second;
1170 break;
1171 }
1172 }
1173 if (abilityRecord == nullptr) {
1174 HILOG_ERROR("failed, ability record is nullptr");
1175 return;
1176 }
1177 HILOG_DEBUG("call, msgId:%{public}d, name:%{public}s", msgId, abilityRecord->GetAbilityInfo().name.c_str());
1178 abilityRecord->RevokeUriPermission();
1179 PrintTimeOutLog(abilityRecord, msgId, isHalf);
1180 if (isHalf) {
1181 return;
1182 }
1183 switch (msgId) {
1184 case AbilityManagerService::LOAD_TIMEOUT_MSG:
1185 abilityRecord->SetLoading(false);
1186 HandleLoadTimeout(abilityRecord);
1187 break;
1188 case AbilityManagerService::FOREGROUND_TIMEOUT_MSG:
1189 HandleForegroundTimeout(abilityRecord);
1190 break;
1191 default:
1192 break;
1193 }
1194 }
1195
SetRootSceneSession(const sptr<IRemoteObject> & rootSceneSession)1196 void UIAbilityLifecycleManager::SetRootSceneSession(const sptr<IRemoteObject> &rootSceneSession)
1197 {
1198 HILOG_DEBUG("call");
1199 if (rootSceneSession == nullptr) {
1200 HILOG_ERROR("rootSceneSession is invalid.");
1201 return;
1202 }
1203 auto tmpSceneSession = iface_cast<Rosen::ISession>(rootSceneSession);
1204 auto descriptor = Str16ToStr8(tmpSceneSession->GetDescriptor());
1205 if (descriptor != "OHOS.ISession") {
1206 HILOG_ERROR("token's Descriptor: %{public}s", descriptor.c_str());
1207 return;
1208 }
1209 rootSceneSession_ = tmpSceneSession;
1210 }
1211
NotifySCBToHandleException(const std::shared_ptr<AbilityRecord> & abilityRecord,int32_t errorCode,std::string errorReason)1212 void UIAbilityLifecycleManager::NotifySCBToHandleException(const std::shared_ptr<AbilityRecord> &abilityRecord,
1213 int32_t errorCode, std::string errorReason)
1214 {
1215 HILOG_DEBUG("call");
1216 if (abilityRecord == nullptr) {
1217 HILOG_ERROR("ability record is nullptr");
1218 return;
1219 }
1220 auto sessionInfo = abilityRecord->GetSessionInfo();
1221 CHECK_POINTER(sessionInfo);
1222 CHECK_POINTER(sessionInfo->sessionToken);
1223 auto session = iface_cast<Rosen::ISession>(sessionInfo->sessionToken);
1224 HILOG_INFO("call notifySessionException");
1225 sptr<SessionInfo> info = abilityRecord->GetSessionInfo();
1226 info->errorCode = errorCode;
1227 info->errorReason = errorReason;
1228 session->NotifySessionException(info);
1229 EraseAbilityRecord(abilityRecord);
1230 }
1231
HandleLoadTimeout(const std::shared_ptr<AbilityRecord> & abilityRecord)1232 void UIAbilityLifecycleManager::HandleLoadTimeout(const std::shared_ptr<AbilityRecord> &abilityRecord)
1233 {
1234 HILOG_DEBUG("call");
1235 if (abilityRecord == nullptr) {
1236 HILOG_ERROR("failed, ability record is nullptr");
1237 return;
1238 }
1239 NotifySCBToHandleException(abilityRecord,
1240 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_LOAD_TIMEOUT), "handleLoadTimeout");
1241 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1242 }
1243
HandleForegroundTimeout(const std::shared_ptr<AbilityRecord> & abilityRecord)1244 void UIAbilityLifecycleManager::HandleForegroundTimeout(const std::shared_ptr<AbilityRecord> &abilityRecord)
1245 {
1246 HILOG_DEBUG("call");
1247 if (abilityRecord == nullptr) {
1248 HILOG_ERROR("ability record is nullptr");
1249 return;
1250 }
1251 if (!abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) {
1252 HILOG_ERROR("this ability is not foregrounding state");
1253 return;
1254 }
1255 NotifySCBToHandleException(abilityRecord,
1256 static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_FOREGROUND_TIMEOUT), "handleForegroundTimeout");
1257 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1258 EraseSpecifiedAbilityRecord(abilityRecord);
1259 }
1260
OnAbilityDied(std::shared_ptr<AbilityRecord> abilityRecord)1261 void UIAbilityLifecycleManager::OnAbilityDied(std::shared_ptr<AbilityRecord> abilityRecord)
1262 {
1263 HILOG_DEBUG("call");
1264 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1265 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1266 if (abilityRecord == nullptr) {
1267 HILOG_ERROR("failed, ability record is nullptr");
1268 return;
1269 }
1270 auto handler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetEventHandler();
1271 CHECK_POINTER_LOG(handler, "Fail to get AbilityEventHandler.");
1272 if (abilityRecord->GetAbilityState() == AbilityState::INITIAL) {
1273 handler->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
1274 abilityRecord->SetLoading(false);
1275 }
1276 if (abilityRecord->GetAbilityState() == AbilityState::FOREGROUNDING) {
1277 handler->RemoveEvent(AbilityManagerService::FOREGROUND_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
1278 }
1279 auto taskHandler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
1280 CHECK_POINTER_LOG(taskHandler, "Get AbilityTaskHandler failed.");
1281 if (abilityRecord->GetAbilityState() == AbilityState::BACKGROUNDING) {
1282 taskHandler->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId()));
1283 }
1284
1285 terminateAbilityList_.push_back(abilityRecord);
1286 abilityRecord->SetAbilityState(AbilityState::TERMINATING);
1287 NotifySCBToHandleException(abilityRecord, static_cast<int32_t>(ErrorLifecycleState::ABILITY_STATE_DIED),
1288 "onAbilityDied");
1289 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1290 DispatchTerminate(abilityRecord);
1291 EraseSpecifiedAbilityRecord(abilityRecord);
1292 }
1293
OnAcceptWantResponse(const AAFwk::Want & want,const std::string & flag)1294 void UIAbilityLifecycleManager::OnAcceptWantResponse(const AAFwk::Want &want, const std::string &flag)
1295 {
1296 HILOG_DEBUG("call");
1297 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1298 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1299 if (abilityQueue_.empty()) {
1300 return;
1301 }
1302
1303 AbilityRequest abilityRequest = abilityQueue_.front();
1304 abilityQueue_.pop();
1305 if (abilityRequest.callSpecifiedFlagTimeout) {
1306 HILOG_ERROR("The abilityRequest call onAcceptWant timeout.");
1307 return;
1308 }
1309 if (abilityRequest.abilityInfo.launchMode != AppExecFwk::LaunchMode::SPECIFIED) {
1310 return;
1311 }
1312 auto callerAbility = GetAbilityRecordByToken(abilityRequest.callerToken);
1313 if (!flag.empty()) {
1314 abilityRequest.specifiedFlag = flag;
1315 bool reuse = false;
1316 auto currentAccountId = DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId();
1317 auto persistentId = GetReusedSpecifiedPersistentId(abilityRequest, reuse, currentAccountId);
1318 if (persistentId != 0) {
1319 auto abilityRecord = GetReusedSpecifiedAbility(want, flag);
1320 if (!abilityRecord) {
1321 return;
1322 }
1323 abilityRecord->SetWant(abilityRequest.want);
1324 abilityRecord->SetIsNewWant(true);
1325 UpdateAbilityRecordLaunchReason(abilityRequest, abilityRecord);
1326 MoveAbilityToFront(abilityRequest, abilityRecord, callerAbility);
1327 NotifyRestartSpecifiedAbility(abilityRequest, abilityRecord->GetToken());
1328 return;
1329 }
1330 }
1331 NotifyStartSpecifiedAbility(abilityRequest, want);
1332 StartAbilityBySpecifed(abilityRequest, callerAbility);
1333 }
1334
OnStartSpecifiedAbilityTimeoutResponse(const AAFwk::Want & want)1335 void UIAbilityLifecycleManager::OnStartSpecifiedAbilityTimeoutResponse(const AAFwk::Want &want)
1336 {
1337 HILOG_INFO("%{public}s called.", __func__);
1338 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1339 if (abilityQueue_.empty()) {
1340 return;
1341 }
1342 AbilityRequest &abilityRequest = abilityQueue_.front();
1343 abilityRequest.callSpecifiedFlagTimeout = true;
1344 }
1345
OnStartSpecifiedProcessResponse(const AAFwk::Want & want,const std::string & flag)1346 void UIAbilityLifecycleManager::OnStartSpecifiedProcessResponse(const AAFwk::Want &want, const std::string &flag)
1347 {
1348 HILOG_DEBUG("call.");
1349 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1350 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1351 if (abilityQueue_.empty()) {
1352 return;
1353 }
1354 AbilityRequest abilityRequest = abilityQueue_.front();
1355 abilityQueue_.pop();
1356 std::string specifiedProcessFlag = flag;
1357 if (abilityRequest.callSpecifiedFlagTimeout) {
1358 HILOG_ERROR("The abilityRequest call onNewProcessRequest timeout.");
1359 specifiedProcessFlag = "";
1360 }
1361 abilityRequest.want.SetParam(PARAM_SPECIFIED_PROCESS_FLAG, specifiedProcessFlag);
1362 auto isSpecified = (abilityRequest.abilityInfo.launchMode == AppExecFwk::LaunchMode::SPECIFIED);
1363 if (isSpecified) {
1364 EnqueueAbilityToFront(abilityRequest);
1365 DelayedSingleton<AppScheduler>::GetInstance()->StartSpecifiedAbility(
1366 abilityRequest.want, abilityRequest.abilityInfo);
1367 return;
1368 }
1369 auto sessionInfo = CreateSessionInfo(abilityRequest);
1370 sessionInfo->requestCode = abilityRequest.requestCode;
1371 sessionInfo->persistentId = GetPersistentIdByAbilityRequest(abilityRequest, sessionInfo->reuse,
1372 abilityRequest.userId);
1373 sessionInfo->userId = abilityRequest.userId;
1374 HILOG_INFO("Reused sessionId: %{public}d, userId: %{public}d.", sessionInfo->persistentId, abilityRequest.userId);
1375 NotifySCBPendingActivation(sessionInfo, abilityRequest);
1376 }
1377
OnStartSpecifiedProcessTimeoutResponse(const AAFwk::Want & want)1378 void UIAbilityLifecycleManager::OnStartSpecifiedProcessTimeoutResponse(const AAFwk::Want &want)
1379 {
1380 HILOG_INFO("%{public}s called.", __func__);
1381 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1382 HILOG_DEBUG("abilityQueue_.size() = %{public}zu", abilityQueue_.size());
1383 if (abilityQueue_.empty()) {
1384 return;
1385 }
1386 AbilityRequest &abilityRequest = abilityQueue_.front();
1387 abilityRequest.callSpecifiedFlagTimeout = true;
1388 }
1389
StartSpecifiedAbilityBySCB(const Want & want,int32_t userId)1390 void UIAbilityLifecycleManager::StartSpecifiedAbilityBySCB(const Want &want, int32_t userId)
1391 {
1392 HILOG_DEBUG("call");
1393 AbilityRequest abilityRequest;
1394 int result = DelayedSingleton<AbilityManagerService>::GetInstance()->GenerateAbilityRequest(
1395 want, DEFAULT_INVAL_VALUE, abilityRequest, nullptr, userId);
1396 if (result != ERR_OK) {
1397 HILOG_ERROR("cannot find generate ability request");
1398 return;
1399 }
1400 {
1401 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1402 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1403 EnqueueAbilityToFront(abilityRequest);
1404 }
1405 DelayedSingleton<AppScheduler>::GetInstance()->StartSpecifiedAbility(
1406 abilityRequest.want, abilityRequest.abilityInfo);
1407 }
1408
GetReusedSpecifiedAbility(const AAFwk::Want & want,const std::string & flag)1409 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManager::GetReusedSpecifiedAbility(const AAFwk::Want &want,
1410 const std::string &flag)
1411 {
1412 auto element = want.GetElement();
1413 for (const auto& [first, second] : specifiedAbilityMap_) {
1414 if (flag == first.flag && element.GetAbilityName() == first.abilityName &&
1415 element.GetBundleName() == first.bundleName) {
1416 return second;
1417 }
1418 }
1419 return nullptr;
1420 }
1421
EnqueueAbilityToFront(const AbilityRequest & abilityRequest)1422 void UIAbilityLifecycleManager::EnqueueAbilityToFront(const AbilityRequest &abilityRequest)
1423 {
1424 abilityQueue_.push(abilityRequest);
1425 }
1426
NotifyRestartSpecifiedAbility(AbilityRequest & request,const sptr<IRemoteObject> & token)1427 void UIAbilityLifecycleManager::NotifyRestartSpecifiedAbility(AbilityRequest &request,
1428 const sptr<IRemoteObject> &token)
1429 {
1430 if (request.abilityInfoCallback == nullptr) {
1431 return;
1432 }
1433 sptr<AppExecFwk::IAbilityInfoCallback> abilityInfoCallback
1434 = iface_cast<AppExecFwk::IAbilityInfoCallback> (request.abilityInfoCallback);
1435 if (abilityInfoCallback != nullptr) {
1436 HILOG_DEBUG("%{public}s called.", __func__);
1437 abilityInfoCallback->NotifyRestartSpecifiedAbility(token);
1438 }
1439 }
1440
NotifyStartSpecifiedAbility(AbilityRequest & abilityRequest,const AAFwk::Want & want)1441 void UIAbilityLifecycleManager::NotifyStartSpecifiedAbility(AbilityRequest &abilityRequest, const AAFwk::Want &want)
1442 {
1443 if (abilityRequest.abilityInfoCallback == nullptr) {
1444 return;
1445 }
1446
1447 sptr<AppExecFwk::IAbilityInfoCallback> abilityInfoCallback
1448 = iface_cast<AppExecFwk::IAbilityInfoCallback> (abilityRequest.abilityInfoCallback);
1449 if (abilityInfoCallback != nullptr) {
1450 Want newWant = want;
1451 int32_t type = static_cast<int32_t>(abilityRequest.abilityInfo.type);
1452 newWant.SetParam("abilityType", type);
1453 sptr<Want> extraParam = new (std::nothrow) Want();
1454 abilityInfoCallback->NotifyStartSpecifiedAbility(abilityRequest.callerToken, newWant,
1455 abilityRequest.requestCode, extraParam);
1456 int32_t procCode = extraParam->GetIntParam(Want::PARAM_RESV_REQUEST_PROC_CODE, 0);
1457 if (procCode != 0) {
1458 abilityRequest.want.SetParam(Want::PARAM_RESV_REQUEST_PROC_CODE, procCode);
1459 }
1460 int32_t tokenCode = extraParam->GetIntParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, 0);
1461 if (tokenCode != 0) {
1462 abilityRequest.want.SetParam(Want::PARAM_RESV_REQUEST_TOKEN_CODE, tokenCode);
1463 }
1464 }
1465 }
1466
MoveAbilityToFront(const AbilityRequest & abilityRequest,const std::shared_ptr<AbilityRecord> & abilityRecord,std::shared_ptr<AbilityRecord> callerAbility,std::shared_ptr<StartOptions> startOptions)1467 int UIAbilityLifecycleManager::MoveAbilityToFront(const AbilityRequest &abilityRequest,
1468 const std::shared_ptr<AbilityRecord> &abilityRecord, std::shared_ptr<AbilityRecord> callerAbility,
1469 std::shared_ptr<StartOptions> startOptions)
1470 {
1471 HILOG_DEBUG("call");
1472 if (!abilityRecord) {
1473 HILOG_ERROR("get target ability record failed");
1474 return ERR_INVALID_VALUE;
1475 }
1476 sptr<SessionInfo> sessionInfo = abilityRecord->GetSessionInfo();
1477 sessionInfo->want = abilityRequest.want;
1478 SendSessionInfoToSCB(callerAbility, sessionInfo);
1479 abilityRecord->RemoveWindowMode();
1480 if (startOptions != nullptr) {
1481 abilityRecord->SetWindowMode(startOptions->GetWindowMode());
1482 }
1483 return ERR_OK;
1484 }
1485
SendSessionInfoToSCB(std::shared_ptr<AbilityRecord> & callerAbility,sptr<SessionInfo> & sessionInfo)1486 int UIAbilityLifecycleManager::SendSessionInfoToSCB(std::shared_ptr<AbilityRecord> &callerAbility,
1487 sptr<SessionInfo> &sessionInfo)
1488 {
1489 HILOG_DEBUG("call");
1490 if (callerAbility != nullptr) {
1491 auto callerSessionInfo = callerAbility->GetSessionInfo();
1492 if (callerSessionInfo != nullptr && callerSessionInfo->sessionToken != nullptr) {
1493 auto callerSession = iface_cast<Rosen::ISession>(callerSessionInfo->sessionToken);
1494 callerSession->PendingSessionActivation(sessionInfo);
1495 } else {
1496 CHECK_POINTER_AND_RETURN(rootSceneSession_, ERR_INVALID_VALUE);
1497 rootSceneSession_->PendingSessionActivation(sessionInfo);
1498 }
1499 } else {
1500 CHECK_POINTER_AND_RETURN(rootSceneSession_, ERR_INVALID_VALUE);
1501 rootSceneSession_->PendingSessionActivation(sessionInfo);
1502 }
1503 return ERR_OK;
1504 }
1505
StartAbilityBySpecifed(const AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> & callerAbility)1506 int UIAbilityLifecycleManager::StartAbilityBySpecifed(const AbilityRequest &abilityRequest,
1507 std::shared_ptr<AbilityRecord> &callerAbility)
1508 {
1509 HILOG_DEBUG("call");
1510 sptr<SessionInfo> sessionInfo = new SessionInfo();
1511 sessionInfo->callerToken = abilityRequest.callerToken;
1512 sessionInfo->want = abilityRequest.want;
1513 sessionInfo->requestCode = abilityRequest.requestCode;
1514 SpecifiedInfo specifiedInfo;
1515 specifiedInfo.abilityName = abilityRequest.abilityInfo.name;
1516 specifiedInfo.bundleName = abilityRequest.abilityInfo.bundleName;
1517 specifiedInfo.flag = abilityRequest.specifiedFlag;
1518 specifiedInfoQueue_.push(specifiedInfo);
1519
1520 SendSessionInfoToSCB(callerAbility, sessionInfo);
1521 return ERR_OK;
1522 }
1523
CallRequestDone(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<IRemoteObject> & callStub)1524 void UIAbilityLifecycleManager::CallRequestDone(const std::shared_ptr<AbilityRecord> &abilityRecord,
1525 const sptr<IRemoteObject> &callStub)
1526 {
1527 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1528 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1529 if (abilityRecord == nullptr) {
1530 HILOG_ERROR("ability record is null.");
1531 return;
1532 }
1533 if (callStub == nullptr) {
1534 HILOG_ERROR("call stub is null.");
1535 return;
1536 }
1537 abilityRecord->CallRequestDone(callStub);
1538 }
1539
ReleaseCallLocked(const sptr<IAbilityConnection> & connect,const AppExecFwk::ElementName & element)1540 int UIAbilityLifecycleManager::ReleaseCallLocked(
1541 const sptr<IAbilityConnection> &connect, const AppExecFwk::ElementName &element)
1542 {
1543 HILOG_DEBUG("release call ability.");
1544 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1545 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
1546 CHECK_POINTER_AND_RETURN(connect->AsObject(), ERR_INVALID_VALUE);
1547
1548 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1549
1550 auto abilityRecords = GetAbilityRecordsByName(element);
1551 auto isExist = [connect] (const std::shared_ptr<AbilityRecord> &abilityRecord) {
1552 return abilityRecord->IsExistConnection(connect);
1553 };
1554 auto findRecord = std::find_if(abilityRecords.begin(), abilityRecords.end(), isExist);
1555 if (findRecord == abilityRecords.end()) {
1556 HILOG_ERROR("not found ability record by callback.");
1557 return RELEASE_CALL_ABILITY_INNER_ERR;
1558 }
1559 auto abilityRecord = *findRecord;
1560 CHECK_POINTER_AND_RETURN(abilityRecord, RELEASE_CALL_ABILITY_INNER_ERR);
1561
1562 if (!abilityRecord->ReleaseCall(connect)) {
1563 HILOG_ERROR("ability release call record failed.");
1564 return RELEASE_CALL_ABILITY_INNER_ERR;
1565 }
1566 return ERR_OK;
1567 }
1568
OnCallConnectDied(const std::shared_ptr<CallRecord> & callRecord)1569 void UIAbilityLifecycleManager::OnCallConnectDied(const std::shared_ptr<CallRecord> &callRecord)
1570 {
1571 HILOG_INFO("On callConnect died.");
1572 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1573 CHECK_POINTER(callRecord);
1574 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1575
1576 AppExecFwk::ElementName element = callRecord->GetTargetServiceName();
1577 auto abilityRecords = GetAbilityRecordsByName(element);
1578 auto isExist = [callRecord] (const std::shared_ptr<AbilityRecord> &abilityRecord) {
1579 return abilityRecord->IsExistConnection(callRecord->GetConCallBack());
1580 };
1581 auto findRecord = std::find_if(abilityRecords.begin(), abilityRecords.end(), isExist);
1582 if (findRecord == abilityRecords.end()) {
1583 HILOG_ERROR("not found ability record by callback");
1584 return;
1585 }
1586 auto abilityRecord = *findRecord;
1587 CHECK_POINTER(abilityRecord);
1588 abilityRecord->ReleaseCall(callRecord->GetConCallBack());
1589 }
1590
GetAbilityRecordsByName(const AppExecFwk::ElementName & element)1591 std::vector<std::shared_ptr<AbilityRecord>> UIAbilityLifecycleManager::GetAbilityRecordsByName(
1592 const AppExecFwk::ElementName &element)
1593 {
1594 std::vector<std::shared_ptr<AbilityRecord>> records;
1595 for (const auto& [first, second] : sessionAbilityMap_) {
1596 auto &abilityInfo = second->GetAbilityInfo();
1597 AppExecFwk::ElementName localElement(abilityInfo.deviceId, abilityInfo.bundleName,
1598 abilityInfo.name, abilityInfo.moduleName);
1599 AppExecFwk::ElementName localElementNoModuleName(abilityInfo.deviceId,
1600 abilityInfo.bundleName, abilityInfo.name);
1601 if (localElement == element || localElementNoModuleName == element) {
1602 HILOG_DEBUG("find element %{public}s", localElement.GetURI().c_str());
1603 records.push_back(second);
1604 }
1605 }
1606 return records;
1607 }
1608
GetSessionIdByAbilityToken(const sptr<IRemoteObject> & token)1609 int32_t UIAbilityLifecycleManager::GetSessionIdByAbilityToken(const sptr<IRemoteObject> &token)
1610 {
1611 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1612 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1613 for (const auto& [first, second] : sessionAbilityMap_) {
1614 if (second && second->GetToken()->AsObject() == token) {
1615 return first;
1616 }
1617 }
1618 HILOG_ERROR("not find");
1619 return 0;
1620 }
1621
GetActiveAbilityList(const std::string & bundleName,std::vector<std::string> & abilityList)1622 void UIAbilityLifecycleManager::GetActiveAbilityList(const std::string &bundleName,
1623 std::vector<std::string> &abilityList)
1624 {
1625 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1626 auto currentAccountId = DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId();
1627 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1628 for (const auto& [first, second] : sessionAbilityMap_) {
1629 if (second->GetOwnerMissionUserId() == currentAccountId) {
1630 const auto &abilityInfo = second->GetAbilityInfo();
1631 if (abilityInfo.bundleName == bundleName && !abilityInfo.name.empty()) {
1632 HILOG_DEBUG("find ability name is %{public}s", abilityInfo.name.c_str());
1633 abilityList.push_back(abilityInfo.name);
1634 }
1635 }
1636 }
1637 }
1638
SetRevicerInfo(const AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> & abilityRecord) const1639 void UIAbilityLifecycleManager::SetRevicerInfo(const AbilityRequest &abilityRequest,
1640 std::shared_ptr<AbilityRecord> &abilityRecord) const
1641 {
1642 const auto &abilityInfo = abilityRequest.abilityInfo;
1643 auto isStandard = abilityInfo.launchMode == AppExecFwk::LaunchMode::STANDARD && !abilityRequest.startRecent;
1644 if (!isStandard) {
1645 bool hasRecoverInfo = false;
1646 (void)DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance()->
1647 GetAbilityRecoverInfo(abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name, hasRecoverInfo);
1648 abilityRecord->UpdateRecoveryInfo(hasRecoverInfo);
1649 (void)DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance()->
1650 DeleteAbilityRecoverInfo(abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name);
1651 }
1652 }
1653
SetLastExitReason(std::shared_ptr<AbilityRecord> & abilityRecord) const1654 void UIAbilityLifecycleManager::SetLastExitReason(std::shared_ptr<AbilityRecord> &abilityRecord) const
1655 {
1656 if (abilityRecord == nullptr) {
1657 HILOG_ERROR("abilityRecord is nullptr.");
1658 return;
1659 }
1660
1661 if (abilityRecord->GetAbilityInfo().bundleName.empty()) {
1662 HILOG_ERROR("bundleName is empty.");
1663 return;
1664 }
1665
1666 Reason exitReason;
1667 bool isSetReason;
1668 DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance()->GetAppExitReason(
1669 abilityRecord->GetAbilityInfo().bundleName, abilityRecord->GetAbilityInfo().name, isSetReason, exitReason);
1670
1671 if (isSetReason) {
1672 abilityRecord->SetLastExitReason(CovertAppExitReasonToLastReason(exitReason));
1673 }
1674 }
1675
CovertAppExitReasonToLastReason(const Reason exitReason) const1676 LastExitReason UIAbilityLifecycleManager::CovertAppExitReasonToLastReason(const Reason exitReason) const
1677 {
1678 switch (exitReason) {
1679 case REASON_NORMAL:
1680 return LASTEXITREASON_NORMAL;
1681 case REASON_CPP_CRASH:
1682 return LASTEXITREASON_CPP_CRASH;
1683 case REASON_JS_ERROR:
1684 return LASTEXITREASON_JS_ERROR;
1685 case REASON_APP_FREEZE:
1686 return LASTEXITREASON_APP_FREEZE;
1687 case REASON_PERFORMANCE_CONTROL:
1688 return LASTEXITREASON_PERFORMANCE_CONTROL;
1689 case REASON_RESOURCE_CONTROL:
1690 return LASTEXITREASON_RESOURCE_CONTROL;
1691 case REASON_UPGRADE:
1692 return LASTEXITREASON_UPGRADE;
1693 case REASON_UNKNOWN:
1694 default:
1695 return LASTEXITREASON_UNKNOWN;
1696 }
1697 }
1698
PrepareTerminateAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1699 bool UIAbilityLifecycleManager::PrepareTerminateAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1700 {
1701 HILOG_DEBUG("call");
1702 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1703 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1704 if (abilityRecord == nullptr) {
1705 HILOG_ERROR("ability record is null");
1706 return false;
1707 }
1708 HILOG_INFO("abilityInfoName:%{public}s", abilityRecord->GetAbilityInfo().name.c_str());
1709 if (!CheckPrepareTerminateEnable(abilityRecord)) {
1710 HILOG_DEBUG("Not support prepare terminate.");
1711 return false;
1712 }
1713 // execute onPrepareToTerminate util timeout
1714 auto taskHandler = DelayedSingleton<AbilityManagerService>::GetInstance()->GetTaskHandler();
1715 if (taskHandler == nullptr) {
1716 HILOG_ERROR("Fail to get AbilityTaskHandler.");
1717 return false;
1718 }
1719 auto promise = std::make_shared<std::promise<bool>>();
1720 auto future = promise->get_future();
1721 auto task = [promise, abilityRecord]() {
1722 promise->set_value(abilityRecord->PrepareTerminateAbility());
1723 };
1724 taskHandler->SubmitTask(task);
1725 int prepareTerminateTimeout =
1726 AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * PREPARE_TERMINATE_TIMEOUT_MULTIPLE;
1727 std::future_status status = future.wait_for(std::chrono::milliseconds(prepareTerminateTimeout));
1728 if (status == std::future_status::timeout) {
1729 HILOG_ERROR("onPrepareToTerminate timeout.");
1730 return false;
1731 }
1732 return future.get();
1733 }
1734
CheckPrepareTerminateEnable(const std::shared_ptr<AbilityRecord> & abilityRecord)1735 bool UIAbilityLifecycleManager::CheckPrepareTerminateEnable(const std::shared_ptr<AbilityRecord> &abilityRecord)
1736 {
1737 if (abilityRecord == nullptr || abilityRecord->IsTerminating()) {
1738 HILOG_DEBUG("Ability record is not exist or is on terminating.");
1739 return false;
1740 }
1741 auto type = abilityRecord->GetAbilityInfo().type;
1742 bool isStageBasedModel = abilityRecord->GetAbilityInfo().isStageBasedModel;
1743 if (!isStageBasedModel || type != AppExecFwk::AbilityType::PAGE) {
1744 HILOG_DEBUG("ability mode not support.");
1745 return false;
1746 }
1747 auto tokenId = abilityRecord->GetApplicationInfo().accessTokenId;
1748 if (!AAFwk::PermissionVerification::GetInstance()->VerifyPrepareTerminatePermission(tokenId)) {
1749 HILOG_DEBUG("failed, please apply permission ohos.permission.PREPARE_APP_TERMINATE");
1750 return false;
1751 }
1752 return true;
1753 }
1754
SetSessionHandler(const sptr<ISessionHandler> & handler)1755 void UIAbilityLifecycleManager::SetSessionHandler(const sptr<ISessionHandler> &handler)
1756 {
1757 handler_ = handler;
1758 }
1759
GetAbilityRecordsById(int32_t sessionId) const1760 std::shared_ptr<AbilityRecord> UIAbilityLifecycleManager::GetAbilityRecordsById(int32_t sessionId) const
1761 {
1762 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1763 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1764 auto search = sessionAbilityMap_.find(sessionId);
1765 if (search == sessionAbilityMap_.end()) {
1766 HILOG_INFO("sessionId is invalid.");
1767 return nullptr;
1768 }
1769 return search->second;
1770 }
1771
GetActiveAbilityList(const std::string & bundleName,std::vector<std::string> & abilityList,int32_t targetUserId) const1772 void UIAbilityLifecycleManager::GetActiveAbilityList(const std::string &bundleName,
1773 std::vector<std::string> &abilityList, int32_t targetUserId) const
1774 {
1775 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1776 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1777 HILOG_INFO("Call.");
1778 for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) {
1779 if (abilityRecord == nullptr) {
1780 HILOG_WARN("second is nullptr.");
1781 continue;
1782 }
1783 const auto &abilityInfo = abilityRecord->GetAbilityInfo();
1784 if (abilityInfo.bundleName == bundleName && !abilityInfo.name.empty() &&
1785 (targetUserId == DEFAULT_USER_ID || abilityRecord->GetOwnerMissionUserId() == targetUserId)) {
1786 HILOG_DEBUG("find ability name is %{public}s", abilityInfo.name.c_str());
1787 abilityList.push_back(abilityInfo.name);
1788 }
1789 }
1790 if (!abilityList.empty()) {
1791 sort(abilityList.begin(), abilityList.end());
1792 abilityList.erase(unique(abilityList.begin(), abilityList.end()), abilityList.end());
1793 }
1794 }
1795
OnAppStateChanged(const AppInfo & info,int32_t targetUserId)1796 void UIAbilityLifecycleManager::OnAppStateChanged(const AppInfo &info, int32_t targetUserId)
1797 {
1798 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1799 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1800 HILOG_DEBUG("Call.");
1801 if (info.state == AppState::TERMINATED || info.state == AppState::END) {
1802 for (const auto& abilityRecord : terminateAbilityList_) {
1803 if (abilityRecord == nullptr) {
1804 HILOG_WARN("the abilityRecord is nullptr.");
1805 continue;
1806 }
1807 if ((info.processName == abilityRecord->GetAbilityInfo().process ||
1808 info.processName == abilityRecord->GetApplicationInfo().bundleName) &&
1809 targetUserId == abilityRecord->GetOwnerMissionUserId()) {
1810 abilityRecord->SetAppState(info.state);
1811 }
1812 }
1813 return;
1814 }
1815 for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) {
1816 if (abilityRecord == nullptr) {
1817 HILOG_WARN("abilityRecord is nullptr.");
1818 continue;
1819 }
1820 if ((info.processName == abilityRecord->GetAbilityInfo().process ||
1821 info.processName == abilityRecord->GetApplicationInfo().bundleName) &&
1822 targetUserId == abilityRecord->GetOwnerMissionUserId()) {
1823 abilityRecord->SetAppState(info.state);
1824 }
1825 }
1826 }
1827
UninstallApp(const std::string & bundleName,int32_t uid,int32_t targetUserId)1828 void UIAbilityLifecycleManager::UninstallApp(const std::string &bundleName, int32_t uid, int32_t targetUserId)
1829 {
1830 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1831 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1832 HILOG_INFO("Call.");
1833 for (auto it = sessionAbilityMap_.begin(); it != sessionAbilityMap_.end();) {
1834 if (it->second == nullptr) {
1835 it++;
1836 continue;
1837 }
1838 auto &abilityInfo = it->second->GetAbilityInfo();
1839 if (abilityInfo.bundleName == bundleName && it->second->GetUid() == uid &&
1840 (targetUserId == DEFAULT_USER_ID || it->second->GetOwnerMissionUserId() == targetUserId)) {
1841 (void)DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance()->
1842 DeleteAbilityRecoverInfo(abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name);
1843 }
1844 it++;
1845 }
1846 }
1847
GetAbilityRunningInfos(std::vector<AbilityRunningInfo> & info,bool isPerm,int32_t userId) const1848 void UIAbilityLifecycleManager::GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info, bool isPerm,
1849 int32_t userId) const
1850 {
1851 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1852 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1853 HILOG_DEBUG("Call.");
1854 for (auto [sessionId, abilityRecord] : sessionAbilityMap_) {
1855 if (abilityRecord == nullptr || userId != abilityRecord->GetOwnerMissionUserId()) {
1856 HILOG_WARN("abilityRecord is nullptr.");
1857 continue;
1858 }
1859 if (isPerm) {
1860 DelayedSingleton<AbilityManagerService>::GetInstance()->GetAbilityRunningInfo(info, abilityRecord);
1861 } else {
1862 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
1863 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
1864 if (callingTokenId == tokenID) {
1865 DelayedSingleton<AbilityManagerService>::GetInstance()->GetAbilityRunningInfo(info, abilityRecord);
1866 }
1867 }
1868 }
1869 }
1870
1871 #ifdef ABILITY_COMMAND_FOR_TEST
BlockAbility(int32_t abilityRecordId,int32_t targetUserId) const1872 int UIAbilityLifecycleManager::BlockAbility(int32_t abilityRecordId, int32_t targetUserId) const
1873 {
1874 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1875 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1876 HILOG_INFO("Call.");
1877 for (const auto& [first, second] : sessionAbilityMap_) {
1878 if (second == nullptr) {
1879 HILOG_WARN("abilityRecord is nullptr.");
1880 continue;
1881 }
1882 if (second->GetRecordId() == abilityRecordId && targetUserId == abilityRecord->GetOwnerMissionUserId()) {
1883 HILOG_INFO("Call BlockAbility.");
1884 return second->BlockAbility();
1885 }
1886 }
1887 HILOG_ERROR("The abilityRecordId is invalid.");
1888 return -1;
1889 }
1890 #endif
1891
Dump(std::vector<std::string> & info)1892 void UIAbilityLifecycleManager::Dump(std::vector<std::string> &info)
1893 {
1894 HILOG_INFO("Call begin.");
1895 std::unordered_map<int32_t, std::shared_ptr<AbilityRecord>> sessionAbilityMapLocked;
1896 {
1897 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1898 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1899 for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) {
1900 sessionAbilityMapLocked[sessionId] = abilityRecord;
1901 }
1902 }
1903
1904 int userId = DelayedSingleton<AbilityManagerService>::GetInstance()->GetUserId();
1905 std::string dumpInfo = "User ID #" + std::to_string(userId);
1906 info.push_back(dumpInfo);
1907 dumpInfo = " current mission lists:{";
1908 info.push_back(dumpInfo);
1909
1910 for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) {
1911 if (abilityRecord == nullptr) {
1912 HILOG_WARN("abilityRecord is nullptr.");
1913 continue;
1914 }
1915 if (abilityRecord->GetOwnerMissionUserId() != userId) {
1916 continue;
1917 }
1918
1919 sptr<SessionInfo> sessionInfo = abilityRecord->GetSessionInfo();
1920 dumpInfo = " Mission ID #" + std::to_string(sessionId);
1921 if (sessionInfo) {
1922 dumpInfo += " mission name #[" + sessionInfo->sessionName + "]";
1923 }
1924 dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState());
1925 dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]";
1926 info.push_back(dumpInfo);
1927
1928 abilityRecord->Dump(info);
1929
1930 dumpInfo = " }";
1931 info.push_back(dumpInfo);
1932 }
1933 }
1934
DumpMissionList(std::vector<std::string> & info,bool isClient,int userId,const std::string & args)1935 void UIAbilityLifecycleManager::DumpMissionList(
1936 std::vector<std::string> &info, bool isClient, int userId, const std::string &args)
1937 {
1938 HILOG_INFO("Call start.");
1939 std::unordered_map<int32_t, std::shared_ptr<AbilityRecord>> sessionAbilityMapLocked;
1940 {
1941 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1942 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1943 for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) {
1944 sessionAbilityMapLocked[sessionId] = abilityRecord;
1945 }
1946 }
1947 std::string dumpInfo = "User ID #" + std::to_string(userId);
1948 info.push_back(dumpInfo);
1949 dumpInfo = " current mission lists:{";
1950 info.push_back(dumpInfo);
1951
1952 for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) {
1953 if (abilityRecord == nullptr) {
1954 HILOG_WARN("abilityRecord is nullptr.");
1955 continue;
1956 }
1957 if (abilityRecord->GetOwnerMissionUserId() != userId) {
1958 continue;
1959 }
1960 sptr<SessionInfo> sessionInfo = abilityRecord->GetSessionInfo();
1961 dumpInfo = " Mission ID #" + std::to_string(sessionId);
1962 if (sessionInfo) {
1963 dumpInfo += " mission name #[" + sessionInfo->sessionName + "]";
1964 }
1965 dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState());
1966 dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]";
1967 info.push_back(dumpInfo);
1968
1969 std::vector<std::string> params;
1970 abilityRecord->DumpAbilityState(info, isClient, params);
1971
1972 dumpInfo = " }";
1973 info.push_back(dumpInfo);
1974 }
1975 }
1976
DumpMissionListByRecordId(std::vector<std::string> & info,bool isClient,int32_t abilityRecordId,const std::vector<std::string> & params,int userId)1977 void UIAbilityLifecycleManager::DumpMissionListByRecordId(std::vector<std::string> &info, bool isClient,
1978 int32_t abilityRecordId, const std::vector<std::string> ¶ms, int userId)
1979 {
1980 HILOG_INFO("Call.");
1981 std::unordered_map<int32_t, std::shared_ptr<AbilityRecord>> sessionAbilityMapLocked;
1982 {
1983 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1984 std::lock_guard<ffrt::mutex> guard(sessionLock_);
1985 for (const auto& [sessionId, abilityRecord] : sessionAbilityMap_) {
1986 sessionAbilityMapLocked[sessionId] = abilityRecord;
1987 }
1988 }
1989 std::string dumpInfo = "User ID #" + std::to_string(userId);
1990 info.push_back(dumpInfo);
1991 dumpInfo = " current mission lists:{";
1992 info.push_back(dumpInfo);
1993
1994 for (const auto& [sessionId, abilityRecord] : sessionAbilityMapLocked) {
1995 if (abilityRecord == nullptr) {
1996 HILOG_WARN("abilityRecord is nullptr.");
1997 continue;
1998 }
1999 if (abilityRecord->GetAbilityRecordId() != abilityRecordId) {
2000 continue;
2001 }
2002 sptr<SessionInfo> sessionInfo = abilityRecord->GetSessionInfo();
2003 dumpInfo = " Mission ID #" + std::to_string(sessionId);
2004 if (sessionInfo) {
2005 dumpInfo += " mission name #[" + sessionInfo->sessionName + "]";
2006 }
2007 dumpInfo += " lockedState #" + std::to_string(abilityRecord->GetLockedState());
2008 dumpInfo += " mission affinity #[" + abilityRecord->GetMissionAffinity() + "]";
2009 info.push_back(dumpInfo);
2010
2011 abilityRecord->DumpAbilityState(info, isClient, params);
2012
2013 dumpInfo = " }";
2014 info.push_back(dumpInfo);
2015 }
2016 }
2017
MoveMissionToFront(int32_t sessionId,std::shared_ptr<StartOptions> startOptions)2018 int UIAbilityLifecycleManager::MoveMissionToFront(int32_t sessionId, std::shared_ptr<StartOptions> startOptions)
2019 {
2020 CHECK_POINTER_AND_RETURN(rootSceneSession_, ERR_INVALID_VALUE);
2021 std::shared_ptr<AbilityRecord> abilityRecord = GetAbilityRecordsById(sessionId);
2022 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
2023 if (startOptions != nullptr) {
2024 abilityRecord->SetWindowMode(startOptions->GetWindowMode());
2025 }
2026 sptr<SessionInfo> sessionInfo = abilityRecord->GetSessionInfo();
2027 CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE);
2028 HILOG_INFO("Call PendingSessionActivation by rootSceneSession.");
2029 return static_cast<int>(rootSceneSession_->PendingSessionActivation(sessionInfo));
2030 }
2031
SetDevice(std::string deviceType)2032 void UIAbilityLifecycleManager::SetDevice(std::string deviceType)
2033 {
2034 isPcDevice_ = (deviceType == "pc" || deviceType == "2in1");
2035 }
2036
UpdateSessionInfoBySCB(const std::vector<SessionInfo> & sessionInfos,int32_t userId)2037 void UIAbilityLifecycleManager::UpdateSessionInfoBySCB(const std::vector<SessionInfo> &sessionInfos, int32_t userId)
2038 {
2039 auto SearchFunc = [] (const std::vector<SessionInfo> &sessionInfos, int32_t sessionId) -> sptr<IRemoteObject> {
2040 for (const auto& info : sessionInfos) {
2041 if (info.persistentId == sessionId) {
2042 return info.sessionToken;
2043 }
2044 }
2045 return nullptr;
2046 };
2047 std::unordered_set<std::shared_ptr<AbilityRecord>> abilitySet;
2048 {
2049 std::lock_guard<ffrt::mutex> guard(sessionLock_);
2050 for (auto [sessionId, abilityRecord] : sessionAbilityMap_) {
2051 if (abilityRecord->GetOwnerMissionUserId() != userId) {
2052 continue;
2053 }
2054 auto searchRet = SearchFunc(sessionInfos, sessionId);
2055 if (searchRet != nullptr) {
2056 abilityRecord->UpdateSessionInfo(searchRet);
2057 } else {
2058 abilitySet.emplace(abilityRecord);
2059 }
2060 }
2061 }
2062 for (auto ability : abilitySet) {
2063 CloseUIAbility(ability, -1, nullptr, false);
2064 }
2065 HILOG_INFO("The end of updating session info.");
2066 }
2067 } // namespace AAFwk
2068 } // namespace OHOS