1 /*
2 * Copyright (c) 2021-2025 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 "app_lifecycle_deal.h"
17
18 #include "freeze_util.h"
19 #include "hilog_tag_wrapper.h"
20 #include "hitrace_meter.h"
21 #include "in_process_call_wrapper.h"
22 #include "time_util.h"
23 #include "app_mgr_service_const.h"
24 #include "app_mgr_service_dump_error_code.h"
25 #include "bundle_mgr_helper.h"
26
27 namespace OHOS {
28 using AbilityRuntime::FreezeUtil;
29 namespace AppExecFwk {
30 namespace {
31 constexpr const char* REUSING_WINDOW = "ohos.ability_runtime.reusing_window";
32 constexpr const char* IS_HOOK = "ohos.ability_runtime.is_hook";
33 }
AppLifeCycleDeal()34 AppLifeCycleDeal::AppLifeCycleDeal()
35 {}
36
~AppLifeCycleDeal()37 AppLifeCycleDeal::~AppLifeCycleDeal()
38 {
39 TAG_LOGD(AAFwkTag::APPMGR, "called");
40 }
41
LaunchApplication(const AppLaunchData & launchData,const Configuration & config)42 void AppLifeCycleDeal::LaunchApplication(const AppLaunchData &launchData, const Configuration &config)
43 {
44 HITRACE_METER_NAME(HITRACE_TAG_APP, __PRETTY_FUNCTION__);
45 TAG_LOGD(AAFwkTag::APPMGR, "called");
46 auto appThread = GetApplicationClient();
47 if (appThread) {
48 appThread->ScheduleLaunchApplication(launchData, config);
49 }
50 }
51
UpdateApplicationInfoInstalled(const ApplicationInfo & appInfo,const std::string & moduleName)52 void AppLifeCycleDeal::UpdateApplicationInfoInstalled(const ApplicationInfo &appInfo, const std::string &moduleName)
53 {
54 auto appThread = GetApplicationClient();
55 if (!appThread) {
56 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
57 return;
58 }
59
60 appThread->ScheduleUpdateApplicationInfoInstalled(appInfo, moduleName);
61 }
62
AddAbilityStage(const HapModuleInfo & abilityStage)63 void AppLifeCycleDeal::AddAbilityStage(const HapModuleInfo &abilityStage)
64 {
65 auto appThread = GetApplicationClient();
66 if (!appThread) {
67 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
68 return;
69 }
70
71 appThread->ScheduleAbilityStage(abilityStage);
72 }
73
LaunchAbility(const std::shared_ptr<AbilityRunningRecord> & ability)74 void AppLifeCycleDeal::LaunchAbility(const std::shared_ptr<AbilityRunningRecord> &ability)
75 {
76 auto appThread = GetApplicationClient();
77 if (appThread && ability) {
78 auto abilityInfo = ability->GetAbilityInfo();
79 if (abilityInfo == nullptr) {
80 TAG_LOGW(AAFwkTag::APPMGR, "null abilityInfo");
81 return;
82 }
83 if (abilityInfo->type == AbilityType::PAGE) {
84 std::string entry = "AppLifeCycleDeal::LaunchAbility";
85 FreezeUtil::GetInstance().AddLifecycleEvent(ability->GetToken(), entry);
86 }
87 TAG_LOGD(AAFwkTag::APPMGR, "Launch");
88 bool isHookAbility = ability->IsHook();
89 if (isHookAbility) {
90 auto bundleManagerHelper = DelayedSingleton<AppExecFwk::BundleMgrHelper>::GetInstance();
91 HapModuleInfo hapModuleInfo;
92 if (!bundleManagerHelper->GetHapModuleInfo(*abilityInfo, hapModuleInfo)) {
93 TAG_LOGW(AAFwkTag::APPMGR, "GetHapModuleInfo fail");
94 return;
95 }
96 int32_t BASE_USER_RANGE = 200000;
97 auto userId = abilityInfo->uid / BASE_USER_RANGE;
98 abilityInfo = std::make_shared<AbilityInfo>();
99 Want want;
100 want.SetElementName("", hapModuleInfo.bundleName, hapModuleInfo.abilitySrcEntryDelegator,
101 hapModuleInfo.abilityStageSrcEntryDelegator);
102 if (!IN_PROCESS_CALL(bundleManagerHelper->QueryAbilityInfo(
103 want, AppExecFwk::AbilityInfoFlag::GET_ABILITY_INFO_WITH_APPLICATION, userId, *abilityInfo))) {
104 TAG_LOGW(AAFwkTag::APPMGR, "QueryAbilityInfo fail");
105 return;
106 }
107 }
108 appThread->ScheduleLaunchAbility(*abilityInfo, ability->GetToken(),
109 ability->GetWant(), ability->GetAbilityRecordId());
110 if (ability->GetWant() != nullptr) {
111 ability->GetWant()->RemoveParam(REUSING_WINDOW);
112 ability->GetWant()->RemoveParam(IS_HOOK);
113 }
114 } else {
115 TAG_LOGW(AAFwkTag::APPMGR, "null appThread or ability");
116 }
117 }
118
ScheduleTerminate(bool isLastProcess)119 void AppLifeCycleDeal::ScheduleTerminate(bool isLastProcess)
120 {
121 auto appThread = GetApplicationClient();
122 if (!appThread) {
123 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
124 return;
125 }
126
127 appThread->ScheduleTerminateApplication(isLastProcess);
128 }
129
ScheduleForegroundRunning()130 bool AppLifeCycleDeal::ScheduleForegroundRunning()
131 {
132 auto appThread = GetApplicationClient();
133 if (!appThread) {
134 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
135 return false;
136 }
137
138 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
139 return appThread->ScheduleForegroundApplication();
140 }
141
ScheduleBackgroundRunning()142 void AppLifeCycleDeal::ScheduleBackgroundRunning()
143 {
144 auto appThread = GetApplicationClient();
145 if (!appThread) {
146 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
147 return;
148 }
149
150 appThread->ScheduleBackgroundApplication();
151 }
152
ScheduleTrimMemory(int32_t timeLevel)153 void AppLifeCycleDeal::ScheduleTrimMemory(int32_t timeLevel)
154 {
155 auto appThread = GetApplicationClient();
156 if (!appThread) {
157 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
158 return;
159 }
160
161 appThread->ScheduleShrinkMemory(timeLevel);
162 }
163
ScheduleMemoryLevel(int32_t Level)164 void AppLifeCycleDeal::ScheduleMemoryLevel(int32_t Level)
165 {
166 auto appThread = GetApplicationClient();
167 if (!appThread) {
168 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
169 return;
170 }
171
172 appThread->ScheduleMemoryLevel(Level);
173 }
174
ScheduleHeapMemory(const int32_t pid,OHOS::AppExecFwk::MallocInfo & mallocInfo)175 void AppLifeCycleDeal::ScheduleHeapMemory(const int32_t pid, OHOS::AppExecFwk::MallocInfo &mallocInfo)
176 {
177 auto appThread = GetApplicationClient();
178 if (!appThread) {
179 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
180 return;
181 }
182
183 appThread->ScheduleHeapMemory(pid, mallocInfo);
184 }
185
ScheduleJsHeapMemory(OHOS::AppExecFwk::JsHeapDumpInfo & info)186 void AppLifeCycleDeal::ScheduleJsHeapMemory(OHOS::AppExecFwk::JsHeapDumpInfo &info)
187 {
188 auto appThread = GetApplicationClient();
189 if (!appThread) {
190 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
191 return;
192 }
193
194 appThread->ScheduleJsHeapMemory(info);
195 }
196
ScheduleCjHeapMemory(OHOS::AppExecFwk::CjHeapDumpInfo & info)197 void AppLifeCycleDeal::ScheduleCjHeapMemory(OHOS::AppExecFwk::CjHeapDumpInfo &info)
198 {
199 auto appThread = GetApplicationClient();
200 if (!appThread) {
201 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
202 return;
203 }
204
205 appThread->ScheduleCjHeapMemory(info);
206 }
207
LowMemoryWarning()208 void AppLifeCycleDeal::LowMemoryWarning()
209 {
210 auto appThread = GetApplicationClient();
211 if (!appThread) {
212 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
213 return;
214 }
215
216 appThread->ScheduleLowMemory();
217 }
218
ScheduleCleanAbility(const sptr<IRemoteObject> & token,bool isCacheProcess)219 void AppLifeCycleDeal::ScheduleCleanAbility(const sptr<IRemoteObject> &token, bool isCacheProcess)
220 {
221 auto appThread = GetApplicationClient();
222 if (!appThread) {
223 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
224 return;
225 }
226 appThread->ScheduleCleanAbility(token, isCacheProcess);
227 }
228
ScheduleProcessSecurityExit()229 void AppLifeCycleDeal::ScheduleProcessSecurityExit()
230 {
231 auto appThread = GetApplicationClient();
232 if (!appThread) {
233 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
234 return;
235 }
236
237 appThread->ScheduleProcessSecurityExit();
238 }
239
ScheduleClearPageStack()240 void AppLifeCycleDeal::ScheduleClearPageStack()
241 {
242 auto appThread = GetApplicationClient();
243 if (!appThread) {
244 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
245 return;
246 }
247
248 appThread->ScheduleClearPageStack();
249 }
250
SetApplicationClient(const sptr<IAppScheduler> & thread)251 void AppLifeCycleDeal::SetApplicationClient(const sptr<IAppScheduler> &thread)
252 {
253 std::lock_guard guard(schedulerMutex_);
254 appThread_ = thread;
255 }
256
GetApplicationClient() const257 sptr<IAppScheduler> AppLifeCycleDeal::GetApplicationClient() const
258 {
259 std::lock_guard guard(schedulerMutex_);
260 return appThread_;
261 }
262
ScheduleAcceptWant(const AAFwk::Want & want,const std::string & moduleName)263 void AppLifeCycleDeal::ScheduleAcceptWant(const AAFwk::Want &want, const std::string &moduleName)
264 {
265 auto appThread = GetApplicationClient();
266 if (!appThread) {
267 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
268 return;
269 }
270
271 appThread->ScheduleAcceptWant(want, moduleName);
272 }
273
SchedulePrepareTerminate(const std::string & moduleName)274 void AppLifeCycleDeal::SchedulePrepareTerminate(const std::string &moduleName)
275 {
276 TAG_LOGD(AAFwkTag::APPKIT, "called");
277 auto appThread = GetApplicationClient();
278 if (!appThread) {
279 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
280 return;
281 }
282 appThread->SchedulePrepareTerminate(moduleName);
283 }
284
ScheduleNewProcessRequest(const AAFwk::Want & want,const std::string & moduleName)285 void AppLifeCycleDeal::ScheduleNewProcessRequest(const AAFwk::Want &want, const std::string &moduleName)
286 {
287 auto appThread = GetApplicationClient();
288 if (!appThread) {
289 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
290 return;
291 }
292
293 appThread->ScheduleNewProcessRequest(want, moduleName);
294 }
295
UpdateConfiguration(const Configuration & config)296 int32_t AppLifeCycleDeal::UpdateConfiguration(const Configuration &config)
297 {
298 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
299 TAG_LOGD(AAFwkTag::APPMGR, "call");
300 auto appThread = GetApplicationClient();
301 if (!appThread) {
302 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
303 return ERR_INVALID_VALUE;
304 }
305 appThread->ScheduleConfigurationUpdated(config);
306 return ERR_OK;
307 }
308
NotifyLoadRepairPatch(const std::string & bundleName,const sptr<IQuickFixCallback> & callback,const int32_t recordId)309 int32_t AppLifeCycleDeal::NotifyLoadRepairPatch(const std::string &bundleName, const sptr<IQuickFixCallback> &callback,
310 const int32_t recordId)
311 {
312 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
313 TAG_LOGD(AAFwkTag::APPMGR, "call");
314 auto appThread = GetApplicationClient();
315 if (appThread == nullptr) {
316 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
317 return ERR_INVALID_VALUE;
318 }
319 return appThread->ScheduleNotifyLoadRepairPatch(bundleName, callback, recordId);
320 }
321
NotifyHotReloadPage(const sptr<IQuickFixCallback> & callback,const int32_t recordId)322 int32_t AppLifeCycleDeal::NotifyHotReloadPage(const sptr<IQuickFixCallback> &callback, const int32_t recordId)
323 {
324 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
325 TAG_LOGD(AAFwkTag::APPMGR, "call");
326 auto appThread = GetApplicationClient();
327 if (appThread == nullptr) {
328 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
329 return ERR_INVALID_VALUE;
330 }
331 return appThread->ScheduleNotifyHotReloadPage(callback, recordId);
332 }
333
NotifyUnLoadRepairPatch(const std::string & bundleName,const sptr<IQuickFixCallback> & callback,const int32_t recordId)334 int32_t AppLifeCycleDeal::NotifyUnLoadRepairPatch(const std::string &bundleName,
335 const sptr<IQuickFixCallback> &callback, const int32_t recordId)
336 {
337 HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
338 TAG_LOGD(AAFwkTag::APPMGR, "called");
339 auto appThread = GetApplicationClient();
340 if (appThread == nullptr) {
341 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
342 return ERR_INVALID_VALUE;
343 }
344 return appThread->ScheduleNotifyUnLoadRepairPatch(bundleName, callback, recordId);
345 }
346
NotifyAppFault(const FaultData & faultData)347 int32_t AppLifeCycleDeal::NotifyAppFault(const FaultData &faultData)
348 {
349 TAG_LOGD(AAFwkTag::APPMGR, "called");
350 auto appThread = GetApplicationClient();
351 if (appThread == nullptr) {
352 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
353 return ERR_INVALID_VALUE;
354 }
355 return appThread->ScheduleNotifyAppFault(faultData);
356 }
357
ChangeAppGcState(int32_t state,uint64_t tid)358 int32_t AppLifeCycleDeal::ChangeAppGcState(int32_t state, uint64_t tid)
359 {
360 TAG_LOGD(AAFwkTag::APPMGR, "called");
361 auto appThread = GetApplicationClient();
362 if (appThread == nullptr) {
363 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
364 return ERR_INVALID_VALUE;
365 }
366 return appThread->ScheduleChangeAppGcState(state, tid);
367 }
368
AttachAppDebug(bool isDebugFromLocal)369 int32_t AppLifeCycleDeal::AttachAppDebug(bool isDebugFromLocal)
370 {
371 TAG_LOGD(AAFwkTag::APPMGR, "called");
372 auto appThread = GetApplicationClient();
373 if (appThread == nullptr) {
374 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
375 return ERR_INVALID_VALUE;
376 }
377 appThread->AttachAppDebug(isDebugFromLocal);
378 return ERR_OK;
379 }
380
DetachAppDebug()381 int32_t AppLifeCycleDeal::DetachAppDebug()
382 {
383 TAG_LOGD(AAFwkTag::APPMGR, "called");
384 auto appThread = GetApplicationClient();
385 if (appThread == nullptr) {
386 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
387 return ERR_INVALID_VALUE;
388 }
389 appThread->DetachAppDebug();
390 return ERR_OK;
391 }
392
DumpIpcStart(std::string & result)393 int AppLifeCycleDeal::DumpIpcStart(std::string& result)
394 {
395 TAG_LOGD(AAFwkTag::APPMGR, "called");
396 auto appThread = GetApplicationClient();
397 if (appThread == nullptr) {
398 result.append(MSG_DUMP_IPC_START_STAT, strlen(MSG_DUMP_IPC_START_STAT))
399 .append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
400 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
401 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
402 return DumpErrorCode::ERR_INTERNAL_ERROR;
403 }
404 return appThread->ScheduleDumpIpcStart(result);
405 }
406
DumpIpcStop(std::string & result)407 int AppLifeCycleDeal::DumpIpcStop(std::string& result)
408 {
409 TAG_LOGD(AAFwkTag::APPMGR, "called");
410 auto appThread = GetApplicationClient();
411 if (appThread == nullptr) {
412 result.append(MSG_DUMP_IPC_STOP_STAT, strlen(MSG_DUMP_IPC_STOP_STAT))
413 .append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
414 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
415 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
416 return DumpErrorCode::ERR_INTERNAL_ERROR;
417 }
418 return appThread->ScheduleDumpIpcStop(result);
419 }
420
DumpIpcStat(std::string & result)421 int AppLifeCycleDeal::DumpIpcStat(std::string& result)
422 {
423 TAG_LOGD(AAFwkTag::APPMGR, "called");
424 auto appThread = GetApplicationClient();
425 if (appThread == nullptr) {
426 result.append(MSG_DUMP_IPC_STAT, strlen(MSG_DUMP_IPC_STAT))
427 .append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
428 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
429 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
430 return DumpErrorCode::ERR_INTERNAL_ERROR;
431 }
432 return appThread->ScheduleDumpIpcStat(result);
433 }
434
ScheduleCacheProcess()435 void AppLifeCycleDeal::ScheduleCacheProcess()
436 {
437 auto appThread = GetApplicationClient();
438 if (!appThread) {
439 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
440 return;
441 }
442
443 appThread->ScheduleCacheProcess();
444 }
445
DumpFfrt(std::string & result)446 int AppLifeCycleDeal::DumpFfrt(std::string& result)
447 {
448 TAG_LOGD(AAFwkTag::APPMGR, "called");
449 auto appThread = GetApplicationClient();
450 if (appThread == nullptr) {
451 result.append(MSG_DUMP_FAIL, strlen(MSG_DUMP_FAIL))
452 .append(MSG_DUMP_FAIL_REASON_INTERNAL, strlen(MSG_DUMP_FAIL_REASON_INTERNAL));
453 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
454 return DumpErrorCode::ERR_INTERNAL_ERROR;
455 }
456 return appThread->ScheduleDumpFfrt(result);
457 }
458
SetWatchdogBackgroundStatusRunning(bool status)459 void AppLifeCycleDeal::SetWatchdogBackgroundStatusRunning(bool status)
460 {
461 auto appThread = GetApplicationClient();
462 if (!appThread) {
463 TAG_LOGE(AAFwkTag::APPMGR, "null appThread");
464 return;
465 }
466 appThread->SetWatchdogBackgroundStatus(status);
467 }
468 } // namespace AppExecFwk
469 } // namespace OHOS
470