1 /*
2 * Copyright (c) 2021-2024 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 "ability_connect_manager.h"
17
18 #include <regex>
19
20 #include "ability_manager_service.h"
21 #include "ability_resident_process_rdb.h"
22 #include "appfreeze_manager.h"
23 #include "app_exit_reason_data_manager.h"
24 #include "assert_fault_callback_death_mgr.h"
25 #include "hitrace_meter.h"
26 #include "int_wrapper.h"
27 #include "param.h"
28 #include "res_sched_util.h"
29 #include "session/host/include/zidl/session_interface.h"
30 #include "startup_util.h"
31 #include "ui_extension_utils.h"
32 #include "ui_service_extension_connection_constants.h"
33 #include "cache_extension_utils.h"
34 #include "datetime_ex.h"
35 #include "init_reboot.h"
36
37 namespace OHOS {
38 namespace AAFwk {
39 namespace {
40 constexpr char EVENT_KEY_UID[] = "UID";
41 constexpr char EVENT_KEY_PID[] = "PID";
42 constexpr char EVENT_KEY_MESSAGE[] = "MSG";
43 constexpr char EVENT_KEY_PACKAGE_NAME[] = "PACKAGE_NAME";
44 constexpr char EVENT_KEY_PROCESS_NAME[] = "PROCESS_NAME";
45 const std::string DEBUG_APP = "debugApp";
46 const std::string FRS_APP_INDEX = "ohos.extra.param.key.frs_index";
47 const std::string FRS_BUNDLE_NAME = "com.ohos.formrenderservice";
48 const std::string UIEXTENSION_ABILITY_ID = "ability.want.params.uiExtensionAbilityId";
49 const std::string UIEXTENSION_ROOT_HOST_PID = "ability.want.params.uiExtensionRootHostPid";
50 const std::string MAX_UINT64_VALUE = "18446744073709551615";
51 const std::string IS_PRELOAD_UIEXTENSION_ABILITY = "ability.want.params.is_preload_uiextension_ability";
52 const std::string SEPARATOR = ":";
53 #ifdef SUPPORT_ASAN
54 const int LOAD_TIMEOUT_MULTIPLE = 150;
55 const int CONNECT_TIMEOUT_MULTIPLE = 45;
56 const int COMMAND_TIMEOUT_MULTIPLE = 75;
57 const int COMMAND_WINDOW_TIMEOUT_MULTIPLE = 75;
58 #else
59 const int LOAD_TIMEOUT_MULTIPLE = 10;
60 const int CONNECT_TIMEOUT_MULTIPLE = 10;
61 const int COMMAND_TIMEOUT_MULTIPLE = 5;
62 const int COMMAND_WINDOW_TIMEOUT_MULTIPLE = 5;
63 #endif
64 const int32_t AUTO_DISCONNECT_INFINITY = -1;
65 constexpr const char* FROZEN_WHITE_DIALOG = "com.huawei.hmos.huaweicast";
66 constexpr char BUNDLE_NAME_DIALOG[] = "com.ohos.amsdialog";
67 constexpr char ABILITY_NAME_ASSERT_FAULT_DIALOG[] = "AssertFaultDialog";
68 constexpr const char* WANT_PARAMS_APP_RESTART_FLAG = "ohos.aafwk.app.restart";
69
70 const std::string XIAOYI_BUNDLE_NAME = "com.huawei.hmos.vassistant";
71
IsSpecialAbility(const AppExecFwk::AbilityInfo & abilityInfo)72 bool IsSpecialAbility(const AppExecFwk::AbilityInfo &abilityInfo)
73 {
74 std::vector<std::pair<std::string, std::string>> trustAbilities{
75 { AbilityConfig::SCENEBOARD_BUNDLE_NAME, AbilityConfig::SCENEBOARD_ABILITY_NAME },
76 { AbilityConfig::SYSTEM_UI_BUNDLE_NAME, AbilityConfig::SYSTEM_UI_ABILITY_NAME },
77 { AbilityConfig::LAUNCHER_BUNDLE_NAME, AbilityConfig::LAUNCHER_ABILITY_NAME }
78 };
79 for (const auto &pair : trustAbilities) {
80 if (pair.first == abilityInfo.bundleName && pair.second == abilityInfo.name) {
81 return true;
82 }
83 }
84 return false;
85 }
86 }
87
AbilityConnectManager(int userId)88 AbilityConnectManager::AbilityConnectManager(int userId) : userId_(userId)
89 {
90 uiExtensionAbilityRecordMgr_ = std::make_unique<AbilityRuntime::ExtensionRecordManager>(userId);
91 }
92
~AbilityConnectManager()93 AbilityConnectManager::~AbilityConnectManager()
94 {}
95
StartAbility(const AbilityRequest & abilityRequest)96 int AbilityConnectManager::StartAbility(const AbilityRequest &abilityRequest)
97 {
98 std::lock_guard guard(serialMutex_);
99 return StartAbilityLocked(abilityRequest);
100 }
101
TerminateAbility(const sptr<IRemoteObject> & token)102 int AbilityConnectManager::TerminateAbility(const sptr<IRemoteObject> &token)
103 {
104 std::lock_guard guard(serialMutex_);
105 return TerminateAbilityInner(token);
106 }
107
TerminateAbilityInner(const sptr<IRemoteObject> & token)108 int AbilityConnectManager::TerminateAbilityInner(const sptr<IRemoteObject> &token)
109 {
110 auto abilityRecord = GetExtensionByTokenFromServiceMap(token);
111 if (abilityRecord == nullptr) {
112 abilityRecord = GetExtensionByTokenFromAbilityCache(token);
113 }
114 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
115 std::string element = abilityRecord->GetURI();
116 TAG_LOGD(AAFwkTag::ABILITYMGR, "Terminate ability, ability is %{public}s.", element.c_str());
117 if (IsUIExtensionAbility(abilityRecord)) {
118 if (!abilityRecord->IsConnectListEmpty()) {
119 TAG_LOGI(AAFwkTag::ABILITYMGR, "There exist connection, don't terminate.");
120 return ERR_OK;
121 } else if (abilityRecord->IsAbilityState(AbilityState::FOREGROUND) ||
122 abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING) ||
123 abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING)) {
124 TAG_LOGI(AAFwkTag::ABILITYMGR, "current ability is active");
125 DoBackgroundAbilityWindow(abilityRecord, abilityRecord->GetSessionInfo());
126 MoveToTerminatingMap(abilityRecord);
127 return ERR_OK;
128 }
129 }
130 MoveToTerminatingMap(abilityRecord);
131 return TerminateAbilityLocked(token);
132 }
133
StopServiceAbility(const AbilityRequest & abilityRequest)134 int AbilityConnectManager::StopServiceAbility(const AbilityRequest &abilityRequest)
135 {
136 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
137 std::lock_guard guard(serialMutex_);
138 return StopServiceAbilityLocked(abilityRequest);
139 }
140
StartAbilityLocked(const AbilityRequest & abilityRequest)141 int AbilityConnectManager::StartAbilityLocked(const AbilityRequest &abilityRequest)
142 {
143 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
144 TAG_LOGD(AAFwkTag::ABILITYMGR, "ability_name:%{public}s", abilityRequest.want.GetElement().GetURI().c_str());
145
146 std::shared_ptr<AbilityRecord> targetService;
147 bool isLoadedAbility = false;
148 if (UIExtensionUtils::IsUIExtension(abilityRequest.abilityInfo.extensionAbilityType)) {
149 auto callerAbilityRecord = AAFwk::Token::GetAbilityRecordByToken(abilityRequest.callerToken);
150 if (callerAbilityRecord == nullptr) {
151 TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to get callerAbilityRecord.");
152 return ERR_NULL_OBJECT;
153 }
154 std::string hostBundleName = callerAbilityRecord->GetAbilityInfo().bundleName;
155 int32_t ret = GetOrCreateExtensionRecord(abilityRequest, false, hostBundleName, targetService, isLoadedAbility);
156 if (ret != ERR_OK) {
157 TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to get or create extension record, ret: %{public}d", ret);
158 return ret;
159 }
160 } else {
161 GetOrCreateServiceRecord(abilityRequest, false, targetService, isLoadedAbility);
162 }
163 CHECK_POINTER_AND_RETURN(targetService, ERR_INVALID_VALUE);
164 TAG_LOGI(AAFwkTag::ABILITYMGR, "Start ability: %{public}s", targetService->GetURI().c_str());
165
166 targetService->AddCallerRecord(abilityRequest.callerToken, abilityRequest.requestCode, abilityRequest.want);
167
168 targetService->SetLaunchReason(LaunchReason::LAUNCHREASON_START_EXTENSION);
169
170 targetService->DoBackgroundAbilityWindowDelayed(false);
171
172 targetService->SetSessionInfo(abilityRequest.sessionInfo);
173
174 if (IsUIExtensionAbility(targetService) && abilityRequest.sessionInfo && abilityRequest.sessionInfo->sessionToken) {
175 auto &remoteObj = abilityRequest.sessionInfo->sessionToken;
176 {
177 std::lock_guard guard(uiExtensionMapMutex_);
178 uiExtensionMap_[remoteObj] = UIExtWindowMapValType(targetService, abilityRequest.sessionInfo);
179 }
180 AddUIExtWindowDeathRecipient(remoteObj);
181 }
182
183 auto &abilityInfo = abilityRequest.abilityInfo;
184 auto ret = ReportXiaoYiToRSSIfNeeded(abilityInfo);
185 if (ret != ERR_OK) {
186 return ret;
187 }
188
189 if (!isLoadedAbility) {
190 TAG_LOGD(AAFwkTag::ABILITYMGR, "Target service has not been loaded.");
191 SetLastExitReason(abilityRequest, targetService);
192 if (IsUIExtensionAbility(targetService)) {
193 targetService->SetLaunchReason(LaunchReason::LAUNCHREASON_START_ABILITY);
194 }
195 targetService->GrantUriPermissionForServiceExtension();
196 LoadAbility(targetService);
197 } else if (targetService->IsAbilityState(AbilityState::ACTIVE) && !IsUIExtensionAbility(targetService)) {
198 // It may have been started through connect
199 targetService->SetWant(abilityRequest.want);
200 targetService->GrantUriPermissionForServiceExtension();
201 CommandAbility(targetService);
202 } else if (IsUIExtensionAbility(targetService)) {
203 DoForegroundUIExtension(targetService, abilityRequest);
204 } else {
205 TAG_LOGI(AAFwkTag::ABILITYMGR, "Target service is already activating.");
206 EnqueueStartServiceReq(abilityRequest);
207 return ERR_OK;
208 }
209
210 sptr<Token> token = targetService->GetToken();
211 sptr<Token> preToken = nullptr;
212 if (targetService->GetPreAbilityRecord()) {
213 preToken = targetService->GetPreAbilityRecord()->GetToken();
214 }
215 DelayedSingleton<AppScheduler>::GetInstance()->AbilityBehaviorAnalysis(token, preToken, 0, 1, 1);
216 return ERR_OK;
217 }
218
SetLastExitReason(const AbilityRequest & abilityRequest,std::shared_ptr<AbilityRecord> & targetRecord)219 void AbilityConnectManager::SetLastExitReason(
220 const AbilityRequest &abilityRequest, std::shared_ptr<AbilityRecord> &targetRecord)
221 {
222 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
223 if (targetRecord == nullptr || !UIExtensionUtils::IsUIExtension(abilityRequest.abilityInfo.extensionAbilityType)) {
224 TAG_LOGD(AAFwkTag::ABILITYMGR, "Failed to set UIExtensionAbility last exit reason.");
225 return;
226 }
227 auto appExitReasonDataMgr = DelayedSingleton<AbilityRuntime::AppExitReasonDataManager>::GetInstance();
228 if (appExitReasonDataMgr == nullptr) {
229 TAG_LOGE(AAFwkTag::ABILITYMGR, "Get app exit reason data mgr instance is nullptr.");
230 return;
231 }
232
233 ExitReason exitReason = { REASON_UNKNOWN, "" };
234 const std::string keyEx = targetRecord->GetAbilityInfo().bundleName + SEPARATOR +
235 targetRecord->GetAbilityInfo().moduleName + SEPARATOR +
236 targetRecord->GetAbilityInfo().name;
237 if (!appExitReasonDataMgr->GetUIExtensionAbilityExitReason(keyEx, exitReason)) {
238 TAG_LOGD(AAFwkTag::ABILITYMGR, "There is no record of UIExtensionAbility's last exit reason in the database.");
239 return;
240 }
241 targetRecord->SetLastExitReason(exitReason);
242 }
243
DoForegroundUIExtension(std::shared_ptr<AbilityRecord> abilityRecord,const AbilityRequest & abilityRequest)244 void AbilityConnectManager::DoForegroundUIExtension(std::shared_ptr<AbilityRecord> abilityRecord,
245 const AbilityRequest &abilityRequest)
246 {
247 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
248 CHECK_POINTER(abilityRecord);
249 CHECK_POINTER(abilityRequest.sessionInfo);
250 auto abilitystateStr = abilityRecord->ConvertAbilityState(abilityRecord->GetAbilityState());
251 TAG_LOGI(AAFwkTag::ABILITYMGR,
252 "Foreground ability: %{public}s, persistentId: %{public}d, abilityState: %{public}s",
253 abilityRecord->GetURI().c_str(), abilityRequest.sessionInfo->persistentId, abilitystateStr.c_str());
254 if (abilityRecord->IsReady() && !abilityRecord->IsAbilityState(AbilityState::INACTIVATING) &&
255 !abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING) &&
256 !abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING) &&
257 abilityRecord->IsAbilityWindowReady()) {
258 if (abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) {
259 abilityRecord->SetWant(abilityRequest.want);
260 CommandAbilityWindow(abilityRecord, abilityRequest.sessionInfo, WIN_CMD_FOREGROUND);
261 return;
262 } else {
263 abilityRecord->SetWant(abilityRequest.want);
264 abilityRecord->PostUIExtensionAbilityTimeoutTask(AbilityManagerService::FOREGROUND_TIMEOUT_MSG);
265 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(abilityRecord->GetToken());
266 return;
267 }
268 }
269 EnqueueStartServiceReq(abilityRequest, abilityRecord->GetURI());
270 }
271
EnqueueStartServiceReq(const AbilityRequest & abilityRequest,const std::string & serviceUri)272 void AbilityConnectManager::EnqueueStartServiceReq(const AbilityRequest &abilityRequest, const std::string &serviceUri)
273 {
274 std::lock_guard guard(startServiceReqListLock_);
275 auto abilityUri = abilityRequest.want.GetElement().GetURI();
276 if (!serviceUri.empty()) {
277 abilityUri = serviceUri;
278 }
279 TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityUri is %{public}s", abilityUri.c_str());
280 auto reqListIt = startServiceReqList_.find(abilityUri);
281 if (reqListIt != startServiceReqList_.end()) {
282 reqListIt->second->push_back(abilityRequest);
283 } else {
284 auto reqList = std::make_shared<std::list<AbilityRequest>>();
285 reqList->push_back(abilityRequest);
286 startServiceReqList_.emplace(abilityUri, reqList);
287
288 CHECK_POINTER(taskHandler_);
289 auto callback = [abilityUri, connectManager = shared_from_this()]() {
290 std::lock_guard guard{connectManager->startServiceReqListLock_};
291 auto exist = connectManager->startServiceReqList_.erase(abilityUri);
292 if (exist) {
293 TAG_LOGE(AAFwkTag::ABILITYMGR, "Target service %{public}s start timeout", abilityUri.c_str());
294 }
295 };
296
297 int connectTimeout =
298 AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * CONNECT_TIMEOUT_MULTIPLE;
299 taskHandler_->SubmitTask(callback, std::string("start_service_timeout:") + abilityUri,
300 connectTimeout);
301 }
302 }
303
TerminateAbilityLocked(const sptr<IRemoteObject> & token)304 int AbilityConnectManager::TerminateAbilityLocked(const sptr<IRemoteObject> &token)
305 {
306 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
307 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
308 auto abilityRecord = GetExtensionByTokenFromTerminatingMap(token);
309 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
310
311 if (abilityRecord->IsTerminating()) {
312 TAG_LOGD(AAFwkTag::ABILITYMGR, "Ability is on terminating.");
313 return ERR_OK;
314 }
315
316 if (!abilityRecord->GetConnectRecordList().empty()) {
317 TAG_LOGI(AAFwkTag::ABILITYMGR, "Target service has been connected. Post disconnect task.");
318 auto connectRecordList = abilityRecord->GetConnectRecordList();
319 HandleTerminateDisconnectTask(connectRecordList);
320 }
321
322 auto timeoutTask = [abilityRecord, connectManager = shared_from_this()]() {
323 TAG_LOGW(AAFwkTag::ABILITYMGR, "Disconnect ability terminate timeout.");
324 connectManager->HandleStopTimeoutTask(abilityRecord);
325 };
326 abilityRecord->Terminate(timeoutTask);
327 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
328 AddUIExtensionAbilityRecordToTerminatedList(abilityRecord);
329 } else {
330 RemoveUIExtensionAbilityRecord(abilityRecord);
331 }
332
333 return ERR_OK;
334 }
335
StopServiceAbilityLocked(const AbilityRequest & abilityRequest)336 int AbilityConnectManager::StopServiceAbilityLocked(const AbilityRequest &abilityRequest)
337 {
338 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
339 TAG_LOGI(AAFwkTag::ABILITYMGR, "call");
340 AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, GenerateBundleName(abilityRequest),
341 abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
342 std::string serviceKey = element.GetURI();
343 if (FRS_BUNDLE_NAME == abilityRequest.abilityInfo.bundleName) {
344 serviceKey = serviceKey + std::to_string(abilityRequest.want.GetIntParam(FRS_APP_INDEX, 0));
345 }
346 auto abilityRecord = GetServiceRecordByElementName(serviceKey);
347 if (abilityRecord == nullptr) {
348 abilityRecord = AbilityCacheManager::GetInstance().Get(abilityRequest);
349 AddToServiceMap(serviceKey, abilityRecord);
350 }
351 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
352
353 if (abilityRecord->IsTerminating()) {
354 TAG_LOGI(AAFwkTag::ABILITYMGR, "Ability is on terminating.");
355 return ERR_OK;
356 }
357
358 if (!abilityRecord->GetConnectRecordList().empty()) {
359 TAG_LOGI(AAFwkTag::ABILITYMGR, "Post disconnect task.");
360 auto connectRecordList = abilityRecord->GetConnectRecordList();
361 HandleTerminateDisconnectTask(connectRecordList);
362 }
363
364 TerminateRecord(abilityRecord);
365 EventInfo eventInfo = BuildEventInfo(abilityRecord);
366 EventReport::SendStopServiceEvent(EventName::STOP_SERVICE, eventInfo);
367 return ERR_OK;
368 }
369
GetOrCreateExtensionRecord(const AbilityRequest & abilityRequest,bool isCreatedByConnect,const std::string & hostBundleName,std::shared_ptr<AbilityRecord> & extensionRecord,bool & isLoaded)370 int32_t AbilityConnectManager::GetOrCreateExtensionRecord(const AbilityRequest &abilityRequest, bool isCreatedByConnect,
371 const std::string &hostBundleName, std::shared_ptr<AbilityRecord> &extensionRecord, bool &isLoaded)
372 {
373 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
374 AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, abilityRequest.abilityInfo.bundleName,
375 abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
376 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
377 if (uiExtensionAbilityRecordMgr_->IsBelongToManager(abilityRequest.abilityInfo)) {
378 int32_t ret = uiExtensionAbilityRecordMgr_->GetOrCreateExtensionRecord(
379 abilityRequest, hostBundleName, extensionRecord, isLoaded);
380 if (ret != ERR_OK) {
381 return ret;
382 }
383 extensionRecord->SetCreateByConnectMode(isCreatedByConnect);
384 std::string extensionRecordKey = element.GetURI() + std::to_string(extensionRecord->GetUIExtensionAbilityId());
385 extensionRecord->SetURI(extensionRecordKey);
386 TAG_LOGD(AAFwkTag::ABILITYMGR, "Service map add, hostBundleName:%{public}s, key: %{public}s",
387 hostBundleName.c_str(), extensionRecordKey.c_str());
388 AddToServiceMap(extensionRecordKey, extensionRecord);
389 if (IsAbilityNeedKeepAlive(extensionRecord)) {
390 extensionRecord->SetRestartTime(abilityRequest.restartTime);
391 extensionRecord->SetRestartCount(abilityRequest.restartCount);
392 }
393 return ERR_OK;
394 }
395 return ERR_INVALID_VALUE;
396 }
397
GetOrCreateServiceRecord(const AbilityRequest & abilityRequest,const bool isCreatedByConnect,std::shared_ptr<AbilityRecord> & targetService,bool & isLoadedAbility)398 void AbilityConnectManager::GetOrCreateServiceRecord(const AbilityRequest &abilityRequest,
399 const bool isCreatedByConnect, std::shared_ptr<AbilityRecord> &targetService, bool &isLoadedAbility)
400 {
401 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
402 // lifecycle is not complete when window extension is reused
403 bool noReuse = UIExtensionUtils::IsWindowExtension(abilityRequest.abilityInfo.extensionAbilityType);
404 AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, GenerateBundleName(abilityRequest),
405 abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
406 std::string serviceKey = element.GetURI();
407 if (FRS_BUNDLE_NAME == abilityRequest.abilityInfo.bundleName) {
408 serviceKey = element.GetURI() + std::to_string(abilityRequest.want.GetIntParam(FRS_APP_INDEX, 0));
409 }
410 {
411 std::lock_guard lock(serviceMapMutex_);
412 auto serviceMapIter = serviceMap_.find(serviceKey);
413 targetService = serviceMapIter == serviceMap_.end() ? nullptr : serviceMapIter->second;
414 }
415 if (targetService == nullptr &&
416 CacheExtensionUtils::IsCacheExtensionType(abilityRequest.abilityInfo.extensionAbilityType)) {
417 targetService = AbilityCacheManager::GetInstance().Get(abilityRequest);
418 if (targetService != nullptr) {
419 AddToServiceMap(serviceKey, targetService);
420 }
421 }
422 if (noReuse && targetService) {
423 if (IsSpecialAbility(abilityRequest.abilityInfo)) {
424 TAG_LOGI(AAFwkTag::ABILITYMGR, "Removing ability: %{public}s", element.GetURI().c_str());
425 }
426 std::lock_guard lock(serviceMapMutex_);
427 serviceMap_.erase(serviceKey);
428 }
429 isLoadedAbility = true;
430 if (noReuse || targetService == nullptr) {
431 targetService = AbilityRecord::CreateAbilityRecord(abilityRequest);
432 CHECK_POINTER(targetService);
433 targetService->SetOwnerMissionUserId(userId_);
434 if (isCreatedByConnect) {
435 targetService->SetCreateByConnectMode();
436 }
437 if (abilityRequest.abilityInfo.name == AbilityConfig::LAUNCHER_ABILITY_NAME) {
438 targetService->SetLauncherRoot();
439 targetService->SetRestartTime(abilityRequest.restartTime);
440 targetService->SetRestartCount(abilityRequest.restartCount);
441 } else if (IsAbilityNeedKeepAlive(targetService)) {
442 targetService->SetRestartTime(abilityRequest.restartTime);
443 targetService->SetRestartCount(abilityRequest.restartCount);
444 }
445 AddToServiceMap(serviceKey, targetService);
446 isLoadedAbility = false;
447 }
448 }
449
GetConnectRecordListFromMap(const sptr<IAbilityConnection> & connect,std::list<std::shared_ptr<ConnectionRecord>> & connectRecordList)450 void AbilityConnectManager::GetConnectRecordListFromMap(
451 const sptr<IAbilityConnection> &connect, std::list<std::shared_ptr<ConnectionRecord>> &connectRecordList)
452 {
453 std::lock_guard lock(connectMapMutex_);
454 auto connectMapIter = connectMap_.find(connect->AsObject());
455 if (connectMapIter != connectMap_.end()) {
456 connectRecordList = connectMapIter->second;
457 }
458 }
459
GetOrCreateTargetServiceRecord(const AbilityRequest & abilityRequest,const sptr<UIExtensionAbilityConnectInfo> & connectInfo,std::shared_ptr<AbilityRecord> & targetService,bool & isLoadedAbility)460 int32_t AbilityConnectManager::GetOrCreateTargetServiceRecord(
461 const AbilityRequest &abilityRequest, const sptr<UIExtensionAbilityConnectInfo> &connectInfo,
462 std::shared_ptr<AbilityRecord> &targetService, bool &isLoadedAbility)
463 {
464 if (UIExtensionUtils::IsUIExtension(abilityRequest.abilityInfo.extensionAbilityType) && connectInfo != nullptr) {
465 int32_t ret = GetOrCreateExtensionRecord(
466 abilityRequest, true, connectInfo->hostBundleName, targetService, isLoadedAbility);
467 if (ret != ERR_OK || targetService == nullptr) {
468 TAG_LOGE(AAFwkTag::ABILITYMGR, "Failed to get or create extension record.");
469 return ERR_NULL_OBJECT;
470 }
471 connectInfo->uiExtensionAbilityId = targetService->GetUIExtensionAbilityId();
472 TAG_LOGD(AAFwkTag::ABILITYMGR, "UIExtensionAbility id %{public}d.", connectInfo->uiExtensionAbilityId);
473 } else {
474 GetOrCreateServiceRecord(abilityRequest, true, targetService, isLoadedAbility);
475 }
476 CHECK_POINTER_AND_RETURN(targetService, ERR_INVALID_VALUE);
477 return ERR_OK;
478 }
479
PreloadUIExtensionAbilityLocked(const AbilityRequest & abilityRequest,std::string & hostBundleName)480 int AbilityConnectManager::PreloadUIExtensionAbilityLocked(const AbilityRequest &abilityRequest,
481 std::string &hostBundleName)
482 {
483 std::lock_guard guard(serialMutex_);
484 return PreloadUIExtensionAbilityInner(abilityRequest, hostBundleName);
485 }
486
PreloadUIExtensionAbilityInner(const AbilityRequest & abilityRequest,std::string & hostBundleName)487 int AbilityConnectManager::PreloadUIExtensionAbilityInner(const AbilityRequest &abilityRequest,
488 std::string &hostBundleName)
489 {
490 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
491 if (!UIExtensionUtils::IsUIExtension(abilityRequest.abilityInfo.extensionAbilityType)) {
492 TAG_LOGE(AAFwkTag::ABILITYMGR, "Can't preload non-uiextension type.");
493 return ERR_WRONG_INTERFACE_CALL;
494 }
495 std::shared_ptr<ExtensionRecord> extensionRecord = nullptr;
496 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
497 int32_t extensionRecordId = INVALID_EXTENSION_RECORD_ID;
498 int32_t ret = uiExtensionAbilityRecordMgr_->CreateExtensionRecord(abilityRequest, hostBundleName,
499 extensionRecord, extensionRecordId);
500 if (ret != ERR_OK) {
501 TAG_LOGE(AAFwkTag::ABILITYMGR, "CreateExtensionRecord ERR.");
502 return ret;
503 }
504 CHECK_POINTER_AND_RETURN(extensionRecord, ERR_NULL_OBJECT);
505 std::shared_ptr<AbilityRecord> targetService = extensionRecord->abilityRecord_;
506 AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, abilityRequest.abilityInfo.bundleName,
507 abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
508 std::string extensionRecordKey = element.GetURI() + std::to_string(targetService->GetUIExtensionAbilityId());
509 targetService->SetURI(extensionRecordKey);
510 AddToServiceMap(extensionRecordKey, targetService);
511 LoadAbility(targetService);
512 return ERR_OK;
513 }
514
UnloadUIExtensionAbility(const std::shared_ptr<AAFwk::AbilityRecord> & abilityRecord,std::string & hostBundleName)515 int AbilityConnectManager::UnloadUIExtensionAbility(const std::shared_ptr<AAFwk::AbilityRecord> &abilityRecord,
516 std::string &hostBundleName)
517 {
518 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
519 //Get preLoadUIExtensionInfo
520 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
521 auto preLoadUIExtensionInfo = std::make_tuple(abilityRecord->GetWant().GetElement().GetAbilityName(),
522 abilityRecord->GetWant().GetElement().GetBundleName(),
523 abilityRecord->GetWant().GetElement().GetModuleName(), hostBundleName);
524 //delete preLoadUIExtensionMap
525 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
526 auto extensionRecordId = abilityRecord->GetUIExtensionAbilityId();
527 uiExtensionAbilityRecordMgr_->RemovePreloadUIExtensionRecordById(preLoadUIExtensionInfo, extensionRecordId);
528 //terminate preload uiextension
529 auto token = abilityRecord->GetToken();
530 auto result = TerminateAbilityInner(token);
531 if (result != ERR_OK) {
532 TAG_LOGE(AAFwkTag::ABILITYMGR, "terminate error!");
533 return result;
534 }
535 return ERR_OK;
536 }
537
ReportEventToRSS(const AppExecFwk::AbilityInfo & abilityInfo,const std::shared_ptr<AbilityRecord> abilityRecord,sptr<IRemoteObject> callerToken)538 void AbilityConnectManager::ReportEventToRSS(const AppExecFwk::AbilityInfo &abilityInfo,
539 const std::shared_ptr<AbilityRecord> abilityRecord, sptr<IRemoteObject> callerToken)
540 {
541 if (taskHandler_ == nullptr || abilityRecord == nullptr || abilityRecord->GetPid() <= 0) {
542 return;
543 }
544
545 std::string reason = ResSchedUtil::GetInstance().GetThawReasonByAbilityType(abilityInfo);
546 const int32_t uid = abilityInfo.applicationInfo.uid;
547 const std::string bundleName = abilityInfo.applicationInfo.bundleName;
548 const int32_t pid = abilityRecord->GetPid();
549 auto callerAbility = Token::GetAbilityRecordByToken(callerToken);
550 const int32_t callerPid = (callerAbility != nullptr) ? callerAbility->GetPid() : IPCSkeleton::GetCallingPid();
551 TAG_LOGD(AAFwkTag::ABILITYMGR, "%{public}d_%{public}s_%{public}d reason=%{public}s callerPid=%{public}d", uid,
552 bundleName.c_str(), pid, reason.c_str(), callerPid);
553 taskHandler_->SubmitTask([uid, bundleName, reason, pid, callerPid]() {
554 ResSchedUtil::GetInstance().ReportEventToRSS(uid, bundleName, reason, pid, callerPid);
555 });
556 }
557
ConnectAbilityLocked(const AbilityRequest & abilityRequest,const sptr<IAbilityConnection> & connect,const sptr<IRemoteObject> & callerToken,sptr<SessionInfo> sessionInfo,sptr<UIExtensionAbilityConnectInfo> connectInfo)558 int AbilityConnectManager::ConnectAbilityLocked(const AbilityRequest &abilityRequest,
559 const sptr<IAbilityConnection> &connect, const sptr<IRemoteObject> &callerToken, sptr<SessionInfo> sessionInfo,
560 sptr<UIExtensionAbilityConnectInfo> connectInfo)
561 {
562 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
563 CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE);
564 auto connectObject = connect->AsObject();
565 std::lock_guard guard(serialMutex_);
566
567 // 1. get target service ability record, and check whether it has been loaded.
568 std::shared_ptr<AbilityRecord> targetService;
569 bool isLoadedAbility = false;
570 int32_t ret = GetOrCreateTargetServiceRecord(abilityRequest, connectInfo, targetService, isLoadedAbility);
571 if (ret != ERR_OK) {
572 return ret;
573 }
574 if (abilityRequest.abilityInfo.extensionAbilityType == AppExecFwk::ExtensionAbilityType::REMOTE_NOTIFICATION) {
575 ReportEventToRSS(abilityRequest.abilityInfo, targetService, callerToken);
576 }
577 // 2. get target connectRecordList, and check whether this callback has been connected.
578 ConnectListType connectRecordList;
579 GetConnectRecordListFromMap(connect, connectRecordList);
580 bool isCallbackConnected = !connectRecordList.empty();
581 // 3. If this service ability and callback has been connected, There is no need to connect repeatedly
582 if (isLoadedAbility && (isCallbackConnected) && IsAbilityConnected(targetService, connectRecordList)) {
583 TAG_LOGI(AAFwkTag::ABILITYMGR, "Service/callback connected");
584 return ERR_OK;
585 }
586
587 // 4. Other cases , need to connect the service ability
588 auto connectRecord = ConnectionRecord::CreateConnectionRecord(callerToken, targetService, connect);
589 CHECK_POINTER_AND_RETURN(connectRecord, ERR_INVALID_VALUE);
590 connectRecord->AttachCallerInfo();
591 connectRecord->SetConnectState(ConnectionState::CONNECTING);
592 if (targetService->GetAbilityInfo().extensionAbilityType == AppExecFwk::ExtensionAbilityType::UI_SERVICE) {
593 connectRecord->SetConnectWant(abilityRequest.want);
594 }
595 targetService->AddConnectRecordToList(connectRecord);
596 targetService->SetSessionInfo(sessionInfo);
597 connectRecordList.push_back(connectRecord);
598 AddConnectObjectToMap(connectObject, connectRecordList, isCallbackConnected);
599 targetService->SetLaunchReason(LaunchReason::LAUNCHREASON_CONNECT_EXTENSION);
600
601 if (UIExtensionUtils::IsWindowExtension(targetService->GetAbilityInfo().extensionAbilityType)
602 && abilityRequest.sessionInfo) {
603 std::lock_guard guard(windowExtensionMapMutex_);
604 windowExtensionMap_.emplace(connectObject,
605 WindowExtMapValType(targetService->GetApplicationInfo().accessTokenId, abilityRequest.sessionInfo));
606 }
607
608 auto &abilityInfo = abilityRequest.abilityInfo;
609 ret = ReportXiaoYiToRSSIfNeeded(abilityInfo);
610 if (ret != ERR_OK) {
611 return ret;
612 }
613
614 if (!isLoadedAbility) {
615 LoadAbility(targetService);
616 } else if (targetService->IsAbilityState(AbilityState::ACTIVE)) {
617 targetService->SetWant(abilityRequest.want);
618 HandleActiveAbility(targetService, connectRecord);
619 } else {
620 TAG_LOGI(AAFwkTag::ABILITYMGR, "TargetService activing");
621 targetService->SaveConnectWant(abilityRequest.want);
622 }
623
624 auto token = targetService->GetToken();
625 auto preToken = iface_cast<Token>(connectRecord->GetToken());
626 DelayedSingleton<AppScheduler>::GetInstance()->AbilityBehaviorAnalysis(token, preToken, 0, 1, 1);
627 return ret;
628 }
629
HandleActiveAbility(std::shared_ptr<AbilityRecord> & targetService,std::shared_ptr<ConnectionRecord> & connectRecord)630 void AbilityConnectManager::HandleActiveAbility(std::shared_ptr<AbilityRecord> &targetService,
631 std::shared_ptr<ConnectionRecord> &connectRecord)
632 {
633 TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}s called.", __func__);
634 if (targetService == nullptr) {
635 TAG_LOGW(AAFwkTag::ABILITYMGR, "null target service");
636 return;
637 }
638
639 AppExecFwk::ExtensionAbilityType extType = targetService->GetAbilityInfo().extensionAbilityType;
640 bool isAbilityUIServiceExt = (extType == AppExecFwk::ExtensionAbilityType::UI_SERVICE);
641
642 if (!isAbilityUIServiceExt) {
643 if (targetService->GetConnectedListSize() >= 1) {
644 TAG_LOGI(AAFwkTag::ABILITYMGR, "connected");
645 targetService->RemoveSignatureInfo();
646 CHECK_POINTER(connectRecord);
647 connectRecord->CompleteConnect();
648 } else if (targetService->GetConnectingListSize() <= 1) {
649 ConnectAbility(targetService);
650 } else {
651 TAG_LOGI(AAFwkTag::ABILITYMGR, "connecting");
652 }
653 } else {
654 CHECK_POINTER(connectRecord);
655 Want want = connectRecord->GetConnectWant();
656 int connectRecordId = connectRecord->GetRecordId();
657 ConnectUIServiceExtAbility(targetService, connectRecordId, want);
658 }
659 }
660
DisconnectAbilityLocked(const sptr<IAbilityConnection> & connect)661 int AbilityConnectManager::DisconnectAbilityLocked(const sptr<IAbilityConnection> &connect)
662 {
663 std::lock_guard guard(serialMutex_);
664 return DisconnectAbilityLocked(connect, false);
665 }
666
DisconnectAbilityLocked(const sptr<IAbilityConnection> & connect,bool callerDied)667 int AbilityConnectManager::DisconnectAbilityLocked(const sptr<IAbilityConnection> &connect, bool callerDied)
668 {
669 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
670 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
671
672 // 1. check whether callback was connected.
673 ConnectListType connectRecordList;
674 GetConnectRecordListFromMap(connect, connectRecordList);
675 if (connectRecordList.empty()) {
676 TAG_LOGE(AAFwkTag::ABILITYMGR, "Can't find the connect list from connect map by callback.");
677 return CONNECTION_NOT_EXIST;
678 }
679
680 // 2. schedule disconnect to target service
681 int result = ERR_OK;
682 ConnectListType list;
683 for (auto &connectRecord : connectRecordList) {
684 if (connectRecord) {
685 auto abilityRecord = connectRecord->GetAbilityRecord();
686 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
687 TAG_LOGD(AAFwkTag::ABILITYMGR, "abilityName: %{public}s, bundleName: %{public}s",
688 abilityRecord->GetAbilityInfo().name.c_str(), abilityRecord->GetAbilityInfo().bundleName.c_str());
689 if (abilityRecord->GetAbilityInfo().type == AbilityType::EXTENSION) {
690 RemoveExtensionDelayDisconnectTask(connectRecord);
691 }
692 if (connectRecord->GetCallerTokenId() != IPCSkeleton::GetCallingTokenID() &&
693 static_cast<uint32_t>(IPCSkeleton::GetSelfTokenID() != IPCSkeleton::GetCallingTokenID())) {
694 TAG_LOGW(
695 AAFwkTag::ABILITYMGR, "The caller is inconsistent with the caller stored in the connectRecord.");
696 continue;
697 }
698
699 result = DisconnectRecordNormal(list, connectRecord, callerDied);
700 if (result != ERR_OK && callerDied) {
701 DisconnectRecordForce(list, connectRecord);
702 result = ERR_OK;
703 }
704
705 if (result != ERR_OK) {
706 TAG_LOGE(AAFwkTag::ABILITYMGR, "Disconnect ability fail , ret = %{public}d.", result);
707 break;
708 } else {
709 EventInfo eventInfo = BuildEventInfo(abilityRecord);
710 EventReport::SendDisconnectServiceEvent(EventName::DISCONNECT_SERVICE, eventInfo);
711 }
712 }
713 }
714 for (auto&& connectRecord : list) {
715 RemoveConnectionRecordFromMap(connectRecord);
716 }
717
718 return result;
719 }
720
TerminateRecord(std::shared_ptr<AbilityRecord> abilityRecord)721 void AbilityConnectManager::TerminateRecord(std::shared_ptr<AbilityRecord> abilityRecord)
722 {
723 TAG_LOGI(AAFwkTag::ABILITYMGR, "called");
724 if (!GetExtensionByIdFromServiceMap(abilityRecord->GetRecordId()) &&
725 !AbilityCacheManager::GetInstance().FindRecordByToken(abilityRecord->GetToken())) {
726 return;
727 }
728 auto timeoutTask = [abilityRecord, connectManager = shared_from_this()]() {
729 TAG_LOGW(AAFwkTag::ABILITYMGR, "Disconnect ability terminate timeout.");
730 connectManager->HandleStopTimeoutTask(abilityRecord);
731 };
732
733 MoveToTerminatingMap(abilityRecord);
734 abilityRecord->Terminate(timeoutTask);
735 }
736
DisconnectRecordNormal(ConnectListType & list,std::shared_ptr<ConnectionRecord> connectRecord,bool callerDied) const737 int AbilityConnectManager::DisconnectRecordNormal(ConnectListType &list,
738 std::shared_ptr<ConnectionRecord> connectRecord, bool callerDied) const
739 {
740 auto result = connectRecord->DisconnectAbility();
741 if (result != ERR_OK) {
742 TAG_LOGE(AAFwkTag::ABILITYMGR, "Disconnect ability fail , ret = %{public}d.", result);
743 return result;
744 }
745
746 if (connectRecord->GetConnectState() == ConnectionState::DISCONNECTED) {
747 TAG_LOGW(AAFwkTag::ABILITYMGR, "DisconnectRecordNormal disconnect record:%{public}d",
748 connectRecord->GetRecordId());
749 connectRecord->CompleteDisconnect(ERR_OK, callerDied);
750 list.emplace_back(connectRecord);
751 }
752 return ERR_OK;
753 }
754
DisconnectRecordForce(ConnectListType & list,std::shared_ptr<ConnectionRecord> connectRecord)755 void AbilityConnectManager::DisconnectRecordForce(ConnectListType &list,
756 std::shared_ptr<ConnectionRecord> connectRecord)
757 {
758 auto abilityRecord = connectRecord->GetAbilityRecord();
759 if (abilityRecord == nullptr) {
760 TAG_LOGE(AAFwkTag::ABILITYMGR, "Disconnect force abilityRecord null");
761 return;
762 }
763 abilityRecord->RemoveConnectRecordFromList(connectRecord);
764 connectRecord->CompleteDisconnect(ERR_OK, true);
765 list.emplace_back(connectRecord);
766 if (abilityRecord->IsConnectListEmpty() &&
767 (IsUIExtensionAbility(abilityRecord) || abilityRecord->IsNeverStarted() == 0)) {
768 TAG_LOGW(AAFwkTag::ABILITYMGR, "Force terminate ability record state: %{public}d.",
769 abilityRecord->GetAbilityState());
770 TerminateRecord(abilityRecord);
771 }
772 }
773
AttachAbilityThreadLocked(const sptr<IAbilityScheduler> & scheduler,const sptr<IRemoteObject> & token)774 int AbilityConnectManager::AttachAbilityThreadLocked(
775 const sptr<IAbilityScheduler> &scheduler, const sptr<IRemoteObject> &token)
776 {
777 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
778 std::lock_guard guard(serialMutex_);
779 auto abilityRecord = GetExtensionByTokenFromServiceMap(token);
780 if (abilityRecord == nullptr) {
781 abilityRecord = GetExtensionByTokenFromTerminatingMap(token);
782 if (abilityRecord != nullptr && !IsUIExtensionAbility(abilityRecord)) {
783 abilityRecord = nullptr;
784 }
785 }
786 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
787 std::string element = abilityRecord->GetURI();
788 TAG_LOGI(AAFwkTag::ABILITYMGR, "Ability: %{public}s", element.c_str());
789 if (taskHandler_ != nullptr) {
790 int recordId = abilityRecord->GetRecordId();
791 std::string taskName = std::string("LoadTimeout_") + std::to_string(recordId);
792 taskHandler_->CancelTask(taskName);
793 }
794 if (eventHandler_) {
795 eventHandler_->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
796 }
797 if (abilityRecord->IsSceneBoard()) {
798 TAG_LOGI(AAFwkTag::ABILITYMGR, "Attach Ability: %{public}s", element.c_str());
799 sceneBoardTokenId_ = abilityRecord->GetAbilityInfo().applicationInfo.accessTokenId;
800 }
801 abilityRecord->SetScheduler(scheduler);
802 abilityRecord->RemoveSpecifiedWantParam(UIEXTENSION_ABILITY_ID);
803 abilityRecord->RemoveSpecifiedWantParam(UIEXTENSION_ROOT_HOST_PID);
804 if (IsUIExtensionAbility(abilityRecord) && !abilityRecord->IsCreateByConnect()
805 && !abilityRecord->GetWant().GetBoolParam(IS_PRELOAD_UIEXTENSION_ABILITY, false)) {
806 abilityRecord->PostUIExtensionAbilityTimeoutTask(AbilityManagerService::FOREGROUND_TIMEOUT_MSG);
807 DelayedSingleton<AppScheduler>::GetInstance()->MoveToForeground(token);
808 } else {
809 TAG_LOGD(AAFwkTag::ABILITYMGR, "Inactivate");
810 abilityRecord->Inactivate();
811 }
812 return ERR_OK;
813 }
814
OnAbilityRequestDone(const sptr<IRemoteObject> & token,const int32_t state)815 void AbilityConnectManager::OnAbilityRequestDone(const sptr<IRemoteObject> &token, const int32_t state)
816 {
817 TAG_LOGD(AAFwkTag::ABILITYMGR, "state: %{public}d", state);
818 std::lock_guard guard(serialMutex_);
819 AppAbilityState abilityState = DelayedSingleton<AppScheduler>::GetInstance()->ConvertToAppAbilityState(state);
820 if (abilityState == AppAbilityState::ABILITY_STATE_FOREGROUND) {
821 auto abilityRecord = GetExtensionByTokenFromServiceMap(token);
822 CHECK_POINTER(abilityRecord);
823 if (!IsUIExtensionAbility(abilityRecord)) {
824 TAG_LOGE(AAFwkTag::ABILITYMGR, "Not ui extension.");
825 return;
826 }
827 if (abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) {
828 TAG_LOGW(AAFwkTag::ABILITYMGR, "abilityRecord is foregrounding.");
829 return;
830 }
831 std::string element = abilityRecord->GetURI();
832 TAG_LOGD(AAFwkTag::ABILITYMGR, "Ability is %{public}s, start to foreground.", element.c_str());
833 abilityRecord->GrantUriPermissionForUIExtension();
834 abilityRecord->ForegroundUIExtensionAbility();
835 }
836 }
837
OnAppStateChanged(const AppInfo & info)838 void AbilityConnectManager::OnAppStateChanged(const AppInfo &info)
839 {
840 auto serviceMap = GetServiceMap();
841 std::for_each(serviceMap.begin(), serviceMap.end(), [&info](ServiceMapType::reference service) {
842 if (service.second && (info.processName == service.second->GetAbilityInfo().process ||
843 info.processName == service.second->GetApplicationInfo().bundleName)) {
844 auto appName = service.second->GetApplicationInfo().name;
845 auto uid = service.second->GetAbilityInfo().applicationInfo.uid;
846 auto isExist = [&appName, &uid](
847 const AppData &appData) { return appData.appName == appName && appData.uid == uid; };
848 auto iter = std::find_if(info.appData.begin(), info.appData.end(), isExist);
849 if (iter != info.appData.end()) {
850 service.second->SetAppState(info.state);
851 }
852 }
853 });
854
855 auto cacheAbilityList = AbilityCacheManager::GetInstance().GetAbilityList();
856 std::for_each(cacheAbilityList.begin(), cacheAbilityList.end(), [&info](std::shared_ptr<AbilityRecord> &service) {
857 if (service && (info.processName == service->GetAbilityInfo().process ||
858 info.processName == service->GetApplicationInfo().bundleName)) {
859 auto appName = service->GetApplicationInfo().name;
860 auto uid = service->GetAbilityInfo().applicationInfo.uid;
861 auto isExist = [&appName, &uid](const AppData &appData) {
862 return appData.appName == appName && appData.uid == uid;
863 };
864 auto iter = std::find_if(info.appData.begin(), info.appData.end(), isExist);
865 if (iter != info.appData.end()) {
866 service->SetAppState(info.state);
867 }
868 }
869 });
870 }
871
AbilityTransitionDone(const sptr<IRemoteObject> & token,int state)872 int AbilityConnectManager::AbilityTransitionDone(const sptr<IRemoteObject> &token, int state)
873 {
874 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
875 std::lock_guard guard(serialMutex_);
876 int targetState = AbilityRecord::ConvertLifeCycleToAbilityState(static_cast<AbilityLifeCycleState>(state));
877 std::string abilityState = AbilityRecord::ConvertAbilityState(static_cast<AbilityState>(targetState));
878 std::shared_ptr<AbilityRecord> abilityRecord;
879 if (targetState == AbilityState::INACTIVE) {
880 abilityRecord = GetExtensionByTokenFromServiceMap(token);
881 } else if (targetState == AbilityState::FOREGROUND || targetState == AbilityState::BACKGROUND) {
882 abilityRecord = GetExtensionByTokenFromServiceMap(token);
883 if (abilityRecord == nullptr) {
884 abilityRecord = GetExtensionByTokenFromTerminatingMap(token);
885 }
886 } else if (targetState == AbilityState::INITIAL) {
887 abilityRecord = GetExtensionByTokenFromTerminatingMap(token);
888 }
889
890 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
891 std::string element = abilityRecord->GetURI();
892 TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}s called, ability:%{public}s, state:%{public}s",
893 __func__, element.c_str(), abilityState.c_str());
894
895 switch (targetState) {
896 case AbilityState::INACTIVE: {
897 if (abilityRecord->GetAbilityInfo().type == AbilityType::SERVICE) {
898 DelayedSingleton<AppScheduler>::GetInstance()->UpdateAbilityState(
899 token, AppExecFwk::AbilityState::ABILITY_STATE_CREATE);
900 } else {
901 DelayedSingleton<AppScheduler>::GetInstance()->UpdateExtensionState(
902 token, AppExecFwk::ExtensionState::EXTENSION_STATE_CREATE);
903 auto preloadTask = [owner = weak_from_this(), abilityRecord] {
904 auto acm = owner.lock();
905 if (acm == nullptr) {
906 TAG_LOGE(AAFwkTag::ABILITYMGR, "AbilityConnectManager is nullptr.");
907 return;
908 }
909 acm->ProcessPreload(abilityRecord);
910 };
911 if (taskHandler_ != nullptr) {
912 taskHandler_->SubmitTask(preloadTask);
913 }
914 }
915 return DispatchInactive(abilityRecord, state);
916 }
917 case AbilityState::FOREGROUND: {
918 abilityRecord->RemoveSignatureInfo();
919 return DispatchForeground(abilityRecord);
920 }
921 case AbilityState::BACKGROUND: {
922 return DispatchBackground(abilityRecord);
923 }
924 case AbilityState::INITIAL: {
925 if (abilityRecord->GetAbilityInfo().type == AbilityType::SERVICE) {
926 DelayedSingleton<AppScheduler>::GetInstance()->UpdateAbilityState(
927 token, AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED);
928 } else {
929 DelayedSingleton<AppScheduler>::GetInstance()->UpdateExtensionState(
930 token, AppExecFwk::ExtensionState::EXTENSION_STATE_TERMINATED);
931 }
932 return DispatchTerminate(abilityRecord);
933 }
934 default: {
935 TAG_LOGW(AAFwkTag::ABILITYMGR, "Don't support transiting state: %{public}d", state);
936 return ERR_INVALID_VALUE;
937 }
938 }
939 }
940
AbilityWindowConfigTransactionDone(const sptr<IRemoteObject> & token,const WindowConfig & windowConfig)941 int AbilityConnectManager::AbilityWindowConfigTransactionDone(const sptr<IRemoteObject> &token,
942 const WindowConfig &windowConfig)
943 {
944 std::lock_guard<ffrt::mutex> guard(serialMutex_);
945 auto abilityRecord = Token::GetAbilityRecordByToken(token);
946 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
947 abilityRecord->SaveAbilityWindowConfig(windowConfig);
948 return ERR_OK;
949 }
950
ProcessPreload(const std::shared_ptr<AbilityRecord> & record) const951 void AbilityConnectManager::ProcessPreload(const std::shared_ptr<AbilityRecord> &record) const
952 {
953 auto bundleMgrHelper = AbilityUtil::GetBundleManagerHelper();
954 CHECK_POINTER(bundleMgrHelper);
955 auto abilityInfo = record->GetAbilityInfo();
956 Want want;
957 want.SetElementName(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name, abilityInfo.moduleName);
958 auto uid = record->GetUid();
959 want.SetParam("uid", uid);
960 bundleMgrHelper->ProcessPreload(want);
961 }
962
ScheduleConnectAbilityDoneLocked(const sptr<IRemoteObject> & token,const sptr<IRemoteObject> & remoteObject)963 int AbilityConnectManager::ScheduleConnectAbilityDoneLocked(
964 const sptr<IRemoteObject> &token, const sptr<IRemoteObject> &remoteObject)
965 {
966 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
967 std::lock_guard guard(serialMutex_);
968 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
969
970 auto abilityRecord = Token::GetAbilityRecordByToken(token);
971 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
972
973 std::string element = abilityRecord->GetURI();
974 TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}s called, Connect ability done, ability: %{public}s.",
975 __func__, element.c_str());
976
977 if ((!abilityRecord->IsAbilityState(AbilityState::INACTIVE)) &&
978 (!abilityRecord->IsAbilityState(AbilityState::ACTIVE))) {
979 TAG_LOGE(AAFwkTag::ABILITYMGR, "Ability record state is not inactive ,state: %{public}d",
980 abilityRecord->GetAbilityState());
981 return INVALID_CONNECTION_STATE;
982 }
983 abilityRecord->RemoveConnectWant();
984 abilityRecord->RemoveSignatureInfo();
985
986 if (abilityRecord->GetAbilityInfo().type == AbilityType::SERVICE) {
987 DelayedSingleton<AppScheduler>::GetInstance()->UpdateAbilityState(
988 token, AppExecFwk::AbilityState::ABILITY_STATE_CONNECTED);
989 } else {
990 DelayedSingleton<AppScheduler>::GetInstance()->UpdateExtensionState(
991 token, AppExecFwk::ExtensionState::EXTENSION_STATE_CONNECTED);
992 }
993 EventInfo eventInfo = BuildEventInfo(abilityRecord);
994 eventInfo.userId = userId_;
995 eventInfo.bundleName = abilityRecord->GetAbilityInfo().bundleName;
996 eventInfo.moduleName = abilityRecord->GetAbilityInfo().moduleName;
997 eventInfo.abilityName = abilityRecord->GetAbilityInfo().name;
998 EventReport::SendConnectServiceEvent(EventName::CONNECT_SERVICE, eventInfo);
999
1000 abilityRecord->SetConnRemoteObject(remoteObject);
1001 // There may be multiple callers waiting for the connection result
1002 auto connectRecordList = abilityRecord->GetConnectRecordList();
1003 for (auto &connectRecord : connectRecordList) {
1004 connectRecord->ScheduleConnectAbilityDone();
1005 if (abilityRecord->GetAbilityInfo().type == AbilityType::EXTENSION &&
1006 abilityRecord->GetAbilityInfo().extensionAbilityType != AppExecFwk::ExtensionAbilityType::SERVICE) {
1007 PostExtensionDelayDisconnectTask(connectRecord);
1008 }
1009 }
1010 CompleteStartServiceReq(abilityRecord->GetURI());
1011 return ERR_OK;
1012 }
1013
ProcessEliminateAbilityRecord(std::shared_ptr<AbilityRecord> eliminateRecord)1014 void AbilityConnectManager::ProcessEliminateAbilityRecord(std::shared_ptr<AbilityRecord> eliminateRecord)
1015 {
1016 CHECK_POINTER(eliminateRecord);
1017 std::string eliminateKey = eliminateRecord->GetURI();
1018 if (FRS_BUNDLE_NAME == eliminateRecord->GetAbilityInfo().bundleName) {
1019 eliminateKey = eliminateKey +
1020 std::to_string(eliminateRecord->GetWant().GetIntParam(FRS_APP_INDEX, 0));
1021 }
1022 AddToServiceMap(eliminateKey, eliminateRecord);
1023 TerminateRecord(eliminateRecord);
1024 }
1025
TerminateOrCacheAbility(std::shared_ptr<AbilityRecord> abilityRecord)1026 void AbilityConnectManager::TerminateOrCacheAbility(std::shared_ptr<AbilityRecord> abilityRecord)
1027 {
1028 RemoveUIExtensionAbilityRecord(abilityRecord);
1029 if (abilityRecord->IsSceneBoard()) {
1030 return;
1031 }
1032 if (IsCacheExtensionAbilityType(abilityRecord)) {
1033 std::string serviceKey = abilityRecord->GetURI();
1034 auto abilityInfo = abilityRecord->GetAbilityInfo();
1035 TAG_LOGD(AAFwkTag::ABILITYMGR, "Cache the ability, service:%{public}s, extension type %{public}d",
1036 serviceKey.c_str(), abilityInfo.extensionAbilityType);
1037 if (FRS_BUNDLE_NAME == abilityInfo.bundleName) {
1038 AppExecFwk::ElementName elementName(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name,
1039 abilityInfo.moduleName);
1040 serviceKey = elementName.GetURI() +
1041 std::to_string(abilityRecord->GetWant().GetIntParam(FRS_APP_INDEX, 0));
1042 }
1043 {
1044 std::lock_guard lock(serviceMapMutex_);
1045 serviceMap_.erase(serviceKey);
1046 }
1047 auto eliminateRecord = AbilityCacheManager::GetInstance().Put(abilityRecord);
1048 if (eliminateRecord != nullptr) {
1049 TAG_LOGD(AAFwkTag::ABILITYMGR, "Terminate the eliminated ability, service:%{public}s.",
1050 eliminateRecord->GetURI().c_str());
1051 ProcessEliminateAbilityRecord(eliminateRecord);
1052 }
1053 return;
1054 }
1055 TAG_LOGD(AAFwkTag::ABILITYMGR, "Terminate the ability, service:%{public}s, extension type %{public}d",
1056 abilityRecord->GetURI().c_str(), abilityRecord->GetAbilityInfo().extensionAbilityType);
1057 TerminateRecord(abilityRecord);
1058 }
1059
ScheduleDisconnectAbilityDoneLocked(const sptr<IRemoteObject> & token)1060 int AbilityConnectManager::ScheduleDisconnectAbilityDoneLocked(const sptr<IRemoteObject> &token)
1061 {
1062 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1063 std::lock_guard guard(serialMutex_);
1064 auto abilityRecord = GetExtensionByTokenFromServiceMap(token);
1065 CHECK_POINTER_AND_RETURN(abilityRecord, CONNECTION_NOT_EXIST);
1066
1067 auto connect = abilityRecord->GetDisconnectingRecord();
1068 CHECK_POINTER_AND_RETURN(connect, CONNECTION_NOT_EXIST);
1069
1070 if (!abilityRecord->IsAbilityState(AbilityState::ACTIVE)) {
1071 if (IsUIExtensionAbility(abilityRecord) && (abilityRecord->IsForeground() ||
1072 abilityRecord->IsAbilityState(AbilityState::BACKGROUND) ||
1073 abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING))) {
1074 // uiextension ability support connect and start, so the ability state maybe others
1075 TAG_LOGI(
1076 AAFwkTag::ABILITYMGR, "Disconnect when ability state is %{public}d", abilityRecord->GetAbilityState());
1077 } else {
1078 TAG_LOGE(AAFwkTag::ABILITYMGR, "The service ability state is not active ,state: %{public}d",
1079 abilityRecord->GetAbilityState());
1080 return INVALID_CONNECTION_STATE;
1081 }
1082 }
1083
1084 if (abilityRecord->GetAbilityInfo().type == AbilityType::SERVICE) {
1085 DelayedSingleton<AppScheduler>::GetInstance()->UpdateAbilityState(
1086 token, AppExecFwk::AbilityState::ABILITY_STATE_DISCONNECTED);
1087 } else {
1088 DelayedSingleton<AppScheduler>::GetInstance()->UpdateExtensionState(
1089 token, AppExecFwk::ExtensionState::EXTENSION_STATE_DISCONNECTED);
1090 }
1091
1092 std::string element = abilityRecord->GetURI();
1093 TAG_LOGI(AAFwkTag::ABILITYMGR, "ScheduleDisconnectAbilityDoneLocked called, service:%{public}s.",
1094 element.c_str());
1095
1096 // complete disconnect and remove record from conn map
1097 connect->ScheduleDisconnectAbilityDone();
1098 abilityRecord->RemoveConnectRecordFromList(connect);
1099 if (abilityRecord->IsConnectListEmpty() && abilityRecord->GetStartId() == 0) {
1100 if (IsUIExtensionAbility(abilityRecord) && CheckUIExtensionAbilitySessionExist(abilityRecord)) {
1101 TAG_LOGI(AAFwkTag::ABILITYMGR, "There exist ui extension component, don't terminate when disconnect.");
1102 } else if (abilityRecord->GetAbilityInfo().extensionAbilityType ==
1103 AppExecFwk::ExtensionAbilityType::UI_SERVICE) {
1104 TAG_LOGI(AAFwkTag::ABILITYMGR, "don't terminate uiservice");
1105 } else {
1106 TAG_LOGI(AAFwkTag::ABILITYMGR,
1107 "Service ability has no any connection, and not started, need terminate or cache.");
1108 TerminateOrCacheAbility(abilityRecord);
1109 }
1110 }
1111 RemoveConnectionRecordFromMap(connect);
1112
1113 return ERR_OK;
1114 }
1115
ScheduleCommandAbilityDoneLocked(const sptr<IRemoteObject> & token)1116 int AbilityConnectManager::ScheduleCommandAbilityDoneLocked(const sptr<IRemoteObject> &token)
1117 {
1118 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1119 std::lock_guard guard(serialMutex_);
1120 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
1121 auto abilityRecord = Token::GetAbilityRecordByToken(token);
1122 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1123 std::string element = abilityRecord->GetURI();
1124 TAG_LOGI(AAFwkTag::ABILITYMGR, "%{public}s called, Ability: %{public}s", __func__, element.c_str());
1125
1126 if ((!abilityRecord->IsAbilityState(AbilityState::INACTIVE)) &&
1127 (!abilityRecord->IsAbilityState(AbilityState::ACTIVE))) {
1128 TAG_LOGE(AAFwkTag::ABILITYMGR, "Ability record state is not inactive ,state: %{public}d",
1129 abilityRecord->GetAbilityState());
1130 return INVALID_CONNECTION_STATE;
1131 }
1132 EventInfo eventInfo = BuildEventInfo(abilityRecord);
1133 EventReport::SendStartServiceEvent(EventName::START_SERVICE, eventInfo);
1134 abilityRecord->RemoveSignatureInfo();
1135 // complete command and pop waiting start ability from queue.
1136 CompleteCommandAbility(abilityRecord);
1137
1138 return ERR_OK;
1139 }
1140
ScheduleCommandAbilityWindowDone(const sptr<IRemoteObject> & token,const sptr<SessionInfo> & sessionInfo,WindowCommand winCmd,AbilityCommand abilityCmd)1141 int AbilityConnectManager::ScheduleCommandAbilityWindowDone(
1142 const sptr<IRemoteObject> &token,
1143 const sptr<SessionInfo> &sessionInfo,
1144 WindowCommand winCmd,
1145 AbilityCommand abilityCmd)
1146 {
1147 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1148 std::lock_guard guard(serialMutex_);
1149 CHECK_POINTER_AND_RETURN(token, ERR_INVALID_VALUE);
1150 CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE);
1151 auto abilityRecord = Token::GetAbilityRecordByToken(token);
1152 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1153 std::string element = abilityRecord->GetURI();
1154 TAG_LOGI(AAFwkTag::ABILITYMGR,
1155 "Ability: %{public}s, persistentId: %{private}d, winCmd: %{public}d, abilityCmd: %{public}d", element.c_str(),
1156 sessionInfo->persistentId, winCmd, abilityCmd);
1157
1158 // Only foreground mode need cancel, cause only foreground CommandAbilityWindow post timeout task.
1159 if (taskHandler_ && winCmd == WIN_CMD_FOREGROUND) {
1160 int recordId = abilityRecord->GetRecordId();
1161 std::string taskName = std::string("CommandWindowTimeout_") + std::to_string(recordId) + std::string("_") +
1162 std::to_string(sessionInfo->persistentId) + std::string("_") + std::to_string(winCmd);
1163 taskHandler_->CancelTask(taskName);
1164 }
1165
1166 if (winCmd == WIN_CMD_DESTROY) {
1167 HandleCommandDestroy(sessionInfo);
1168 }
1169
1170 abilityRecord->SetAbilityWindowState(sessionInfo, winCmd, true);
1171
1172 CompleteStartServiceReq(element);
1173 return ERR_OK;
1174 }
1175
HandleCommandDestroy(const sptr<SessionInfo> & sessionInfo)1176 void AbilityConnectManager::HandleCommandDestroy(const sptr<SessionInfo> &sessionInfo)
1177 {
1178 if (sessionInfo == nullptr) {
1179 TAG_LOGW(AAFwkTag::ABILITYMGR, "null session info.");
1180 return;
1181 }
1182 if (sessionInfo->sessionToken) {
1183 RemoveUIExtWindowDeathRecipient(sessionInfo->sessionToken);
1184 size_t ret = 0;
1185 {
1186 std::lock_guard guard(uiExtensionMapMutex_);
1187 ret = uiExtensionMap_.erase(sessionInfo->sessionToken);
1188 }
1189 if (ret > 0) {
1190 return;
1191 }
1192
1193 std::lock_guard guard(windowExtensionMapMutex_);
1194 for (auto& item : windowExtensionMap_) {
1195 auto sessionInfoVal = item.second.second;
1196 if (sessionInfoVal && sessionInfoVal->callerToken == sessionInfo->sessionToken) {
1197 windowExtensionMap_.erase(item.first);
1198 break;
1199 }
1200 }
1201 }
1202 }
1203
CompleteCommandAbility(std::shared_ptr<AbilityRecord> abilityRecord)1204 void AbilityConnectManager::CompleteCommandAbility(std::shared_ptr<AbilityRecord> abilityRecord)
1205 {
1206 CHECK_POINTER(abilityRecord);
1207 if (taskHandler_) {
1208 int recordId = abilityRecord->GetRecordId();
1209 std::string taskName = std::string("CommandTimeout_") + std::to_string(recordId) + std::string("_") +
1210 std::to_string(abilityRecord->GetStartId());
1211 taskHandler_->CancelTask(taskName);
1212 }
1213
1214 abilityRecord->SetAbilityState(AbilityState::ACTIVE);
1215
1216 // manage queued request
1217 CompleteStartServiceReq(abilityRecord->GetURI());
1218 if (abilityRecord->NeedConnectAfterCommand()) {
1219 ConnectAbility(abilityRecord);
1220 }
1221 }
1222
CompleteStartServiceReq(const std::string & serviceUri)1223 void AbilityConnectManager::CompleteStartServiceReq(const std::string &serviceUri)
1224 {
1225 std::shared_ptr<std::list<OHOS::AAFwk::AbilityRequest>> reqList;
1226 {
1227 std::lock_guard guard(startServiceReqListLock_);
1228 auto it = startServiceReqList_.find(serviceUri);
1229 if (it != startServiceReqList_.end()) {
1230 reqList = it->second;
1231 startServiceReqList_.erase(it);
1232 if (taskHandler_) {
1233 taskHandler_->CancelTask(std::string("start_service_timeout:") + serviceUri);
1234 }
1235 }
1236 }
1237
1238 if (reqList) {
1239 TAG_LOGI(AAFwkTag::ABILITYMGR, "Target service is activating : %{public}zu, uri: %{public}s", reqList->size(),
1240 serviceUri.c_str());
1241 for (const auto &req: *reqList) {
1242 StartAbilityLocked(req);
1243 }
1244 }
1245 }
1246
GetServiceRecordByElementName(const std::string & element)1247 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetServiceRecordByElementName(const std::string &element)
1248 {
1249 std::lock_guard guard(serviceMapMutex_);
1250 auto mapIter = serviceMap_.find(element);
1251 if (mapIter != serviceMap_.end()) {
1252 return mapIter->second;
1253 }
1254 return nullptr;
1255 }
1256
GetExtensionByTokenFromServiceMap(const sptr<IRemoteObject> & token)1257 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetExtensionByTokenFromServiceMap(
1258 const sptr<IRemoteObject> &token)
1259 {
1260 auto IsMatch = [token](auto service) {
1261 if (!service.second) {
1262 return false;
1263 }
1264 sptr<IRemoteObject> srcToken = service.second->GetToken();
1265 return srcToken == token;
1266 };
1267 std::lock_guard lock(serviceMapMutex_);
1268 auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch);
1269 if (serviceRecord != serviceMap_.end()) {
1270 return serviceRecord->second;
1271 }
1272 return nullptr;
1273 }
1274
GetExtensionByTokenFromAbilityCache(const sptr<IRemoteObject> & token)1275 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetExtensionByTokenFromAbilityCache(
1276 const sptr<IRemoteObject> &token)
1277 {
1278 return AbilityCacheManager::GetInstance().FindRecordByToken(token);
1279 }
1280
GetExtensionByIdFromServiceMap(const int64_t & abilityRecordId)1281 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetExtensionByIdFromServiceMap(
1282 const int64_t &abilityRecordId)
1283 {
1284 auto IsMatch = [abilityRecordId](auto &service) {
1285 if (!service.second) {
1286 return false;
1287 }
1288 return service.second->GetAbilityRecordId() == abilityRecordId;
1289 };
1290
1291 std::lock_guard lock(serviceMapMutex_);
1292 auto serviceRecord = std::find_if(serviceMap_.begin(), serviceMap_.end(), IsMatch);
1293 if (serviceRecord != serviceMap_.end()) {
1294 return serviceRecord->second;
1295 }
1296 return nullptr;
1297 }
1298
GetExtensionByIdFromTerminatingMap(const int64_t & abilityRecordId)1299 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetExtensionByIdFromTerminatingMap(
1300 const int64_t &abilityRecordId)
1301 {
1302 auto IsMatch = [abilityRecordId](auto &extensionRecord) {
1303 if (extensionRecord == nullptr) {
1304 return false;
1305 }
1306 return extensionRecord->GetAbilityRecordId() == abilityRecordId;
1307 };
1308
1309 std::lock_guard lock(serviceMapMutex_);
1310 auto extensionRecord = std::find_if(terminatingExtensionList_.begin(), terminatingExtensionList_.end(), IsMatch);
1311 if (extensionRecord != terminatingExtensionList_.end()) {
1312 return *extensionRecord;
1313 }
1314 return nullptr;
1315 }
1316
GetUIExtensioBySessionInfo(const sptr<SessionInfo> & sessionInfo)1317 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetUIExtensioBySessionInfo(
1318 const sptr<SessionInfo> &sessionInfo)
1319 {
1320 CHECK_POINTER_AND_RETURN(sessionInfo, nullptr);
1321 auto sessionToken = iface_cast<Rosen::ISession>(sessionInfo->sessionToken);
1322 CHECK_POINTER_AND_RETURN(sessionToken, nullptr);
1323 std::string descriptor = Str16ToStr8(sessionToken->GetDescriptor());
1324 if (descriptor != "OHOS.ISession") {
1325 TAG_LOGE(AAFwkTag::ABILITYMGR, "Input token is not a sessionToken, token->GetDescriptor(): %{public}s",
1326 descriptor.c_str());
1327 return nullptr;
1328 }
1329
1330 std::lock_guard guard(uiExtensionMapMutex_);
1331 auto it = uiExtensionMap_.find(sessionToken->AsObject());
1332 if (it != uiExtensionMap_.end()) {
1333 auto abilityRecord = it->second.first.lock();
1334 if (abilityRecord == nullptr) {
1335 TAG_LOGW(AAFwkTag::ABILITYMGR, "abilityRecord is nullptr.");
1336 RemoveUIExtWindowDeathRecipient(sessionToken->AsObject());
1337 uiExtensionMap_.erase(it);
1338 return nullptr;
1339 }
1340 auto savedSessionInfo = it->second.second;
1341 if (!savedSessionInfo || savedSessionInfo->sessionToken != sessionInfo->sessionToken
1342 || savedSessionInfo->callerToken != sessionInfo->callerToken) {
1343 TAG_LOGW(AAFwkTag::ABILITYMGR, "Inconsistent sessionInfo.");
1344 return nullptr;
1345 }
1346 return abilityRecord;
1347 } else {
1348 TAG_LOGE(AAFwkTag::ABILITYMGR, "UIExtension not found.");
1349 }
1350 return nullptr;
1351 }
1352
GetExtensionByTokenFromTerminatingMap(const sptr<IRemoteObject> & token)1353 std::shared_ptr<AbilityRecord> AbilityConnectManager::GetExtensionByTokenFromTerminatingMap(
1354 const sptr<IRemoteObject> &token)
1355 {
1356 auto IsMatch = [token](auto& extensionRecord) {
1357 if (extensionRecord == nullptr) {
1358 return false;
1359 }
1360 auto terminatingToken = extensionRecord->GetToken();
1361 if (terminatingToken != nullptr) {
1362 return terminatingToken->AsObject() == token;
1363 }
1364 return false;
1365 };
1366
1367 std::lock_guard lock(serviceMapMutex_);
1368 auto terminatingExtensionRecord =
1369 std::find_if(terminatingExtensionList_.begin(), terminatingExtensionList_.end(), IsMatch);
1370 if (terminatingExtensionRecord != terminatingExtensionList_.end()) {
1371 return *terminatingExtensionRecord;
1372 }
1373 return nullptr;
1374 }
1375
GetConnectRecordListByCallback(sptr<IAbilityConnection> callback)1376 std::list<std::shared_ptr<ConnectionRecord>> AbilityConnectManager::GetConnectRecordListByCallback(
1377 sptr<IAbilityConnection> callback)
1378 {
1379 std::lock_guard guard(connectMapMutex_);
1380 std::list<std::shared_ptr<ConnectionRecord>> connectList;
1381 auto connectMapIter = connectMap_.find(callback->AsObject());
1382 if (connectMapIter != connectMap_.end()) {
1383 connectList = connectMapIter->second;
1384 }
1385 return connectList;
1386 }
1387
LoadAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1388 void AbilityConnectManager::LoadAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1389 {
1390 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1391 CHECK_POINTER(abilityRecord);
1392 abilityRecord->SetStartTime();
1393
1394 if (!abilityRecord->CanRestartRootLauncher()) {
1395 TAG_LOGE(AAFwkTag::ABILITYMGR, "Root launcher restart is out of max count.");
1396 RemoveServiceAbility(abilityRecord);
1397 return;
1398 }
1399 bool isDebug = abilityRecord->GetWant().GetBoolParam(DEBUG_APP, false);
1400 if (!isDebug) {
1401 TAG_LOGD(AAFwkTag::ABILITYMGR, "IsDebug is false, here is not debug app");
1402 PostTimeOutTask(abilityRecord, AbilityManagerService::LOAD_TIMEOUT_MSG);
1403 }
1404 sptr<Token> token = abilityRecord->GetToken();
1405 sptr<Token> perToken = nullptr;
1406 if (abilityRecord->IsCreateByConnect()) {
1407 perToken = iface_cast<Token>(abilityRecord->GetConnectingRecord()->GetToken());
1408 } else {
1409 auto callerList = abilityRecord->GetCallerRecordList();
1410 if (!callerList.empty() && callerList.back()) {
1411 auto caller = callerList.back()->GetCaller();
1412 if (caller) {
1413 perToken = caller->GetToken();
1414 }
1415 }
1416 }
1417
1418 UpdateUIExtensionInfo(abilityRecord);
1419 AbilityRuntime::LoadParam loadParam;
1420 loadParam.abilityRecordId = abilityRecord->GetRecordId();
1421 loadParam.isShellCall = AAFwk::PermissionVerification::GetInstance()->IsShellCall();
1422 loadParam.token = token;
1423 loadParam.preToken = perToken;
1424 DelayedSingleton<AppScheduler>::GetInstance()->LoadAbility(
1425 loadParam, abilityRecord->GetAbilityInfo(), abilityRecord->GetApplicationInfo(), abilityRecord->GetWant());
1426 }
1427
PostRestartResidentTask(const AbilityRequest & abilityRequest)1428 void AbilityConnectManager::PostRestartResidentTask(const AbilityRequest &abilityRequest)
1429 {
1430 TAG_LOGI(AAFwkTag::ABILITYMGR, "PostRestartResidentTask start.");
1431 CHECK_POINTER(taskHandler_);
1432 std::string taskName = std::string("RestartResident_") + std::string(abilityRequest.abilityInfo.name);
1433 auto task = [abilityRequest, connectManager = shared_from_this()]() {
1434 CHECK_POINTER(connectManager);
1435 connectManager->HandleRestartResidentTask(abilityRequest);
1436 };
1437 int restartIntervalTime = 0;
1438 auto abilityMgr = DelayedSingleton<AbilityManagerService>::GetInstance();
1439 if (abilityMgr) {
1440 restartIntervalTime = AmsConfigurationParameter::GetInstance().GetRestartIntervalTime();
1441 }
1442 TAG_LOGD(AAFwkTag::ABILITYMGR, "PostRestartResidentTask, time:%{public}d", restartIntervalTime);
1443 taskHandler_->SubmitTask(task, taskName, restartIntervalTime);
1444 TAG_LOGI(AAFwkTag::ABILITYMGR, "PostRestartResidentTask end.");
1445 }
1446
HandleRestartResidentTask(const AbilityRequest & abilityRequest)1447 void AbilityConnectManager::HandleRestartResidentTask(const AbilityRequest &abilityRequest)
1448 {
1449 TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleRestartResidentTask start.");
1450 std::lock_guard guard(serialMutex_);
1451 auto findRestartResidentTask = [abilityRequest](const AbilityRequest &requestInfo) {
1452 return (requestInfo.want.GetElement().GetBundleName() == abilityRequest.want.GetElement().GetBundleName() &&
1453 requestInfo.want.GetElement().GetModuleName() == abilityRequest.want.GetElement().GetModuleName() &&
1454 requestInfo.want.GetElement().GetAbilityName() == abilityRequest.want.GetElement().GetAbilityName());
1455 };
1456 auto findIter = find_if(restartResidentTaskList_.begin(), restartResidentTaskList_.end(), findRestartResidentTask);
1457 if (findIter != restartResidentTaskList_.end()) {
1458 restartResidentTaskList_.erase(findIter);
1459 }
1460 StartAbilityLocked(abilityRequest);
1461 }
1462
PostTimeOutTask(const std::shared_ptr<AbilityRecord> & abilityRecord,uint32_t messageId)1463 void AbilityConnectManager::PostTimeOutTask(const std::shared_ptr<AbilityRecord> &abilityRecord, uint32_t messageId)
1464 {
1465 int connectRecordId = 0;
1466 if (messageId == AbilityConnectManager::CONNECT_TIMEOUT_MSG) {
1467 auto connectRecord = abilityRecord->GetConnectingRecord();
1468 CHECK_POINTER(connectRecord);
1469 connectRecordId = connectRecord->GetRecordId();
1470 }
1471 PostTimeOutTask(abilityRecord, connectRecordId, messageId);
1472 }
1473
PostTimeOutTask(const std::shared_ptr<AbilityRecord> & abilityRecord,int connectRecordId,uint32_t messageId)1474 void AbilityConnectManager::PostTimeOutTask(const std::shared_ptr<AbilityRecord> &abilityRecord,
1475 int connectRecordId, uint32_t messageId)
1476 {
1477 CHECK_POINTER(abilityRecord);
1478 CHECK_POINTER(taskHandler_);
1479
1480 std::string taskName;
1481 int32_t delayTime = 0;
1482 if (messageId == AbilityManagerService::LOAD_TIMEOUT_MSG) {
1483 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
1484 return abilityRecord->PostUIExtensionAbilityTimeoutTask(messageId);
1485 }
1486 // first load ability, There is at most one connect record.
1487 int recordId = abilityRecord->GetRecordId();
1488 taskName = std::string("LoadTimeout_") + std::to_string(recordId);
1489 delayTime = AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * LOAD_TIMEOUT_MULTIPLE;
1490 } else if (messageId == AbilityConnectManager::CONNECT_TIMEOUT_MSG) {
1491 taskName = std::string("ConnectTimeout_") + std::to_string(connectRecordId);
1492 delayTime = AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * CONNECT_TIMEOUT_MULTIPLE;
1493 } else {
1494 TAG_LOGE(AAFwkTag::ABILITYMGR, "Timeout task messageId is error.");
1495 return;
1496 }
1497
1498 // check libc.hook_mode
1499 const int bufferLen = 128;
1500 char paramOutBuf[bufferLen] = {0};
1501 const char *hook_mode = "startup:";
1502 int ret = GetParameter("libc.hook_mode", "", paramOutBuf, bufferLen - 1);
1503 if (ret > 0 && strncmp(paramOutBuf, hook_mode, strlen(hook_mode)) == 0) {
1504 TAG_LOGD(AAFwkTag::ABILITYMGR, "Hook_mode: no timeoutTask");
1505 return;
1506 }
1507
1508 auto timeoutTask = [abilityRecord, connectManager = shared_from_this(), messageId]() {
1509 if (messageId == AbilityManagerService::LOAD_TIMEOUT_MSG) {
1510 connectManager->HandleStartTimeoutTask(abilityRecord);
1511 } else if (messageId == AbilityConnectManager::CONNECT_TIMEOUT_MSG) {
1512 connectManager->HandleConnectTimeoutTask(abilityRecord);
1513 }
1514 };
1515 taskHandler_->SubmitTask(timeoutTask, taskName, delayTime);
1516 }
1517
HandleStartTimeoutTask(const std::shared_ptr<AbilityRecord> & abilityRecord)1518 void AbilityConnectManager::HandleStartTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord)
1519 {
1520 TAG_LOGW(AAFwkTag::ABILITYMGR, "load ability timeout.");
1521 std::lock_guard guard(serialMutex_);
1522 CHECK_POINTER(abilityRecord);
1523 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
1524 TAG_LOGE(AAFwkTag::ABILITYMGR, "consume session timeout, Uri: %{public}s", abilityRecord->GetURI().c_str());
1525 if (uiExtensionAbilityRecordMgr_ != nullptr && IsCallerValid(abilityRecord)) {
1526 TAG_LOGW(AAFwkTag::ABILITYMGR, "Start load timeout.");
1527 uiExtensionAbilityRecordMgr_->LoadTimeout(abilityRecord->GetUIExtensionAbilityId());
1528 }
1529 }
1530 auto connectingList = abilityRecord->GetConnectingRecordList();
1531 for (auto &connectRecord : connectingList) {
1532 if (connectRecord == nullptr) {
1533 TAG_LOGW(AAFwkTag::ABILITYMGR, "ConnectRecord is nullptr.");
1534 continue;
1535 }
1536 connectRecord->CompleteDisconnect(ERR_OK, false, true);
1537 abilityRecord->RemoveConnectRecordFromList(connectRecord);
1538 RemoveConnectionRecordFromMap(connectRecord);
1539 }
1540
1541 if (GetExtensionByTokenFromServiceMap(abilityRecord->GetToken()) == nullptr) {
1542 TAG_LOGE(AAFwkTag::ABILITYMGR, "Timeout ability record is not exist in service map.");
1543 return;
1544 }
1545 MoveToTerminatingMap(abilityRecord);
1546
1547 TAG_LOGW(AAFwkTag::ABILITYMGR, "Load time out , remove target service record from services map.");
1548 RemoveServiceAbility(abilityRecord);
1549 if (abilityRecord->IsSceneBoard()) {
1550 auto isAttached = IN_PROCESS_CALL(DelayedSingleton<AppScheduler>::GetInstance()->IsProcessAttached(
1551 abilityRecord->GetToken()));
1552 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1553 if (!isAttached) {
1554 RestartAbility(abilityRecord, userId_);
1555 }
1556 return;
1557 }
1558 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1559 if (IsAbilityNeedKeepAlive(abilityRecord)) {
1560 TAG_LOGW(AAFwkTag::ABILITYMGR, "Load time out, try to restart");
1561 RestartAbility(abilityRecord, userId_);
1562 }
1563 }
1564
HandleCommandTimeoutTask(const std::shared_ptr<AbilityRecord> & abilityRecord)1565 void AbilityConnectManager::HandleCommandTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord)
1566 {
1567 CHECK_POINTER(abilityRecord);
1568 if (AppUtils::GetInstance().IsLauncherAbility(abilityRecord->GetAbilityInfo().name)) {
1569 TAG_LOGD(AAFwkTag::ABILITYMGR, "Handle root launcher command timeout.");
1570 // terminate the timeout root launcher.
1571 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(abilityRecord->GetToken());
1572 }
1573 TAG_LOGD(AAFwkTag::ABILITYMGR, "HandleCommandTimeoutTask end");
1574 }
1575
HandleConnectTimeoutTask(std::shared_ptr<AbilityRecord> abilityRecord)1576 void AbilityConnectManager::HandleConnectTimeoutTask(std::shared_ptr<AbilityRecord> abilityRecord)
1577 {
1578 TAG_LOGW(AAFwkTag::ABILITYMGR, "connect ability timeout.");
1579 CHECK_POINTER(abilityRecord);
1580 auto connectList = abilityRecord->GetConnectRecordList();
1581 std::lock_guard guard(serialMutex_);
1582 for (const auto &connectRecord : connectList) {
1583 RemoveExtensionDelayDisconnectTask(connectRecord);
1584 connectRecord->CancelConnectTimeoutTask();
1585 connectRecord->CompleteDisconnect(ERR_OK, false, true);
1586 abilityRecord->RemoveConnectRecordFromList(connectRecord);
1587 RemoveConnectionRecordFromMap(connectRecord);
1588 }
1589
1590 if (IsSpecialAbility(abilityRecord->GetAbilityInfo()) || abilityRecord->GetStartId() != 0) {
1591 TAG_LOGI(AAFwkTag::ABILITYMGR, "no need to terminate.");
1592 return;
1593 }
1594
1595 TerminateRecord(abilityRecord);
1596 }
1597
HandleCommandWindowTimeoutTask(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<SessionInfo> & sessionInfo,WindowCommand winCmd)1598 void AbilityConnectManager::HandleCommandWindowTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord,
1599 const sptr<SessionInfo> &sessionInfo, WindowCommand winCmd)
1600 {
1601 TAG_LOGD(AAFwkTag::ABILITYMGR, "start");
1602 std::lock_guard guard(serialMutex_);
1603 CHECK_POINTER(abilityRecord);
1604 abilityRecord->SetAbilityWindowState(sessionInfo, winCmd, true);
1605 // manage queued request
1606 CompleteStartServiceReq(abilityRecord->GetURI());
1607 TAG_LOGD(AAFwkTag::ABILITYMGR, "end");
1608 }
1609
HandleStopTimeoutTask(const std::shared_ptr<AbilityRecord> & abilityRecord)1610 void AbilityConnectManager::HandleStopTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord)
1611 {
1612 TAG_LOGD(AAFwkTag::ABILITYMGR, "Complete stop ability timeout start.");
1613 std::lock_guard guard(serialMutex_);
1614 CHECK_POINTER(abilityRecord);
1615 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
1616 if (uiExtensionAbilityRecordMgr_ != nullptr && IsCallerValid(abilityRecord)) {
1617 TAG_LOGW(AAFwkTag::ABILITYMGR, "Start terminate timeout");
1618 uiExtensionAbilityRecordMgr_->TerminateTimeout(abilityRecord->GetUIExtensionAbilityId());
1619 }
1620 PrintTimeOutLog(abilityRecord, AbilityManagerService::TERMINATE_TIMEOUT_MSG);
1621 }
1622 TerminateDone(abilityRecord);
1623 }
1624
HandleTerminateDisconnectTask(const ConnectListType & connectlist)1625 void AbilityConnectManager::HandleTerminateDisconnectTask(const ConnectListType& connectlist)
1626 {
1627 TAG_LOGD(AAFwkTag::ABILITYMGR, "Disconnect ability when terminate.");
1628 for (auto& connectRecord : connectlist) {
1629 if (!connectRecord) {
1630 continue;
1631 }
1632 auto targetService = connectRecord->GetAbilityRecord();
1633 if (targetService) {
1634 TAG_LOGW(AAFwkTag::ABILITYMGR, "This record complete disconnect directly. recordId:%{public}d",
1635 connectRecord->GetRecordId());
1636 connectRecord->CompleteDisconnect(ERR_OK, false, true);
1637 targetService->RemoveConnectRecordFromList(connectRecord);
1638 RemoveConnectionRecordFromMap(connectRecord);
1639 };
1640 }
1641 }
1642
DispatchInactive(const std::shared_ptr<AbilityRecord> & abilityRecord,int state)1643 int AbilityConnectManager::DispatchInactive(const std::shared_ptr<AbilityRecord> &abilityRecord, int state)
1644 {
1645 TAG_LOGD(AAFwkTag::ABILITYMGR, "DispatchInactive call");
1646 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1647 CHECK_POINTER_AND_RETURN(eventHandler_, ERR_INVALID_VALUE);
1648 if (!abilityRecord->IsAbilityState(AbilityState::INACTIVATING)) {
1649 TAG_LOGE(AAFwkTag::ABILITYMGR,
1650 "Ability transition life state error. expect %{public}d, actual %{public}d callback %{public}d",
1651 AbilityState::INACTIVATING, abilityRecord->GetAbilityState(), state);
1652 return ERR_INVALID_VALUE;
1653 }
1654 eventHandler_->RemoveEvent(AbilityManagerService::INACTIVE_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
1655
1656 if (abilityRecord->GetAbilityInfo().extensionAbilityType == AppExecFwk::ExtensionAbilityType::SERVICE) {
1657 ResSchedUtil::GetInstance().ReportLoadingEventToRss(LoadingStage::LOAD_END,
1658 abilityRecord->GetPid(), abilityRecord->GetUid(), 0, abilityRecord->GetAbilityRecordId());
1659 }
1660
1661 // complete inactive
1662 abilityRecord->SetAbilityState(AbilityState::INACTIVE);
1663 if (abilityRecord->IsCreateByConnect()) {
1664 ConnectAbility(abilityRecord);
1665 } else if (abilityRecord->GetWant().GetBoolParam(IS_PRELOAD_UIEXTENSION_ABILITY, false)) {
1666 TAG_LOGD(AAFwkTag::ABILITYMGR, "IS_PRELOAD_UIEXTENSION_ABILITY");
1667 auto ret = uiExtensionAbilityRecordMgr_->AddPreloadUIExtensionRecord(abilityRecord);
1668 if (ret != ERR_OK) {
1669 TAG_LOGE(AAFwkTag::ABILITYMGR, "Add preload UI Extension record error!");
1670 return ret;
1671 }
1672 return ERR_OK;
1673 } else {
1674 CommandAbility(abilityRecord);
1675 if (abilityRecord->GetConnectRecordList().size() > 0) {
1676 // It means someone called connectAbility when service was loading
1677 abilityRecord->UpdateConnectWant();
1678 ConnectAbility(abilityRecord);
1679 }
1680 }
1681
1682 return ERR_OK;
1683 }
1684
DispatchForeground(const std::shared_ptr<AbilityRecord> & abilityRecord)1685 int AbilityConnectManager::DispatchForeground(const std::shared_ptr<AbilityRecord> &abilityRecord)
1686 {
1687 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1688 CHECK_POINTER_AND_RETURN(taskHandler_, ERR_INVALID_VALUE);
1689 // remove foreground timeout task.
1690 if (eventHandler_) {
1691 eventHandler_->RemoveEvent(AbilityManagerService::FOREGROUND_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
1692 }
1693 auto self(shared_from_this());
1694 auto task = [self, abilityRecord]() { self->CompleteForeground(abilityRecord); };
1695 taskHandler_->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
1696
1697 return ERR_OK;
1698 }
1699
DispatchBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)1700 int AbilityConnectManager::DispatchBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
1701 {
1702 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1703 CHECK_POINTER_AND_RETURN(taskHandler_, ERR_INVALID_VALUE);
1704 // remove background timeout task.
1705 taskHandler_->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId()));
1706
1707 auto self(shared_from_this());
1708 auto task = [self, abilityRecord]() { self->CompleteBackground(abilityRecord); };
1709 taskHandler_->SubmitTask(task, TaskQoS::USER_INTERACTIVE);
1710
1711 return ERR_OK;
1712 }
1713
DispatchTerminate(const std::shared_ptr<AbilityRecord> & abilityRecord)1714 int AbilityConnectManager::DispatchTerminate(const std::shared_ptr<AbilityRecord> &abilityRecord)
1715 {
1716 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_INVALID_VALUE);
1717 // remove terminate timeout task
1718 if (taskHandler_ != nullptr) {
1719 taskHandler_->CancelTask("terminate_" + std::to_string(abilityRecord->GetAbilityRecordId()));
1720 }
1721 ResSchedUtil::GetInstance().ReportLoadingEventToRss(LoadingStage::DESTROY_END, abilityRecord->GetPid(),
1722 abilityRecord->GetUid(), 0, abilityRecord->GetRecordId());
1723 // complete terminate
1724 TerminateDone(abilityRecord);
1725 return ERR_OK;
1726 }
1727
ConnectAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1728 void AbilityConnectManager::ConnectAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1729 {
1730 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1731 CHECK_POINTER(abilityRecord);
1732 AppExecFwk::ExtensionAbilityType extType = abilityRecord->GetAbilityInfo().extensionAbilityType;
1733 if (extType == AppExecFwk::ExtensionAbilityType::UI_SERVICE) {
1734 ResumeConnectAbility(abilityRecord);
1735 } else {
1736 PostTimeOutTask(abilityRecord, AbilityConnectManager::CONNECT_TIMEOUT_MSG);
1737 abilityRecord->ConnectAbility();
1738 }
1739 }
1740
ConnectUIServiceExtAbility(const std::shared_ptr<AbilityRecord> & abilityRecord,int connectRecordId,const Want & want)1741 void AbilityConnectManager::ConnectUIServiceExtAbility(const std::shared_ptr<AbilityRecord> &abilityRecord,
1742 int connectRecordId, const Want &want)
1743 {
1744 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1745 CHECK_POINTER(abilityRecord);
1746 PostTimeOutTask(abilityRecord, connectRecordId, AbilityConnectManager::CONNECT_TIMEOUT_MSG);
1747 abilityRecord->ConnectAbilityWithWant(want);
1748 }
1749
ResumeConnectAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1750 void AbilityConnectManager::ResumeConnectAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1751 {
1752 TAG_LOGI(AAFwkTag::ABILITYMGR, "ResumeConnectAbility");
1753 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1754 CHECK_POINTER(abilityRecord);
1755 std::list<std::shared_ptr<ConnectionRecord>> connectingList = abilityRecord->GetConnectingRecordList();
1756 for (auto &connectRecord : connectingList) {
1757 if (connectRecord == nullptr) {
1758 TAG_LOGW(AAFwkTag::ABILITYMGR, "ConnectRecord is nullptr.");
1759 continue;
1760 }
1761 int connectRecordId = connectRecord->GetRecordId();
1762 PostTimeOutTask(abilityRecord, connectRecordId, AbilityConnectManager::CONNECT_TIMEOUT_MSG);
1763 abilityRecord->ConnectAbilityWithWant(connectRecord->GetConnectWant());
1764 }
1765 }
1766
CommandAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1767 void AbilityConnectManager::CommandAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1768 {
1769 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1770 if (taskHandler_ != nullptr) {
1771 // first connect ability, There is at most one connect record.
1772 int recordId = abilityRecord->GetRecordId();
1773 abilityRecord->AddStartId();
1774 std::string taskName = std::string("CommandTimeout_") + std::to_string(recordId) + std::string("_") +
1775 std::to_string(abilityRecord->GetStartId());
1776 auto timeoutTask = [abilityRecord, connectManager = shared_from_this()]() {
1777 TAG_LOGE(AAFwkTag::ABILITYMGR, "Command ability timeout. %{public}s",
1778 abilityRecord->GetAbilityInfo().name.c_str());
1779 connectManager->HandleCommandTimeoutTask(abilityRecord);
1780 };
1781 int commandTimeout =
1782 AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * COMMAND_TIMEOUT_MULTIPLE;
1783 taskHandler_->SubmitTask(timeoutTask, taskName, commandTimeout);
1784 // scheduling command ability
1785 abilityRecord->CommandAbility();
1786 }
1787 }
1788
CommandAbilityWindow(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<SessionInfo> & sessionInfo,WindowCommand winCmd)1789 void AbilityConnectManager::CommandAbilityWindow(const std::shared_ptr<AbilityRecord> &abilityRecord,
1790 const sptr<SessionInfo> &sessionInfo, WindowCommand winCmd)
1791 {
1792 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1793 CHECK_POINTER(abilityRecord);
1794 CHECK_POINTER(sessionInfo);
1795 TAG_LOGD(AAFwkTag::ABILITYMGR, "ability: %{public}s, persistentId: %{private}d, wincmd: %{public}d",
1796 abilityRecord->GetURI().c_str(), sessionInfo->persistentId, winCmd);
1797 abilityRecord->SetAbilityWindowState(sessionInfo, winCmd, false);
1798 if (taskHandler_ != nullptr) {
1799 int recordId = abilityRecord->GetRecordId();
1800 std::string taskName = std::string("CommandWindowTimeout_") + std::to_string(recordId) + std::string("_") +
1801 std::to_string(sessionInfo->persistentId) + std::string("_") + std::to_string(winCmd);
1802 auto timeoutTask = [abilityRecord, sessionInfo, winCmd, connectManager = shared_from_this()]() {
1803 TAG_LOGE(AAFwkTag::ABILITYMGR, "Command window timeout. %{public}s",
1804 abilityRecord->GetAbilityInfo().name.c_str());
1805 connectManager->HandleCommandWindowTimeoutTask(abilityRecord, sessionInfo, winCmd);
1806 };
1807 int commandWindowTimeout =
1808 AmsConfigurationParameter::GetInstance().GetAppStartTimeoutTime() * COMMAND_WINDOW_TIMEOUT_MULTIPLE;
1809 taskHandler_->SubmitTask(timeoutTask, taskName, commandWindowTimeout);
1810 // scheduling command ability
1811 abilityRecord->CommandAbilityWindow(sessionInfo, winCmd);
1812 }
1813 }
1814
BackgroundAbilityWindowLocked(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<SessionInfo> & sessionInfo)1815 void AbilityConnectManager::BackgroundAbilityWindowLocked(const std::shared_ptr<AbilityRecord> &abilityRecord,
1816 const sptr<SessionInfo> &sessionInfo)
1817 {
1818 std::lock_guard guard(serialMutex_);
1819 DoBackgroundAbilityWindow(abilityRecord, sessionInfo);
1820 }
1821
DoBackgroundAbilityWindow(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<SessionInfo> & sessionInfo)1822 void AbilityConnectManager::DoBackgroundAbilityWindow(const std::shared_ptr<AbilityRecord> &abilityRecord,
1823 const sptr<SessionInfo> &sessionInfo)
1824 {
1825 CHECK_POINTER(abilityRecord);
1826 CHECK_POINTER(sessionInfo);
1827 auto abilitystateStr = abilityRecord->ConvertAbilityState(abilityRecord->GetAbilityState());
1828 TAG_LOGI(AAFwkTag::ABILITYMGR,
1829 "Background ability: %{public}s, persistentId: %{public}d, abilityState: %{public}s",
1830 abilityRecord->GetURI().c_str(), sessionInfo->persistentId, abilitystateStr.c_str());
1831 if (abilityRecord->IsAbilityState(AbilityState::FOREGROUND)) {
1832 MoveToBackground(abilityRecord);
1833 } else if (abilityRecord->IsAbilityState(AbilityState::INITIAL) ||
1834 abilityRecord->IsAbilityState(AbilityState::FOREGROUNDING)) {
1835 TAG_LOGI(AAFwkTag::ABILITYMGR, "There exist initial or foregrounding task.");
1836 abilityRecord->DoBackgroundAbilityWindowDelayed(true);
1837 } else if (!abilityRecord->IsAbilityState(AbilityState::BACKGROUNDING)) {
1838 TAG_LOGW(AAFwkTag::ABILITYMGR, "Invalid ability state when background.");
1839 }
1840 }
1841
TerminateAbilityWindowLocked(const std::shared_ptr<AbilityRecord> & abilityRecord,const sptr<SessionInfo> & sessionInfo)1842 void AbilityConnectManager::TerminateAbilityWindowLocked(const std::shared_ptr<AbilityRecord> &abilityRecord,
1843 const sptr<SessionInfo> &sessionInfo)
1844 {
1845 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1846 CHECK_POINTER(abilityRecord);
1847 CHECK_POINTER(sessionInfo);
1848 auto abilitystateStr = abilityRecord->ConvertAbilityState(abilityRecord->GetAbilityState());
1849 TAG_LOGI(AAFwkTag::ABILITYMGR,
1850 "Terminate ability: %{public}s, persistentId: %{public}d, abilityState: %{public}s",
1851 abilityRecord->GetURI().c_str(), sessionInfo->persistentId, abilitystateStr.c_str());
1852 EventInfo eventInfo;
1853 eventInfo.bundleName = abilityRecord->GetAbilityInfo().bundleName;
1854 eventInfo.abilityName = abilityRecord->GetAbilityInfo().name;
1855 EventReport::SendAbilityEvent(EventName::TERMINATE_ABILITY, HiSysEventType::BEHAVIOR, eventInfo);
1856 std::lock_guard guard(serialMutex_);
1857 eventInfo.errCode = TerminateAbilityInner(abilityRecord->GetToken());
1858 if (eventInfo.errCode != ERR_OK) {
1859 EventReport::SendAbilityEvent(EventName::TERMINATE_ABILITY_ERROR, HiSysEventType::FAULT, eventInfo);
1860 }
1861 }
1862
TerminateDone(const std::shared_ptr<AbilityRecord> & abilityRecord)1863 void AbilityConnectManager::TerminateDone(const std::shared_ptr<AbilityRecord> &abilityRecord)
1864 {
1865 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
1866 CHECK_POINTER(abilityRecord);
1867 if (!abilityRecord->IsAbilityState(AbilityState::TERMINATING)) {
1868 std::string expect = AbilityRecord::ConvertAbilityState(AbilityState::TERMINATING);
1869 std::string actual = AbilityRecord::ConvertAbilityState(abilityRecord->GetAbilityState());
1870 TAG_LOGE(AAFwkTag::ABILITYMGR,
1871 "Transition life state error. expect %{public}s, actual %{public}s", expect.c_str(), actual.c_str());
1872 return;
1873 }
1874 IN_PROCESS_CALL_WITHOUT_RET(abilityRecord->RevokeUriPermission());
1875 abilityRecord->RemoveAbilityDeathRecipient();
1876 if (abilityRecord->IsSceneBoard()) {
1877 TAG_LOGI(AAFwkTag::ABILITYMGR, "To kill processes because scb exit.");
1878 KillProcessesByUserId();
1879 }
1880 DelayedSingleton<AppScheduler>::GetInstance()->TerminateAbility(abilityRecord->GetToken(), false);
1881 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
1882 RemoveUIExtensionAbilityRecord(abilityRecord);
1883 }
1884 RemoveServiceAbility(abilityRecord);
1885 }
1886
IsAbilityConnected(const std::shared_ptr<AbilityRecord> & abilityRecord,const std::list<std::shared_ptr<ConnectionRecord>> & connectRecordList)1887 bool AbilityConnectManager::IsAbilityConnected(const std::shared_ptr<AbilityRecord> &abilityRecord,
1888 const std::list<std::shared_ptr<ConnectionRecord>> &connectRecordList)
1889 {
1890 auto isMatch = [abilityRecord](auto connectRecord) -> bool {
1891 if (abilityRecord == nullptr || connectRecord == nullptr) {
1892 return false;
1893 }
1894 if (abilityRecord != connectRecord->GetAbilityRecord()) {
1895 return false;
1896 }
1897 return true;
1898 };
1899 return std::any_of(connectRecordList.begin(), connectRecordList.end(), isMatch);
1900 }
1901
RemoveConnectionRecordFromMap(std::shared_ptr<ConnectionRecord> connection)1902 void AbilityConnectManager::RemoveConnectionRecordFromMap(std::shared_ptr<ConnectionRecord> connection)
1903 {
1904 std::lock_guard lock(connectMapMutex_);
1905 for (auto &connectCallback : connectMap_) {
1906 auto &connectList = connectCallback.second;
1907 auto connectRecord = std::find(connectList.begin(), connectList.end(), connection);
1908 if (connectRecord != connectList.end()) {
1909 TAG_LOGD(AAFwkTag::ABILITYMGR, "connrecord(%{public}d)", (*connectRecord)->GetRecordId());
1910 connectList.remove(connection);
1911 if (connectList.empty()) {
1912 RemoveConnectDeathRecipient(connectCallback.first);
1913 connectMap_.erase(connectCallback.first);
1914 }
1915 return;
1916 }
1917 }
1918 }
1919
RemoveServiceAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)1920 void AbilityConnectManager::RemoveServiceAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
1921 {
1922 CHECK_POINTER(abilityRecord);
1923 TAG_LOGD(AAFwkTag::ABILITYMGR, "Remove service(%{public}s) from terminating map.", abilityRecord->GetURI().c_str());
1924 std::lock_guard lock(serviceMapMutex_);
1925 terminatingExtensionList_.remove(abilityRecord);
1926 }
1927
AddConnectDeathRecipient(sptr<IRemoteObject> connectObject)1928 void AbilityConnectManager::AddConnectDeathRecipient(sptr<IRemoteObject> connectObject)
1929 {
1930 CHECK_POINTER(connectObject);
1931 {
1932 std::lock_guard guard(recipientMapMutex_);
1933 auto it = recipientMap_.find(connectObject);
1934 if (it != recipientMap_.end()) {
1935 TAG_LOGE(AAFwkTag::ABILITYMGR, "This death recipient has been added.");
1936 return;
1937 }
1938 }
1939
1940 std::weak_ptr<AbilityConnectManager> thisWeakPtr(shared_from_this());
1941 sptr<IRemoteObject::DeathRecipient> deathRecipient =
1942 new AbilityConnectCallbackRecipient([thisWeakPtr](const wptr<IRemoteObject> &remote) {
1943 auto abilityConnectManager = thisWeakPtr.lock();
1944 if (abilityConnectManager) {
1945 abilityConnectManager->OnCallBackDied(remote);
1946 }
1947 });
1948 if (!connectObject->AddDeathRecipient(deathRecipient)) {
1949 TAG_LOGE(AAFwkTag::ABILITYMGR, "AddDeathRecipient failed.");
1950 }
1951 std::lock_guard guard(recipientMapMutex_);
1952 recipientMap_.emplace(connectObject, deathRecipient);
1953 }
1954
RemoveConnectDeathRecipient(sptr<IRemoteObject> connectObject)1955 void AbilityConnectManager::RemoveConnectDeathRecipient(sptr<IRemoteObject> connectObject)
1956 {
1957 CHECK_POINTER(connectObject);
1958 sptr<IRemoteObject::DeathRecipient> deathRecipient;
1959 {
1960 std::lock_guard guard(recipientMapMutex_);
1961 auto it = recipientMap_.find(connectObject);
1962 if (it == recipientMap_.end()) {
1963 return;
1964 }
1965 deathRecipient = it->second;
1966 recipientMap_.erase(it);
1967 }
1968
1969 connectObject->RemoveDeathRecipient(deathRecipient);
1970 }
1971
OnCallBackDied(const wptr<IRemoteObject> & remote)1972 void AbilityConnectManager::OnCallBackDied(const wptr<IRemoteObject> &remote)
1973 {
1974 auto object = remote.promote();
1975 CHECK_POINTER(object);
1976 if (taskHandler_) {
1977 auto task = [object, connectManager = shared_from_this()]() { connectManager->HandleCallBackDiedTask(object); };
1978 taskHandler_->SubmitTask(task, TASK_ON_CALLBACK_DIED);
1979 }
1980 }
1981
HandleCallBackDiedTask(const sptr<IRemoteObject> & connect)1982 void AbilityConnectManager::HandleCallBackDiedTask(const sptr<IRemoteObject> &connect)
1983 {
1984 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
1985 CHECK_POINTER(connect);
1986 {
1987 std::lock_guard guard(windowExtensionMapMutex_);
1988 auto item = windowExtensionMap_.find(connect);
1989 if (item != windowExtensionMap_.end()) {
1990 windowExtensionMap_.erase(item);
1991 }
1992 }
1993
1994 {
1995 std::lock_guard guard(connectMapMutex_);
1996 auto it = connectMap_.find(connect);
1997 if (it != connectMap_.end()) {
1998 ConnectListType connectRecordList = it->second;
1999 for (auto &connRecord : connectRecordList) {
2000 connRecord->ClearConnCallBack();
2001 }
2002 } else {
2003 TAG_LOGI(AAFwkTag::ABILITYMGR, "Died object can't find from conn map.");
2004 return;
2005 }
2006 }
2007
2008 sptr<IAbilityConnection> object = iface_cast<IAbilityConnection>(connect);
2009 std::lock_guard guard(serialMutex_);
2010 DisconnectAbilityLocked(object, true);
2011 }
2012
GetActiveUIExtensionList(const int32_t pid,std::vector<std::string> & extensionList)2013 int32_t AbilityConnectManager::GetActiveUIExtensionList(
2014 const int32_t pid, std::vector<std::string> &extensionList)
2015 {
2016 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
2017 return uiExtensionAbilityRecordMgr_->GetActiveUIExtensionList(pid, extensionList);
2018 }
2019
GetActiveUIExtensionList(const std::string & bundleName,std::vector<std::string> & extensionList)2020 int32_t AbilityConnectManager::GetActiveUIExtensionList(
2021 const std::string &bundleName, std::vector<std::string> &extensionList)
2022 {
2023 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
2024 return uiExtensionAbilityRecordMgr_->GetActiveUIExtensionList(bundleName, extensionList);
2025 }
2026
OnAbilityDied(const std::shared_ptr<AbilityRecord> & abilityRecord,int32_t currentUserId)2027 void AbilityConnectManager::OnAbilityDied(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId)
2028 {
2029 CHECK_POINTER(abilityRecord);
2030 TAG_LOGI(AAFwkTag::ABILITYMGR, "On ability died: %{public}s.", abilityRecord->GetURI().c_str());
2031 if (abilityRecord->GetAbilityInfo().type != AbilityType::SERVICE &&
2032 abilityRecord->GetAbilityInfo().type != AbilityType::EXTENSION) {
2033 TAG_LOGW(AAFwkTag::ABILITYMGR, "Ability type is not service.");
2034 return;
2035 }
2036 if (eventHandler_ && abilityRecord->GetAbilityState() == AbilityState::INITIAL) {
2037 eventHandler_->RemoveEvent(AbilityManagerService::LOAD_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
2038 }
2039 if (eventHandler_ && abilityRecord->GetAbilityState() == AbilityState::FOREGROUNDING) {
2040 eventHandler_->RemoveEvent(AbilityManagerService::FOREGROUND_TIMEOUT_MSG, abilityRecord->GetAbilityRecordId());
2041 }
2042 if (taskHandler_ && abilityRecord->GetAbilityState() == AbilityState::BACKGROUNDING) {
2043 taskHandler_->CancelTask("background_" + std::to_string(abilityRecord->GetAbilityRecordId()));
2044 }
2045 if (taskHandler_ && abilityRecord->GetAbilityState() == AbilityState::TERMINATING) {
2046 taskHandler_->CancelTask("terminate_" + std::to_string(abilityRecord->GetAbilityRecordId()));
2047 }
2048 if (taskHandler_) {
2049 auto task = [abilityRecord, connectManager = shared_from_this(), currentUserId]() {
2050 connectManager->HandleAbilityDiedTask(abilityRecord, currentUserId);
2051 };
2052 taskHandler_->SubmitTask(task, TASK_ON_ABILITY_DIED);
2053 }
2054 }
2055
OnTimeOut(uint32_t msgId,int64_t abilityRecordId,bool isHalf)2056 void AbilityConnectManager::OnTimeOut(uint32_t msgId, int64_t abilityRecordId, bool isHalf)
2057 {
2058 auto abilityRecord = GetExtensionByIdFromServiceMap(abilityRecordId);
2059 if (abilityRecord == nullptr) {
2060 TAG_LOGE(AAFwkTag::ABILITYMGR, "ability record nullptr");
2061 return;
2062 }
2063 PrintTimeOutLog(abilityRecord, msgId, isHalf);
2064 if (isHalf) {
2065 return;
2066 }
2067 switch (msgId) {
2068 case AbilityManagerService::LOAD_TIMEOUT_MSG:
2069 HandleStartTimeoutTask(abilityRecord);
2070 break;
2071 case AbilityManagerService::INACTIVE_TIMEOUT_MSG:
2072 HandleInactiveTimeout(abilityRecord);
2073 break;
2074 case AbilityManagerService::FOREGROUND_TIMEOUT_MSG:
2075 HandleForegroundTimeoutTask(abilityRecord);
2076 break;
2077 default:
2078 break;
2079 }
2080 }
2081
HandleInactiveTimeout(const std::shared_ptr<AbilityRecord> & ability)2082 void AbilityConnectManager::HandleInactiveTimeout(const std::shared_ptr<AbilityRecord> &ability)
2083 {
2084 TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleInactiveTimeout start");
2085 CHECK_POINTER(ability);
2086 if (AppUtils::GetInstance().IsLauncherAbility(ability->GetAbilityInfo().name)) {
2087 TAG_LOGD(AAFwkTag::ABILITYMGR, "Handle root launcher inactive timeout.");
2088 // terminate the timeout root launcher.
2089 DelayedSingleton<AppScheduler>::GetInstance()->AttachTimeOut(ability->GetToken());
2090 }
2091 if (ability->GetAbilityInfo().name == AbilityConfig::CALLUI_ABILITY_NAME && ability->GetStartId() == 0) {
2092 HandleConnectTimeoutTask(ability);
2093 EventInfo eventInfo;
2094 eventInfo.userId = userId_;
2095 eventInfo.bundleName = ability->GetAbilityInfo().bundleName;
2096 eventInfo.moduleName = ability->GetAbilityInfo().moduleName;
2097 eventInfo.abilityName = ability->GetAbilityInfo().name;
2098 eventInfo.abilityName = ability->GetAbilityInfo().name;
2099 eventInfo.errCode = CONNECTION_TIMEOUT;
2100 EventReport::SendExtensionEvent(EventName::CONNECT_SERVICE_ERROR, HiSysEventType::FAULT, eventInfo);
2101 }
2102
2103 TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleInactiveTimeout end");
2104 }
2105
IsAbilityNeedKeepAlive(const std::shared_ptr<AbilityRecord> & abilityRecord)2106 bool AbilityConnectManager::IsAbilityNeedKeepAlive(const std::shared_ptr<AbilityRecord> &abilityRecord)
2107 {
2108 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2109 CHECK_POINTER_AND_RETURN(abilityRecord, false);
2110 const auto &abilityInfo = abilityRecord->GetAbilityInfo();
2111 if (IsSpecialAbility(abilityInfo)) {
2112 return true;
2113 }
2114
2115 return abilityRecord->IsKeepAliveBundle();
2116 }
2117
ClearPreloadUIExtensionRecord(const std::shared_ptr<AbilityRecord> & abilityRecord)2118 void AbilityConnectManager::ClearPreloadUIExtensionRecord(const std::shared_ptr<AbilityRecord> &abilityRecord)
2119 {
2120 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
2121 CHECK_POINTER(abilityRecord);
2122 auto extensionRecordId = abilityRecord->GetUIExtensionAbilityId();
2123 std::string hostBundleName;
2124 auto ret = uiExtensionAbilityRecordMgr_->GetHostBundleNameForExtensionId(extensionRecordId, hostBundleName);
2125 if (ret != ERR_OK) {
2126 TAG_LOGE(AAFwkTag::ABILITYMGR, "cannot get hostbundlename for this extension id.");
2127 return;
2128 }
2129 auto extensionRecordMapKey = std::make_tuple(abilityRecord->GetWant().GetElement().GetAbilityName(),
2130 abilityRecord->GetWant().GetElement().GetBundleName(),
2131 abilityRecord->GetWant().GetElement().GetModuleName(), hostBundleName);
2132 uiExtensionAbilityRecordMgr_->RemovePreloadUIExtensionRecordById(extensionRecordMapKey, extensionRecordId);
2133 }
2134
KeepAbilityAlive(const std::shared_ptr<AbilityRecord> & abilityRecord,int32_t currentUserId)2135 void AbilityConnectManager::KeepAbilityAlive(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId)
2136 {
2137 CHECK_POINTER(abilityRecord);
2138 auto abilityInfo = abilityRecord->GetAbilityInfo();
2139 TAG_LOGI(AAFwkTag::ABILITYMGR, "restart ability, bundleName: %{public}s, abilityName: %{public}s",
2140 abilityInfo.bundleName.c_str(), abilityInfo.name.c_str());
2141 auto token = abilityRecord->GetToken();
2142 if ((IsLauncher(abilityRecord) || abilityRecord->IsSceneBoard()) && token != nullptr) {
2143 IN_PROCESS_CALL_WITHOUT_RET(DelayedSingleton<AppScheduler>::GetInstance()->ClearProcessByToken(
2144 token->AsObject()));
2145 if (abilityRecord->IsSceneBoard() && currentUserId != userId_) {
2146 TAG_LOGI(AAFwkTag::ABILITYMGR, "Not the current user's SCB, clear the user and do not restart");
2147 KillProcessesByUserId();
2148 return;
2149 }
2150 }
2151
2152 if (userId_ != USER_ID_NO_HEAD && userId_ != currentUserId) {
2153 TAG_LOGI(AAFwkTag::ABILITYMGR, "Not current user's ability");
2154 return;
2155 }
2156
2157 if (abilityRecord->IsSceneBoard() && AmsConfigurationParameter::GetInstance().IsSupportSCBCrashReboot()) {
2158 static int sceneBoardCrashCount = 0;
2159 static int64_t tickCount = GetTickCount();
2160 int64_t tickNow = GetTickCount();
2161 const int64_t maxTime = 240000; // 240000 4min
2162 const int maxCount = 4; // 4: crash happened 4 times during 4 mins
2163 if (tickNow - tickCount > maxTime) {
2164 sceneBoardCrashCount = 0;
2165 tickCount = tickNow;
2166 }
2167 ++sceneBoardCrashCount;
2168 if (sceneBoardCrashCount >= maxCount) {
2169 std::string reason = "SceneBoard exits " + std::to_string(sceneBoardCrashCount) +
2170 "times in " + std::to_string(maxTime) + "ms";
2171 DoRebootExt("panic", reason.c_str());
2172 }
2173 }
2174
2175 if (DelayedSingleton<AppScheduler>::GetInstance()->IsKilledForUpgradeWeb(abilityInfo.bundleName)) {
2176 TAG_LOGI(AAFwkTag::ABILITYMGR, "bundle is killed for upgrade web");
2177 return;
2178 }
2179 if (DelayedSingleton<AppScheduler>::GetInstance()->IsMemorySizeSufficent() ||
2180 IsLauncher(abilityRecord) || abilityRecord->IsSceneBoard() ||
2181 AppUtils::GetInstance().IsAllowResidentInExtremeMemory(abilityInfo.bundleName, abilityInfo.name)) {
2182 RestartAbility(abilityRecord, currentUserId);
2183 }
2184 }
2185
HandleAbilityDiedTask(const std::shared_ptr<AbilityRecord> & abilityRecord,int32_t currentUserId)2186 void AbilityConnectManager::HandleAbilityDiedTask(
2187 const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId)
2188 {
2189 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
2190 std::lock_guard guard(serialMutex_);
2191 CHECK_POINTER(abilityRecord);
2192 TAG_LOGI(AAFwkTag::ABILITYMGR, "Ability died: %{public}s", abilityRecord->GetURI().c_str());
2193 abilityRecord->SetConnRemoteObject(nullptr);
2194 ConnectListType connlist = abilityRecord->GetConnectRecordList();
2195 for (auto &connectRecord : connlist) {
2196 TAG_LOGW(AAFwkTag::ABILITYMGR, "This record complete disconnect directly. recordId:%{public}d",
2197 connectRecord->GetRecordId());
2198 RemoveExtensionDelayDisconnectTask(connectRecord);
2199 connectRecord->CompleteDisconnect(ERR_OK, false, true);
2200 abilityRecord->RemoveConnectRecordFromList(connectRecord);
2201 RemoveConnectionRecordFromMap(connectRecord);
2202 }
2203 if (IsUIExtensionAbility(abilityRecord)) {
2204 HandleUIExtensionDied(abilityRecord);
2205 }
2206
2207 bool isRemove = false;
2208 if (IsCacheExtensionAbilityType(abilityRecord) &&
2209 AbilityCacheManager::GetInstance().FindRecordByToken(abilityRecord->GetToken()) != nullptr) {
2210 AbilityCacheManager::GetInstance().Remove(abilityRecord);
2211 MoveToTerminatingMap(abilityRecord);
2212 RemoveServiceAbility(abilityRecord);
2213 isRemove = true;
2214 } else if (GetExtensionByIdFromServiceMap(abilityRecord->GetAbilityRecordId()) != nullptr) {
2215 MoveToTerminatingMap(abilityRecord);
2216 RemoveServiceAbility(abilityRecord);
2217 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
2218 RemoveUIExtensionAbilityRecord(abilityRecord);
2219 }
2220 isRemove = true;
2221 }
2222
2223 if (IsAbilityNeedKeepAlive(abilityRecord)) {
2224 KeepAbilityAlive(abilityRecord, currentUserId);
2225 } else {
2226 if (isRemove) {
2227 HandleNotifyAssertFaultDialogDied(abilityRecord);
2228 }
2229 }
2230 }
2231
CheckIsNumString(const std::string & numStr)2232 static bool CheckIsNumString(const std::string &numStr)
2233 {
2234 const std::regex regexJsperf(R"(^\d*)");
2235 std::match_results<std::string::const_iterator> matchResults;
2236 if (numStr.empty() || !std::regex_match(numStr, matchResults, regexJsperf)) {
2237 TAG_LOGE(AAFwkTag::ABILITYMGR, "Number parsing error, %{public}s.", numStr.c_str());
2238 return false;
2239 }
2240 if (MAX_UINT64_VALUE.length() < numStr.length() ||
2241 (MAX_UINT64_VALUE.length() == numStr.length() && MAX_UINT64_VALUE.compare(numStr) < 0)) {
2242 TAG_LOGE(AAFwkTag::ABILITYMGR, "Number parsing error, %{public}s.", numStr.c_str());
2243 return false;
2244 }
2245
2246 return true;
2247 }
2248
HandleNotifyAssertFaultDialogDied(const std::shared_ptr<AbilityRecord> & abilityRecord)2249 void AbilityConnectManager::HandleNotifyAssertFaultDialogDied(const std::shared_ptr<AbilityRecord> &abilityRecord)
2250 {
2251 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
2252 CHECK_POINTER(abilityRecord);
2253 if (abilityRecord->GetAbilityInfo().name != ABILITY_NAME_ASSERT_FAULT_DIALOG ||
2254 abilityRecord->GetAbilityInfo().bundleName != BUNDLE_NAME_DIALOG) {
2255 TAG_LOGE(AAFwkTag::ABILITYMGR, "Is not assert fault dialog.");
2256 return;
2257 }
2258
2259 auto want = abilityRecord->GetWant();
2260 auto assertSessionStr = want.GetStringParam(Want::PARAM_ASSERT_FAULT_SESSION_ID);
2261 if (!CheckIsNumString(assertSessionStr)) {
2262 TAG_LOGE(AAFwkTag::ABILITYMGR, "Check assert session str is number failed.");
2263 return;
2264 }
2265
2266 auto callbackDeathMgr = DelayedSingleton<AbilityRuntime::AssertFaultCallbackDeathMgr>::GetInstance();
2267 if (callbackDeathMgr == nullptr) {
2268 TAG_LOGE(AAFwkTag::ABILITYMGR, "Get callback death manager instance is nullptr.");
2269 return;
2270 }
2271 callbackDeathMgr->CallAssertFaultCallback(std::stoull(assertSessionStr));
2272 }
2273
CloseAssertDialog(const std::string & assertSessionId)2274 void AbilityConnectManager::CloseAssertDialog(const std::string &assertSessionId)
2275 {
2276 TAG_LOGD(AAFwkTag::ABILITYMGR, "Called");
2277 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
2278 {
2279 std::lock_guard lock(serviceMapMutex_);
2280 for (const auto &item : serviceMap_) {
2281 if (item.second == nullptr) {
2282 continue;
2283 }
2284
2285 auto assertSessionStr = item.second->GetWant().GetStringParam(Want::PARAM_ASSERT_FAULT_SESSION_ID);
2286 if (assertSessionStr == assertSessionId) {
2287 abilityRecord = item.second;
2288 serviceMap_.erase(item.first);
2289 break;
2290 }
2291 }
2292 }
2293 if (abilityRecord == nullptr) {
2294 abilityRecord = AbilityCacheManager::GetInstance().FindRecordBySessionId(assertSessionId);
2295 AbilityCacheManager::GetInstance().Remove(abilityRecord);
2296 }
2297 if (abilityRecord == nullptr) {
2298 return;
2299 }
2300 TAG_LOGD(AAFwkTag::ABILITYMGR, "Terminate assert fault dialog");
2301 terminatingExtensionList_.push_back(abilityRecord);
2302 sptr<IRemoteObject> token = abilityRecord->GetToken();
2303 if (token != nullptr) {
2304 std::lock_guard lock(serialMutex_);
2305 TerminateAbilityLocked(token);
2306 }
2307 }
2308
HandleUIExtensionDied(const std::shared_ptr<AbilityRecord> & abilityRecord)2309 void AbilityConnectManager::HandleUIExtensionDied(const std::shared_ptr<AbilityRecord> &abilityRecord)
2310 {
2311 TAG_LOGD(AAFwkTag::ABILITYMGR, "called");
2312 CHECK_POINTER(abilityRecord);
2313 std::lock_guard guard(uiExtensionMapMutex_);
2314 for (auto it = uiExtensionMap_.begin(); it != uiExtensionMap_.end();) {
2315 std::shared_ptr<AbilityRecord> uiExtAbility = it->second.first.lock();
2316 if (uiExtAbility == nullptr) {
2317 TAG_LOGW(AAFwkTag::ABILITYMGR, "uiExtAbility is nullptr");
2318 RemoveUIExtWindowDeathRecipient(it->first);
2319 it = uiExtensionMap_.erase(it);
2320 continue;
2321 }
2322
2323 if (abilityRecord == uiExtAbility) {
2324 sptr<Rosen::ISession> sessionProxy = iface_cast<Rosen::ISession>(it->first);
2325 if (sessionProxy) {
2326 TAG_LOGD(AAFwkTag::ABILITYMGR, "start NotifyExtensionDied");
2327 sessionProxy->NotifyExtensionDied();
2328 }
2329 TAG_LOGW(AAFwkTag::UI_EXT, "uiExtAbility caller died");
2330 RemoveUIExtWindowDeathRecipient(it->first);
2331 it = uiExtensionMap_.erase(it);
2332 continue;
2333 }
2334 ++it;
2335 }
2336 }
2337
RestartAbility(const std::shared_ptr<AbilityRecord> & abilityRecord,int32_t currentUserId)2338 void AbilityConnectManager::RestartAbility(const std::shared_ptr<AbilityRecord> &abilityRecord, int32_t currentUserId)
2339 {
2340 TAG_LOGI(AAFwkTag::ABILITYMGR, "Restart ability: %{public}s.", abilityRecord->GetURI().c_str());
2341 AbilityRequest requestInfo;
2342 requestInfo.want = abilityRecord->GetWant();
2343 requestInfo.abilityInfo = abilityRecord->GetAbilityInfo();
2344 requestInfo.appInfo = abilityRecord->GetApplicationInfo();
2345 requestInfo.restartTime = abilityRecord->GetRestartTime();
2346 requestInfo.restart = true;
2347 requestInfo.uid = abilityRecord->GetUid();
2348 abilityRecord->SetRestarting(true);
2349 ResidentAbilityInfoGuard residentAbilityInfoGuard;
2350 if (abilityRecord->IsKeepAliveBundle()) {
2351 residentAbilityInfoGuard.SetResidentAbilityInfo(requestInfo.abilityInfo.bundleName,
2352 requestInfo.abilityInfo.name, userId_);
2353 }
2354
2355 if (AppUtils::GetInstance().IsLauncherAbility(abilityRecord->GetAbilityInfo().name)) {
2356 if (currentUserId != userId_) {
2357 TAG_LOGW(AAFwkTag::ABILITYMGR, "delay restart root launcher until switch user.");
2358 return;
2359 }
2360 if (abilityRecord->IsSceneBoard()) {
2361 requestInfo.want.SetParam("ohos.app.recovery", true);
2362 DelayedSingleton<AbilityManagerService>::GetInstance()->EnableListForSCBRecovery(userId_);
2363 }
2364 requestInfo.restartCount = abilityRecord->GetRestartCount();
2365 TAG_LOGD(AAFwkTag::ABILITYMGR, "restart root launcher, number:%{public}d", requestInfo.restartCount);
2366 StartAbilityLocked(requestInfo);
2367 return;
2368 }
2369
2370 requestInfo.want.SetParam(WANT_PARAMS_APP_RESTART_FLAG, true);
2371
2372 // restart other resident ability
2373 if (abilityRecord->CanRestartResident()) {
2374 requestInfo.restartCount = abilityRecord->GetRestartCount();
2375 requestInfo.restartTime = AbilityUtil::SystemTimeMillis();
2376 StartAbilityLocked(requestInfo);
2377 } else {
2378 auto findRestartResidentTask = [requestInfo](const AbilityRequest &abilityRequest) {
2379 return (requestInfo.want.GetElement().GetBundleName() == abilityRequest.want.GetElement().GetBundleName() &&
2380 requestInfo.want.GetElement().GetModuleName() == abilityRequest.want.GetElement().GetModuleName() &&
2381 requestInfo.want.GetElement().GetAbilityName() == abilityRequest.want.GetElement().GetAbilityName());
2382 };
2383 auto findIter = find_if(restartResidentTaskList_.begin(), restartResidentTaskList_.end(),
2384 findRestartResidentTask);
2385 if (findIter != restartResidentTaskList_.end()) {
2386 TAG_LOGW(AAFwkTag::ABILITYMGR, "The restart task has been registered.");
2387 return;
2388 }
2389 restartResidentTaskList_.emplace_back(requestInfo);
2390 PostRestartResidentTask(requestInfo);
2391 }
2392 }
2393
GetServiceKey(const std::shared_ptr<AbilityRecord> & service)2394 std::string AbilityConnectManager::GetServiceKey(const std::shared_ptr<AbilityRecord> &service)
2395 {
2396 std::string serviceKey = service->GetURI();
2397 if (FRS_BUNDLE_NAME == service->GetAbilityInfo().bundleName) {
2398 serviceKey = serviceKey + std::to_string(service->GetWant().GetIntParam(FRS_APP_INDEX, 0));
2399 }
2400 return serviceKey;
2401 }
2402
DumpState(std::vector<std::string> & info,bool isClient,const std::string & args)2403 void AbilityConnectManager::DumpState(std::vector<std::string> &info, bool isClient, const std::string &args)
2404 {
2405 TAG_LOGI(AAFwkTag::ABILITYMGR, "args:%{public}s.", args.c_str());
2406 auto serviceMapBack = GetServiceMap();
2407 auto cacheList = AbilityCacheManager::GetInstance().GetAbilityList();
2408 if (!args.empty()) {
2409 auto it = std::find_if(serviceMapBack.begin(), serviceMapBack.end(), [&args](const auto &service) {
2410 return service.first.compare(args) == 0;
2411 });
2412 if (it != serviceMapBack.end()) {
2413 info.emplace_back("uri [ " + it->first + " ]");
2414 if (it->second != nullptr) {
2415 it->second->DumpService(info, isClient);
2416 }
2417 } else {
2418 info.emplace_back(args + ": Nothing to dump from serviceMap.");
2419 }
2420
2421 std::string serviceKey;
2422 auto iter = std::find_if(cacheList.begin(), cacheList.end(), [&args, &serviceKey, this](const auto &service) {
2423 serviceKey = GetServiceKey(service);
2424 return serviceKey.compare(args) == 0;
2425 });
2426 if (iter != cacheList.end()) {
2427 info.emplace_back("uri [ " + serviceKey + " ]");
2428 if (*iter != nullptr) {
2429 (*iter)->DumpService(info, isClient);
2430 }
2431 } else {
2432 info.emplace_back(args + ": Nothing to dump from lru cache.");
2433 }
2434 } else {
2435 info.emplace_back(" ExtensionRecords:");
2436 for (auto &&service : serviceMapBack) {
2437 info.emplace_back(" uri [" + service.first + "]");
2438 if (service.second != nullptr) {
2439 service.second->DumpService(info, isClient);
2440 }
2441 }
2442 for (auto &&service : cacheList) {
2443 std::string serviceKey = GetServiceKey(service);
2444 info.emplace_back(" uri [" + serviceKey + "]");
2445 if (service != nullptr) {
2446 service->DumpService(info, isClient);
2447 }
2448 }
2449 }
2450 }
2451
DumpStateByUri(std::vector<std::string> & info,bool isClient,const std::string & args,std::vector<std::string> & params)2452 void AbilityConnectManager::DumpStateByUri(std::vector<std::string> &info, bool isClient, const std::string &args,
2453 std::vector<std::string> ¶ms)
2454 {
2455 TAG_LOGI(AAFwkTag::ABILITYMGR, "args:%{public}s, params size: %{public}zu", args.c_str(), params.size());
2456 std::shared_ptr<AbilityRecord> extensionAbilityRecord = nullptr;
2457 {
2458 std::lock_guard lock(serviceMapMutex_);
2459 auto it = std::find_if(serviceMap_.begin(), serviceMap_.end(), [&args](const auto &service) {
2460 return service.first.compare(args) == 0;
2461 });
2462 if (it != serviceMap_.end()) {
2463 info.emplace_back("uri [ " + it->first + " ]");
2464 extensionAbilityRecord = it->second;
2465 } else {
2466 info.emplace_back(args + ": Nothing to dump from serviceMap.");
2467 }
2468 }
2469 if (extensionAbilityRecord != nullptr) {
2470 extensionAbilityRecord->DumpService(info, params, isClient);
2471 return;
2472 }
2473 extensionAbilityRecord = AbilityCacheManager::GetInstance().FindRecordByServiceKey(args);
2474 if (extensionAbilityRecord != nullptr) {
2475 info.emplace_back("uri [ " + args + " ]");
2476 extensionAbilityRecord->DumpService(info, params, isClient);
2477 } else {
2478 info.emplace_back(args + ": Nothing to dump from lru cache.");
2479 }
2480 }
2481
GetExtensionRunningInfos(int upperLimit,std::vector<ExtensionRunningInfo> & info,const int32_t userId,bool isPerm)2482 void AbilityConnectManager::GetExtensionRunningInfos(int upperLimit, std::vector<ExtensionRunningInfo> &info,
2483 const int32_t userId, bool isPerm)
2484 {
2485 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2486 auto serviceMapBack = GetServiceMap();
2487 auto queryInfo = [&](ServiceMapType::reference service) {
2488 if (static_cast<int>(info.size()) >= upperLimit) {
2489 return;
2490 }
2491 auto abilityRecord = service.second;
2492 CHECK_POINTER(abilityRecord);
2493
2494 if (isPerm) {
2495 GetExtensionRunningInfo(abilityRecord, userId, info);
2496 } else {
2497 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
2498 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
2499 if (callingTokenId == tokenID) {
2500 GetExtensionRunningInfo(abilityRecord, userId, info);
2501 }
2502 }
2503 };
2504 std::for_each(serviceMapBack.begin(), serviceMapBack.end(), queryInfo);
2505
2506 auto cacheAbilityList = AbilityCacheManager::GetInstance().GetAbilityList();
2507 auto queryInfoForCache = [&](std::shared_ptr<AbilityRecord> &service) {
2508 if (static_cast<int>(info.size()) >= upperLimit) {
2509 return;
2510 }
2511 CHECK_POINTER(service);
2512
2513 if (isPerm) {
2514 GetExtensionRunningInfo(service, userId, info);
2515 } else {
2516 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
2517 auto tokenID = service->GetApplicationInfo().accessTokenId;
2518 if (callingTokenId == tokenID) {
2519 GetExtensionRunningInfo(service, userId, info);
2520 }
2521 }
2522 };
2523 std::for_each(cacheAbilityList.begin(), cacheAbilityList.end(), queryInfoForCache);
2524 }
2525
GetAbilityRunningInfos(std::vector<AbilityRunningInfo> & info,bool isPerm)2526 void AbilityConnectManager::GetAbilityRunningInfos(std::vector<AbilityRunningInfo> &info, bool isPerm)
2527 {
2528 auto serviceMapBack = GetServiceMap();
2529 auto queryInfo = [&info, isPerm](ServiceMapType::reference service) {
2530 auto abilityRecord = service.second;
2531 CHECK_POINTER(abilityRecord);
2532
2533 if (isPerm) {
2534 DelayedSingleton<AbilityManagerService>::GetInstance()->GetAbilityRunningInfo(info, abilityRecord);
2535 } else {
2536 auto callingTokenId = IPCSkeleton::GetCallingTokenID();
2537 auto tokenID = abilityRecord->GetApplicationInfo().accessTokenId;
2538 if (callingTokenId == tokenID) {
2539 DelayedSingleton<AbilityManagerService>::GetInstance()->GetAbilityRunningInfo(info, abilityRecord);
2540 }
2541 }
2542 };
2543
2544 std::for_each(serviceMapBack.begin(), serviceMapBack.end(), queryInfo);
2545 }
2546
GetExtensionRunningInfo(std::shared_ptr<AbilityRecord> & abilityRecord,const int32_t userId,std::vector<ExtensionRunningInfo> & info)2547 void AbilityConnectManager::GetExtensionRunningInfo(std::shared_ptr<AbilityRecord> &abilityRecord,
2548 const int32_t userId, std::vector<ExtensionRunningInfo> &info)
2549 {
2550 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2551 ExtensionRunningInfo extensionInfo;
2552 AppExecFwk::RunningProcessInfo processInfo;
2553 extensionInfo.extension = abilityRecord->GetElementName();
2554 extensionInfo.type = abilityRecord->GetAbilityInfo().extensionAbilityType;
2555 DelayedSingleton<AppScheduler>::GetInstance()->
2556 GetRunningProcessInfoByToken(abilityRecord->GetToken(), processInfo);
2557 extensionInfo.pid = processInfo.pid_;
2558 extensionInfo.uid = processInfo.uid_;
2559 extensionInfo.processName = processInfo.processName_;
2560 extensionInfo.startTime = abilityRecord->GetStartTime();
2561 ConnectListType connectRecordList = abilityRecord->GetConnectRecordList();
2562 for (auto &connectRecord : connectRecordList) {
2563 if (connectRecord == nullptr) {
2564 TAG_LOGD(AAFwkTag::ABILITYMGR, "connectRecord is nullptr.");
2565 continue;
2566 }
2567 auto callerAbilityRecord = Token::GetAbilityRecordByToken(connectRecord->GetToken());
2568 if (callerAbilityRecord == nullptr) {
2569 TAG_LOGD(AAFwkTag::ABILITYMGR, "callerAbilityRecord is nullptr.");
2570 continue;
2571 }
2572 std::string package = callerAbilityRecord->GetAbilityInfo().bundleName;
2573 extensionInfo.clientPackage.emplace_back(package);
2574 }
2575 info.emplace_back(extensionInfo);
2576 }
2577
PauseExtensions()2578 void AbilityConnectManager::PauseExtensions()
2579 {
2580 TAG_LOGD(AAFwkTag::ABILITYMGR, "begin.");
2581 std::vector<sptr<IRemoteObject>> needTerminatedTokens;
2582 {
2583 std::lock_guard lock(serviceMapMutex_);
2584 for (auto it = serviceMap_.begin(); it != serviceMap_.end();) {
2585 auto targetExtension = it->second;
2586 if (targetExtension != nullptr && targetExtension->GetAbilityInfo().type == AbilityType::EXTENSION &&
2587 (IsLauncher(targetExtension) || targetExtension->IsSceneBoard() ||
2588 (targetExtension->GetKeepAlive() && userId_ != USER_ID_NO_HEAD))) {
2589 terminatingExtensionList_.push_back(it->second);
2590 it = serviceMap_.erase(it);
2591 TAG_LOGI(AAFwkTag::ABILITYMGR, "terminate ability:%{public}s.",
2592 targetExtension->GetAbilityInfo().name.c_str());
2593 needTerminatedTokens.push_back(targetExtension->GetToken());
2594 } else {
2595 ++it;
2596 }
2597 }
2598 }
2599
2600 for (const auto &token : needTerminatedTokens) {
2601 std::lock_guard lock(serialMutex_);
2602 TerminateAbilityLocked(token);
2603 }
2604 }
2605
RemoveLauncherDeathRecipient()2606 void AbilityConnectManager::RemoveLauncherDeathRecipient()
2607 {
2608 TAG_LOGI(AAFwkTag::ABILITYMGR, "Call.");
2609 {
2610 std::lock_guard lock(serviceMapMutex_);
2611 for (auto it = serviceMap_.begin(); it != serviceMap_.end(); ++it) {
2612 auto targetExtension = it->second;
2613 if (targetExtension != nullptr && targetExtension->GetAbilityInfo().type == AbilityType::EXTENSION &&
2614 (IsLauncher(targetExtension) || targetExtension->IsSceneBoard())) {
2615 targetExtension->RemoveAbilityDeathRecipient();
2616 return;
2617 }
2618 }
2619 }
2620 AbilityCacheManager::GetInstance().RemoveLauncherDeathRecipient();
2621 }
2622
IsLauncher(std::shared_ptr<AbilityRecord> serviceExtension) const2623 bool AbilityConnectManager::IsLauncher(std::shared_ptr<AbilityRecord> serviceExtension) const
2624 {
2625 if (serviceExtension == nullptr) {
2626 TAG_LOGE(AAFwkTag::ABILITYMGR, "param is nullptr");
2627 return false;
2628 }
2629 return serviceExtension->GetAbilityInfo().name == AbilityConfig::LAUNCHER_ABILITY_NAME &&
2630 serviceExtension->GetAbilityInfo().bundleName == AbilityConfig::LAUNCHER_BUNDLE_NAME;
2631 }
2632
KillProcessesByUserId() const2633 void AbilityConnectManager::KillProcessesByUserId() const
2634 {
2635 auto appScheduler = DelayedSingleton<AppScheduler>::GetInstance();
2636 if (appScheduler == nullptr) {
2637 TAG_LOGE(AAFwkTag::ABILITYMGR, "appScheduler is nullptr");
2638 return;
2639 }
2640 IN_PROCESS_CALL_WITHOUT_RET(appScheduler->KillProcessesByUserId(userId_));
2641 }
2642
MoveToBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)2643 void AbilityConnectManager::MoveToBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
2644 {
2645 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
2646 if (abilityRecord == nullptr) {
2647 TAG_LOGE(AAFwkTag::ABILITYMGR, "Move the ui extension ability to background fail, ability record is null.");
2648 return;
2649 }
2650 TAG_LOGD(AAFwkTag::ABILITYMGR, "Move the ui extension ability to background, ability:%{public}s.",
2651 abilityRecord->GetAbilityInfo().name.c_str());
2652 abilityRecord->SetIsNewWant(false);
2653
2654 auto self(weak_from_this());
2655 auto task = [abilityRecord, self]() {
2656 auto selfObj = self.lock();
2657 if (selfObj == nullptr) {
2658 TAG_LOGW(AAFwkTag::ABILITYMGR, "mgr is invalid.");
2659 return;
2660 }
2661 CHECK_POINTER(abilityRecord);
2662 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType) &&
2663 selfObj->uiExtensionAbilityRecordMgr_ != nullptr && selfObj->IsCallerValid(abilityRecord)) {
2664 TAG_LOGD(AAFwkTag::ABILITYMGR, "Start background timeout.");
2665 selfObj->uiExtensionAbilityRecordMgr_->BackgroundTimeout(abilityRecord->GetUIExtensionAbilityId());
2666 }
2667 TAG_LOGE(AAFwkTag::ABILITYMGR, "move to background timeout.");
2668 selfObj->PrintTimeOutLog(abilityRecord, AbilityManagerService::BACKGROUND_TIMEOUT_MSG);
2669 selfObj->CompleteBackground(abilityRecord);
2670 };
2671 abilityRecord->BackgroundAbility(task);
2672 }
2673
CompleteForeground(const std::shared_ptr<AbilityRecord> & abilityRecord)2674 void AbilityConnectManager::CompleteForeground(const std::shared_ptr<AbilityRecord> &abilityRecord)
2675 {
2676 std::lock_guard guard(serialMutex_);
2677 if (abilityRecord == nullptr) {
2678 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityRecord is nullptr");
2679 return;
2680 }
2681 if (abilityRecord->GetAbilityState() != AbilityState::FOREGROUNDING) {
2682 TAG_LOGE(AAFwkTag::ABILITYMGR, "Ability state is %{public}d, it can't complete foreground.",
2683 abilityRecord->GetAbilityState());
2684 return;
2685 }
2686
2687 abilityRecord->SetAbilityState(AbilityState::FOREGROUND);
2688 if (abilityRecord->BackgroundAbilityWindowDelayed()) {
2689 TAG_LOGI(AAFwkTag::ABILITYMGR, "Response background request.");
2690 abilityRecord->DoBackgroundAbilityWindowDelayed(false);
2691 DoBackgroundAbilityWindow(abilityRecord, abilityRecord->GetSessionInfo());
2692 }
2693 CompleteStartServiceReq(abilityRecord->GetURI());
2694 }
2695
HandleForegroundTimeoutTask(const std::shared_ptr<AbilityRecord> & abilityRecord)2696 void AbilityConnectManager::HandleForegroundTimeoutTask(const std::shared_ptr<AbilityRecord> &abilityRecord)
2697 {
2698 std::lock_guard guard(serialMutex_);
2699 if (abilityRecord == nullptr) {
2700 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityRecord is nullptr");
2701 return;
2702 }
2703 if (UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType) &&
2704 uiExtensionAbilityRecordMgr_ != nullptr && IsCallerValid(abilityRecord)) {
2705 TAG_LOGW(AAFwkTag::ABILITYMGR, "Start foreground timeout.");
2706 uiExtensionAbilityRecordMgr_->ForegroundTimeout(abilityRecord->GetUIExtensionAbilityId());
2707 }
2708 abilityRecord->SetAbilityState(AbilityState::BACKGROUND);
2709 abilityRecord->DoBackgroundAbilityWindowDelayed(false);
2710 CompleteStartServiceReq(abilityRecord->GetURI());
2711 }
2712
CompleteBackground(const std::shared_ptr<AbilityRecord> & abilityRecord)2713 void AbilityConnectManager::CompleteBackground(const std::shared_ptr<AbilityRecord> &abilityRecord)
2714 {
2715 std::lock_guard lock(serialMutex_);
2716 if (abilityRecord == nullptr) {
2717 TAG_LOGE(AAFwkTag::ABILITYMGR, "abilityRecord is nullptr");
2718 return;
2719 }
2720 if (abilityRecord->GetAbilityState() != AbilityState::BACKGROUNDING) {
2721 TAG_LOGE(AAFwkTag::ABILITYMGR, "Ability state is %{public}d, it can't complete background.",
2722 abilityRecord->GetAbilityState());
2723 return;
2724 }
2725 abilityRecord->SetAbilityState(AbilityState::BACKGROUND);
2726 // send application state to AppMS.
2727 // notify AppMS to update application state.
2728 DelayedSingleton<AppScheduler>::GetInstance()->MoveToBackground(abilityRecord->GetToken());
2729 CompleteStartServiceReq(abilityRecord->GetURI());
2730 // Abilities ahead of the one started were put in terminate list, we need to terminate them.
2731 TerminateAbilityLocked(abilityRecord->GetToken());
2732 }
2733
PrintTimeOutLog(const std::shared_ptr<AbilityRecord> & ability,uint32_t msgId,bool isHalf)2734 void AbilityConnectManager::PrintTimeOutLog(const std::shared_ptr<AbilityRecord> &ability, uint32_t msgId, bool isHalf)
2735 {
2736 CHECK_POINTER(ability);
2737 AppExecFwk::RunningProcessInfo processInfo = {};
2738 DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByToken(ability->GetToken(), processInfo);
2739 if (processInfo.pid_ == 0) {
2740 TAG_LOGE(AAFwkTag::ABILITYMGR, "ability %{public}s pid invalid", ability->GetURI().c_str());
2741 return;
2742 }
2743 int typeId = AppExecFwk::AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT;
2744 std::string msgContent = "ability:" + ability->GetAbilityInfo().name + " ";
2745 switch (msgId) {
2746 case AbilityManagerService::LOAD_TIMEOUT_MSG:
2747 msgContent += "load timeout";
2748 typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT;
2749 break;
2750 case AbilityManagerService::ACTIVE_TIMEOUT_MSG:
2751 msgContent += "active timeout";
2752 break;
2753 case AbilityManagerService::INACTIVE_TIMEOUT_MSG:
2754 msgContent += "inactive timeout";
2755 break;
2756 case AbilityManagerService::FOREGROUND_TIMEOUT_MSG:
2757 msgContent += "foreground timeout";
2758 typeId = AppExecFwk::AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT;
2759 break;
2760 case AbilityManagerService::BACKGROUND_TIMEOUT_MSG:
2761 msgContent += "background timeout";
2762 break;
2763 case AbilityManagerService::TERMINATE_TIMEOUT_MSG:
2764 msgContent += "terminate timeout";
2765 break;
2766 default:
2767 return;
2768 }
2769
2770 TAG_LOGW(AAFwkTag::ABILITYMGR,
2771 "LIFECYCLE_TIMEOUT: uid: %{public}d, pid: %{public}d, bundleName: %{public}s, abilityName: %{public}s,"
2772 "msg: %{public}s", processInfo.uid_, processInfo.pid_, ability->GetAbilityInfo().bundleName.c_str(),
2773 ability->GetAbilityInfo().name.c_str(), msgContent.c_str());
2774 std::string eventName = isHalf ?
2775 AppExecFwk::AppFreezeType::LIFECYCLE_HALF_TIMEOUT : AppExecFwk::AppFreezeType::LIFECYCLE_TIMEOUT;
2776 AppExecFwk::AppfreezeManager::ParamInfo info = {
2777 .typeId = typeId,
2778 .pid = processInfo.pid_,
2779 .eventName = eventName,
2780 .bundleName = ability->GetAbilityInfo().bundleName,
2781 .msg = msgContent
2782 };
2783 AppExecFwk::AppfreezeManager::GetInstance()->LifecycleTimeoutHandle(info);
2784 }
2785
MoveToTerminatingMap(const std::shared_ptr<AbilityRecord> & abilityRecord)2786 void AbilityConnectManager::MoveToTerminatingMap(const std::shared_ptr<AbilityRecord>& abilityRecord)
2787 {
2788 CHECK_POINTER(abilityRecord);
2789 auto& abilityInfo = abilityRecord->GetAbilityInfo();
2790 std::lock_guard lock(serviceMapMutex_);
2791 terminatingExtensionList_.push_back(abilityRecord);
2792 std::string serviceKey = abilityRecord->GetURI();
2793 if (FRS_BUNDLE_NAME == abilityInfo.bundleName) {
2794 AppExecFwk::ElementName element(abilityInfo.deviceId, abilityInfo.bundleName, abilityInfo.name,
2795 abilityInfo.moduleName);
2796 serviceKey = element.GetURI() + std::to_string(abilityRecord->GetWant().GetIntParam(FRS_APP_INDEX, 0));
2797 }
2798 serviceMap_.erase(serviceKey);
2799 AbilityCacheManager::GetInstance().Remove(abilityRecord);
2800 if (IsSpecialAbility(abilityRecord->GetAbilityInfo())) {
2801 TAG_LOGI(AAFwkTag::ABILITYMGR, "Moving ability: %{public}s", abilityRecord->GetURI().c_str());
2802 }
2803 }
2804
AddUIExtWindowDeathRecipient(const sptr<IRemoteObject> & session)2805 void AbilityConnectManager::AddUIExtWindowDeathRecipient(const sptr<IRemoteObject> &session)
2806 {
2807 CHECK_POINTER(session);
2808 std::lock_guard lock(uiExtRecipientMapMutex_);
2809 auto it = uiExtRecipientMap_.find(session);
2810 if (it != uiExtRecipientMap_.end()) {
2811 TAG_LOGE(AAFwkTag::ABILITYMGR, "This death recipient has been added.");
2812 return;
2813 } else {
2814 std::weak_ptr<AbilityConnectManager> thisWeakPtr(shared_from_this());
2815 sptr<IRemoteObject::DeathRecipient> deathRecipient =
2816 new AbilityConnectCallbackRecipient([thisWeakPtr](const wptr<IRemoteObject> &remote) {
2817 auto abilityConnectManager = thisWeakPtr.lock();
2818 if (abilityConnectManager) {
2819 abilityConnectManager->OnUIExtWindowDied(remote);
2820 }
2821 });
2822 if (!session->AddDeathRecipient(deathRecipient)) {
2823 TAG_LOGE(AAFwkTag::ABILITYMGR, "AddDeathRecipient failed.");
2824 }
2825 uiExtRecipientMap_.emplace(session, deathRecipient);
2826 }
2827 }
2828
RemoveUIExtWindowDeathRecipient(const sptr<IRemoteObject> & session)2829 void AbilityConnectManager::RemoveUIExtWindowDeathRecipient(const sptr<IRemoteObject> &session)
2830 {
2831 CHECK_POINTER(session);
2832 std::lock_guard lock(uiExtRecipientMapMutex_);
2833 auto it = uiExtRecipientMap_.find(session);
2834 if (it != uiExtRecipientMap_.end() && it->first != nullptr) {
2835 it->first->RemoveDeathRecipient(it->second);
2836 uiExtRecipientMap_.erase(it);
2837 return;
2838 }
2839 }
2840
OnUIExtWindowDied(const wptr<IRemoteObject> & remote)2841 void AbilityConnectManager::OnUIExtWindowDied(const wptr<IRemoteObject> &remote)
2842 {
2843 auto object = remote.promote();
2844 CHECK_POINTER(object);
2845 if (taskHandler_) {
2846 auto task = [object, connectManager = shared_from_this()]() {
2847 connectManager->HandleUIExtWindowDiedTask(object);
2848 };
2849 taskHandler_->SubmitTask(task);
2850 }
2851 }
2852
HandleUIExtWindowDiedTask(const sptr<IRemoteObject> & remote)2853 void AbilityConnectManager::HandleUIExtWindowDiedTask(const sptr<IRemoteObject> &remote)
2854 {
2855 TAG_LOGD(AAFwkTag::ABILITYMGR, "call.");
2856 CHECK_POINTER(remote);
2857 std::shared_ptr<AbilityRecord> abilityRecord;
2858 sptr<SessionInfo> sessionInfo;
2859 {
2860 std::lock_guard guard(uiExtensionMapMutex_);
2861 auto it = uiExtensionMap_.find(remote);
2862 if (it != uiExtensionMap_.end()) {
2863 abilityRecord = it->second.first.lock();
2864 sessionInfo = it->second.second;
2865 TAG_LOGW(AAFwkTag::UI_EXT, "uiExtAbility caller died");
2866 uiExtensionMap_.erase(it);
2867 } else {
2868 TAG_LOGI(AAFwkTag::ABILITYMGR, "Died object can't find from map.");
2869 return;
2870 }
2871 }
2872
2873 if (abilityRecord) {
2874 TerminateAbilityWindowLocked(abilityRecord, sessionInfo);
2875 } else {
2876 TAG_LOGI(AAFwkTag::ABILITYMGR, "abilityRecord is nullptr");
2877 }
2878 RemoveUIExtWindowDeathRecipient(remote);
2879 }
2880
IsUIExtensionFocused(uint32_t uiExtensionTokenId,const sptr<IRemoteObject> & focusToken)2881 bool AbilityConnectManager::IsUIExtensionFocused(uint32_t uiExtensionTokenId, const sptr<IRemoteObject>& focusToken)
2882 {
2883 TAG_LOGD(AAFwkTag::ABILITYMGR, "called, id: %{public}u", uiExtensionTokenId);
2884 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, false);
2885 std::lock_guard guard(uiExtensionMapMutex_);
2886 for (auto& item: uiExtensionMap_) {
2887 auto uiExtension = item.second.first.lock();
2888 auto sessionInfo = item.second.second;
2889 if (uiExtension && uiExtension->GetApplicationInfo().accessTokenId == uiExtensionTokenId) {
2890 if (sessionInfo && uiExtensionAbilityRecordMgr_->IsFocused(
2891 uiExtension->GetUIExtensionAbilityId(), sessionInfo->callerToken, focusToken)) {
2892 TAG_LOGD(AAFwkTag::ABILITYMGR, "Focused");
2893 return true;
2894 }
2895 if (sessionInfo && sessionInfo->callerToken == focusToken) {
2896 return true;
2897 }
2898 }
2899 }
2900 return false;
2901 }
2902
GetUIExtensionSourceToken(const sptr<IRemoteObject> & token)2903 sptr<IRemoteObject> AbilityConnectManager::GetUIExtensionSourceToken(const sptr<IRemoteObject> &token)
2904 {
2905 TAG_LOGD(AAFwkTag::ABILITYMGR, "Called");
2906 std::lock_guard guard(uiExtensionMapMutex_);
2907 for (auto &item : uiExtensionMap_) {
2908 auto sessionInfo = item.second.second;
2909 auto uiExtension = item.second.first.lock();
2910 if (sessionInfo != nullptr && uiExtension != nullptr && uiExtension->GetToken() != nullptr &&
2911 uiExtension->GetToken()->AsObject() == token) {
2912 TAG_LOGD(AAFwkTag::ABILITYMGR, "The source token found.");
2913 return sessionInfo->callerToken;
2914 }
2915 }
2916 return nullptr;
2917 }
2918
GetUIExtensionCallerTokenList(const std::shared_ptr<AbilityRecord> & abilityRecord,std::list<sptr<IRemoteObject>> & callerList)2919 void AbilityConnectManager::GetUIExtensionCallerTokenList(const std::shared_ptr<AbilityRecord> &abilityRecord,
2920 std::list<sptr<IRemoteObject>> &callerList)
2921 {
2922 CHECK_POINTER(uiExtensionAbilityRecordMgr_);
2923 uiExtensionAbilityRecordMgr_->GetCallerTokenList(abilityRecord, callerList);
2924 }
2925
IsWindowExtensionFocused(uint32_t extensionTokenId,const sptr<IRemoteObject> & focusToken)2926 bool AbilityConnectManager::IsWindowExtensionFocused(uint32_t extensionTokenId, const sptr<IRemoteObject>& focusToken)
2927 {
2928 std::lock_guard guard(windowExtensionMapMutex_);
2929 for (auto& item: windowExtensionMap_) {
2930 uint32_t windowExtTokenId = item.second.first;
2931 auto sessionInfo = item.second.second;
2932 if (windowExtTokenId == extensionTokenId && sessionInfo && sessionInfo->callerToken == focusToken) {
2933 return true;
2934 }
2935 }
2936 return false;
2937 }
2938
HandleProcessFrozen(const std::vector<int32_t> & pidList,int32_t uid)2939 void AbilityConnectManager::HandleProcessFrozen(const std::vector<int32_t> &pidList, int32_t uid)
2940 {
2941 auto taskHandler = taskHandler_;
2942 if (!taskHandler) {
2943 TAG_LOGE(AAFwkTag::ABILITYMGR, "taskHandler null");
2944 return;
2945 }
2946 TAG_LOGI(AAFwkTag::ABILITYMGR, "HandleProcessFrozen: %{public}d", uid);
2947 std::unordered_set<int32_t> pidSet(pidList.begin(), pidList.end());
2948 std::lock_guard lock(serviceMapMutex_);
2949 auto weakThis = weak_from_this();
2950 for (auto [key, abilityRecord] : serviceMap_) {
2951 if (abilityRecord && abilityRecord->GetUid() == uid &&
2952 abilityRecord->GetAbilityInfo().extensionAbilityType == AppExecFwk::ExtensionAbilityType::SERVICE &&
2953 pidSet.count(abilityRecord->GetPid()) > 0 &&
2954 abilityRecord->GetAbilityInfo().bundleName != FROZEN_WHITE_DIALOG &&
2955 abilityRecord->IsConnectListEmpty() &&
2956 !abilityRecord->GetKeepAlive()) {
2957 taskHandler->SubmitTask([weakThis, record = abilityRecord]() {
2958 auto connectManager = weakThis.lock();
2959 if (record && connectManager) {
2960 TAG_LOGI(AAFwkTag::ABILITYMGR, "TerminateRecord: %{public}s",
2961 record->GetAbilityInfo().bundleName.c_str());
2962 connectManager->TerminateRecord(record);
2963 } else {
2964 TAG_LOGE(AAFwkTag::ABILITYMGR, "connectManager null");
2965 }
2966 });
2967 }
2968 }
2969 }
2970
PostExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> & connectRecord)2971 void AbilityConnectManager::PostExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord)
2972 {
2973 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
2974 CHECK_POINTER(taskHandler_);
2975 CHECK_POINTER(connectRecord);
2976 int32_t recordId = connectRecord->GetRecordId();
2977 std::string taskName = std::string("DelayDisconnectTask_") + std::to_string(recordId);
2978
2979 auto abilityRecord = connectRecord->GetAbilityRecord();
2980 CHECK_POINTER(abilityRecord);
2981 auto typeName = abilityRecord->GetAbilityInfo().extensionTypeName;
2982 int32_t delayTime = DelayedSingleton<ExtensionConfig>::GetInstance()->GetExtensionAutoDisconnectTime(typeName);
2983 if (delayTime == AUTO_DISCONNECT_INFINITY) {
2984 TAG_LOGD(AAFwkTag::ABILITYMGR, "This extension needn't auto disconnect.");
2985 return;
2986 }
2987
2988 auto task = [connectRecord, self = weak_from_this()]() {
2989 auto selfObj = self.lock();
2990 if (selfObj == nullptr) {
2991 TAG_LOGW(AAFwkTag::ABILITYMGR, "mgr is invalid.");
2992 return;
2993 }
2994 TAG_LOGW(AAFwkTag::ABILITYMGR, "Auto disconnect the Extension's connection.");
2995 selfObj->HandleExtensionDisconnectTask(connectRecord);
2996 };
2997 taskHandler_->SubmitTask(task, taskName, delayTime);
2998 }
2999
RemoveExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> & connectRecord)3000 void AbilityConnectManager::RemoveExtensionDelayDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord)
3001 {
3002 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
3003 CHECK_POINTER(taskHandler_);
3004 CHECK_POINTER(connectRecord);
3005 int32_t recordId = connectRecord->GetRecordId();
3006 std::string taskName = std::string("DelayDisconnectTask_") + std::to_string(recordId);
3007 taskHandler_->CancelTask(taskName);
3008 }
3009
HandleExtensionDisconnectTask(const std::shared_ptr<ConnectionRecord> & connectRecord)3010 void AbilityConnectManager::HandleExtensionDisconnectTask(const std::shared_ptr<ConnectionRecord> &connectRecord)
3011 {
3012 TAG_LOGD(AAFwkTag::ABILITYMGR, "call");
3013 std::lock_guard guard(serialMutex_);
3014 CHECK_POINTER(connectRecord);
3015 int result = connectRecord->DisconnectAbility();
3016 if (result != ERR_OK) {
3017 TAG_LOGW(AAFwkTag::ABILITYMGR, "Auto disconnect extension error, ret: %{public}d.", result);
3018 }
3019 if (connectRecord->GetConnectState() == ConnectionState::DISCONNECTED) {
3020 connectRecord->CompleteDisconnect(ERR_OK, false);
3021 RemoveConnectionRecordFromMap(connectRecord);
3022 }
3023 }
3024
IsUIExtensionAbility(const std::shared_ptr<AbilityRecord> & abilityRecord)3025 bool AbilityConnectManager::IsUIExtensionAbility(const std::shared_ptr<AbilityRecord> &abilityRecord)
3026 {
3027 CHECK_POINTER_AND_RETURN(abilityRecord, false);
3028 return UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType);
3029 }
3030
IsCacheExtensionAbilityType(const std::shared_ptr<AbilityRecord> & abilityRecord)3031 bool AbilityConnectManager::IsCacheExtensionAbilityType(const std::shared_ptr<AbilityRecord> &abilityRecord)
3032 {
3033 CHECK_POINTER_AND_RETURN(abilityRecord, false);
3034 return CacheExtensionUtils::IsCacheExtensionType(abilityRecord->GetAbilityInfo().extensionAbilityType);
3035 }
3036
CheckUIExtensionAbilitySessionExist(const std::shared_ptr<AbilityRecord> & abilityRecord)3037 bool AbilityConnectManager::CheckUIExtensionAbilitySessionExist(
3038 const std::shared_ptr<AbilityRecord> &abilityRecord)
3039 {
3040 CHECK_POINTER_AND_RETURN(abilityRecord, false);
3041 std::lock_guard guard(uiExtensionMapMutex_);
3042 for (auto it = uiExtensionMap_.begin(); it != uiExtensionMap_.end(); ++it) {
3043 std::shared_ptr<AbilityRecord> uiExtAbility = it->second.first.lock();
3044 if (abilityRecord == uiExtAbility) {
3045 return true;
3046 }
3047 }
3048
3049 return false;
3050 }
3051
RemoveUIExtensionAbilityRecord(const std::shared_ptr<AbilityRecord> & abilityRecord)3052 void AbilityConnectManager::RemoveUIExtensionAbilityRecord(const std::shared_ptr<AbilityRecord> &abilityRecord)
3053 {
3054 CHECK_POINTER(abilityRecord);
3055 CHECK_POINTER(uiExtensionAbilityRecordMgr_);
3056 if (abilityRecord->GetWant().GetBoolParam(IS_PRELOAD_UIEXTENSION_ABILITY, false)) {
3057 ClearPreloadUIExtensionRecord(abilityRecord);
3058 }
3059 uiExtensionAbilityRecordMgr_->RemoveExtensionRecord(abilityRecord->GetUIExtensionAbilityId());
3060 }
3061
AddUIExtensionAbilityRecordToTerminatedList(const std::shared_ptr<AbilityRecord> & abilityRecord)3062 void AbilityConnectManager::AddUIExtensionAbilityRecordToTerminatedList(
3063 const std::shared_ptr<AbilityRecord> &abilityRecord)
3064 {
3065 CHECK_POINTER(abilityRecord);
3066 CHECK_POINTER(uiExtensionAbilityRecordMgr_);
3067 uiExtensionAbilityRecordMgr_->AddExtensionRecordToTerminatedList(abilityRecord->GetUIExtensionAbilityId());
3068 }
3069
IsCallerValid(const std::shared_ptr<AbilityRecord> & abilityRecord)3070 bool AbilityConnectManager::IsCallerValid(const std::shared_ptr<AbilityRecord> &abilityRecord)
3071 {
3072 CHECK_POINTER_AND_RETURN_LOG(abilityRecord, false, "Invalid caller for UIExtension");
3073 auto sessionInfo = abilityRecord->GetSessionInfo();
3074 CHECK_POINTER_AND_RETURN_LOG(sessionInfo, false, "Invalid caller for UIExtension");
3075 CHECK_POINTER_AND_RETURN_LOG(sessionInfo->sessionToken, false, "Invalid caller for UIExtension");
3076 std::lock_guard lock(uiExtRecipientMapMutex_);
3077 if (uiExtRecipientMap_.find(sessionInfo->sessionToken) == uiExtRecipientMap_.end()) {
3078 TAG_LOGW(AAFwkTag::ABILITYMGR, "Invalid caller for UIExtension.");
3079 return false;
3080 }
3081
3082 TAG_LOGD(AAFwkTag::ABILITYMGR, "The caller survival.");
3083 return true;
3084 }
3085
GetUIExtensionSessionInfo(const sptr<IRemoteObject> token,UIExtensionSessionInfo & uiExtensionSessionInfo)3086 int32_t AbilityConnectManager::GetUIExtensionSessionInfo(const sptr<IRemoteObject> token,
3087 UIExtensionSessionInfo &uiExtensionSessionInfo)
3088 {
3089 CHECK_POINTER_AND_RETURN(token, ERR_NULL_OBJECT);
3090 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, ERR_NULL_OBJECT);
3091 return uiExtensionAbilityRecordMgr_->GetUIExtensionSessionInfo(token, uiExtensionSessionInfo);
3092 }
3093
SignRestartAppFlag(int32_t uid)3094 void AbilityConnectManager::SignRestartAppFlag(int32_t uid)
3095 {
3096 {
3097 std::lock_guard lock(serviceMapMutex_);
3098 for (auto &[key, abilityRecord] : serviceMap_) {
3099 if (abilityRecord == nullptr || abilityRecord->GetUid() != uid) {
3100 continue;
3101 }
3102 abilityRecord->SetRestartAppFlag(true);
3103 }
3104 }
3105 AbilityCacheManager::GetInstance().SignRestartAppFlag(uid);
3106 }
3107
GetUIExtensionRootHostInfo(const sptr<IRemoteObject> token)3108 std::shared_ptr<AAFwk::AbilityRecord> AbilityConnectManager::GetUIExtensionRootHostInfo(const sptr<IRemoteObject> token)
3109 {
3110 CHECK_POINTER_AND_RETURN(token, nullptr);
3111 CHECK_POINTER_AND_RETURN(uiExtensionAbilityRecordMgr_, nullptr);
3112 return uiExtensionAbilityRecordMgr_->GetUIExtensionRootHostInfo(token);
3113 }
3114
AddToServiceMap(const std::string & key,std::shared_ptr<AbilityRecord> abilityRecord)3115 bool AbilityConnectManager::AddToServiceMap(const std::string &key, std::shared_ptr<AbilityRecord> abilityRecord)
3116 {
3117 std::lock_guard lock(serviceMapMutex_);
3118 if (abilityRecord == nullptr) {
3119 return false;
3120 }
3121 auto insert = serviceMap_.emplace(key, abilityRecord);
3122 if (!insert.second) {
3123 TAG_LOGW(AAFwkTag::ABILITYMGR, "record exist: %{public}s", key.c_str());
3124 }
3125 return insert.second;
3126 }
3127
GetServiceMap()3128 AbilityConnectManager::ServiceMapType AbilityConnectManager::GetServiceMap()
3129 {
3130 std::lock_guard lock(serviceMapMutex_);
3131 return serviceMap_;
3132 }
3133
AddConnectObjectToMap(sptr<IRemoteObject> connectObject,const ConnectListType & connectRecordList,bool updateOnly)3134 void AbilityConnectManager::AddConnectObjectToMap(sptr<IRemoteObject> connectObject,
3135 const ConnectListType &connectRecordList, bool updateOnly)
3136 {
3137 if (!updateOnly) {
3138 AddConnectDeathRecipient(connectObject);
3139 }
3140 std::lock_guard guard(connectMapMutex_);
3141 connectMap_[connectObject] = connectRecordList;
3142 }
3143
BuildEventInfo(const std::shared_ptr<AbilityRecord> & abilityRecord)3144 EventInfo AbilityConnectManager::BuildEventInfo(const std::shared_ptr<AbilityRecord> &abilityRecord)
3145 {
3146 EventInfo eventInfo;
3147 if (abilityRecord == nullptr) {
3148 TAG_LOGE(AAFwkTag::ABILITYMGR, "build eventInfo failed, abilityRecord is nullptr");
3149 return eventInfo;
3150 }
3151 AppExecFwk::RunningProcessInfo processInfo;
3152 DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByToken(abilityRecord->GetToken(), processInfo);
3153 eventInfo.pid = processInfo.pid_;
3154 eventInfo.processName = processInfo.processName_;
3155 eventInfo.time = std::chrono::duration_cast<std::chrono::milliseconds>(
3156 std::chrono::system_clock::now().time_since_epoch()).count();
3157 auto callerPid = abilityRecord->GetWant().GetIntParam(Want::PARAM_RESV_CALLER_PID, -1);
3158 eventInfo.callerPid = callerPid == -1 ? IPCSkeleton::GetCallingPid() : callerPid;
3159 DelayedSingleton<AppScheduler>::GetInstance()->GetRunningProcessInfoByPid(eventInfo.callerPid, processInfo);
3160 eventInfo.callerPid = processInfo.pid_;
3161 eventInfo.callerProcessName = processInfo.processName_;
3162 if (!abilityRecord->IsCreateByConnect()) {
3163 auto abilityInfo = abilityRecord->GetAbilityInfo();
3164 eventInfo.extensionType = static_cast<int32_t>(abilityInfo.extensionAbilityType);
3165 eventInfo.userId = userId_;
3166 eventInfo.bundleName = abilityInfo.bundleName;
3167 eventInfo.moduleName = abilityInfo.moduleName;
3168 eventInfo.abilityName = abilityInfo.name;
3169 }
3170 return eventInfo;
3171 }
3172
UpdateUIExtensionInfo(const std::shared_ptr<AbilityRecord> & abilityRecord)3173 void AbilityConnectManager::UpdateUIExtensionInfo(const std::shared_ptr<AbilityRecord> &abilityRecord)
3174 {
3175 if (abilityRecord == nullptr ||
3176 !UIExtensionUtils::IsUIExtension(abilityRecord->GetAbilityInfo().extensionAbilityType)) {
3177 return;
3178 }
3179
3180 WantParams wantParams;
3181 auto uiExtensionAbilityId = abilityRecord->GetUIExtensionAbilityId();
3182 wantParams.SetParam(UIEXTENSION_ABILITY_ID, AAFwk::Integer::Box(uiExtensionAbilityId));
3183 auto rootHostRecord = GetUIExtensionRootHostInfo(abilityRecord->GetToken());
3184 if (rootHostRecord != nullptr) {
3185 auto rootHostPid = rootHostRecord->GetPid();
3186 wantParams.SetParam(UIEXTENSION_ROOT_HOST_PID, AAFwk::Integer::Box(rootHostPid));
3187 }
3188 if (abilityRecord->GetWant().GetBoolParam(IS_PRELOAD_UIEXTENSION_ABILITY, false)) {
3189 // Applicable only to preloadUIExtension scenarios
3190 auto rootHostPid = IPCSkeleton::GetCallingPid();
3191 wantParams.SetParam(UIEXTENSION_ROOT_HOST_PID, AAFwk::Integer::Box(rootHostPid));
3192 }
3193 abilityRecord->UpdateUIExtensionInfo(wantParams);
3194 }
3195
GenerateBundleName(const AbilityRequest & abilityRequest) const3196 std::string AbilityConnectManager::GenerateBundleName(const AbilityRequest &abilityRequest) const
3197 {
3198 auto bundleName = abilityRequest.abilityInfo.bundleName;
3199 if (AbilityRuntime::StartupUtil::IsSupportAppClone(abilityRequest.abilityInfo.extensionAbilityType)) {
3200 auto appCloneIndex = abilityRequest.want.GetIntParam(Want::PARAM_APP_CLONE_INDEX_KEY, 0);
3201 if (appCloneIndex > 0) {
3202 bundleName = std::to_string(appCloneIndex) + bundleName;
3203 }
3204 }
3205 return bundleName;
3206 }
3207
ReportXiaoYiToRSSIfNeeded(const AppExecFwk::AbilityInfo & abilityInfo)3208 int32_t AbilityConnectManager::ReportXiaoYiToRSSIfNeeded(const AppExecFwk::AbilityInfo &abilityInfo)
3209 {
3210 if (abilityInfo.type != AppExecFwk::AbilityType::EXTENSION ||
3211 abilityInfo.bundleName != XIAOYI_BUNDLE_NAME) {
3212 return ERR_OK;
3213 }
3214 TAG_LOGI(AAFwkTag::ABILITYMGR,
3215 "bundleName is com.huawei.hmos.vassistant extension, abilityName:%{public}s, report to rss.",
3216 abilityInfo.name.c_str());
3217 auto ret = ReportAbilityStartInfoToRSS(abilityInfo);
3218 if (ret != ERR_OK) {
3219 TAG_LOGE(AAFwkTag::ABILITYMGR, "ReportAbilitStartInfoToRSS failed, ret:%{public}d", ret);
3220 return ret;
3221 }
3222 return ERR_OK;
3223 }
3224
ReportAbilityStartInfoToRSS(const AppExecFwk::AbilityInfo & abilityInfo)3225 int32_t AbilityConnectManager::ReportAbilityStartInfoToRSS(const AppExecFwk::AbilityInfo &abilityInfo)
3226 {
3227 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
3228 std::vector<AppExecFwk::RunningProcessInfo> runningProcessInfos;
3229 auto ret = IN_PROCESS_CALL(DelayedSingleton<AppScheduler>::GetInstance()->GetProcessRunningInfos(
3230 runningProcessInfos));
3231 if (ret != ERR_OK) {
3232 return ret;
3233 }
3234 bool isColdStart = true;
3235 int32_t pid = 0;
3236 for (auto const &info : runningProcessInfos) {
3237 if (info.uid_ == abilityInfo.applicationInfo.uid) {
3238 isColdStart = false;
3239 pid = info.pid_;
3240 break;
3241 }
3242 }
3243 TAG_LOGI(AAFwkTag::ABILITYMGR, "ReportAbilityStartInfoToRSS, abilityName:%{public}s", abilityInfo.name.c_str());
3244 ResSchedUtil::GetInstance().ReportAbilityStartInfoToRSS(abilityInfo, pid, isColdStart);
3245 return ERR_OK;
3246 }
3247
UninstallApp(const std::string & bundleName,int32_t uid)3248 void AbilityConnectManager::UninstallApp(const std::string &bundleName, int32_t uid)
3249 {
3250 std::lock_guard lock(serviceMapMutex_);
3251 for (const auto &[key, abilityRecord]: serviceMap_) {
3252 if (abilityRecord && abilityRecord->GetAbilityInfo().bundleName == bundleName &&
3253 abilityRecord->GetUid() == uid) {
3254 abilityRecord->SetKeepAliveBundle(false);
3255 }
3256 }
3257 }
3258
UpdateKeepAliveEnableState(const std::string & bundleName,const std::string & moduleName,const std::string & mainElement,bool updateEnable)3259 int32_t AbilityConnectManager::UpdateKeepAliveEnableState(const std::string &bundleName,
3260 const std::string &moduleName, const std::string &mainElement, bool updateEnable)
3261 {
3262 std::lock_guard lock(serviceMapMutex_);
3263 for (const auto &[key, abilityRecord]: serviceMap_) {
3264 CHECK_POINTER_AND_RETURN(abilityRecord, ERR_NULL_OBJECT);
3265 if (abilityRecord->GetAbilityInfo().bundleName == bundleName &&
3266 abilityRecord->GetAbilityInfo().name == mainElement &&
3267 abilityRecord->GetAbilityInfo().moduleName == moduleName) {
3268 TAG_LOGI(AAFwkTag::ABILITYMGR,
3269 "update keepAlive,bundle:%{public}s,module:%{public}s,ability:%{public}s,enable:%{public}d",
3270 bundleName.c_str(), moduleName.c_str(), mainElement.c_str(), updateEnable);
3271 abilityRecord->SetKeepAliveBundle(updateEnable);
3272 return ERR_OK;
3273 }
3274 }
3275 return ERR_OK;
3276 }
3277 } // namespace AAFwk
3278 } // namespace OHOS
3279