1 /*
2 * Copyright (c) 2022 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_state_observer.h"
17
18 #include "app_mgr_constants.h"
19 #include "iservice_registry.h"
20 #include "system_ability_definition.h"
21
22 #include "bg_continuous_task_mgr.h"
23 #include "bg_transient_task_mgr.h"
24 #include "continuous_task_log.h"
25 #include "bg_efficiency_resources_mgr.h"
26
27 namespace OHOS {
28 namespace BackgroundTaskMgr {
29 namespace {
30 const std::string TASK_ON_PROCESS_DIED = "OnProcessDiedTask";
31 const std::string TASK_ON_ABILITY_STATE_CHANGED = "OnAbilityStateChangedTask";
32 const std::string TASK_ON_APP_CACHE_STATE_CHANGED = "OnAppCacheStateChangedTask";
33 const std::string TASK_ON_APP_DIED = "OnAppDiedTask";
34 }
35
OnAbilityStateChanged(const AppExecFwk::AbilityStateData & abilityStateData)36 void AppStateObserver::OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData)
37 {
38 if (abilityStateData.abilityState != static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED)) {
39 return;
40 }
41 BGTASK_LOGI("ability state changed, uid: %{public}d abilityName: %{public}s, abilityState: %{public}d, "
42 "abilityId: %{public}d",
43 abilityStateData.uid, abilityStateData.abilityName.c_str(), abilityStateData.abilityState,
44 abilityStateData.abilityRecordId);
45 int32_t uid = abilityStateData.uid;
46 int32_t abilityId = abilityStateData.abilityRecordId;
47 std::string abilityName = abilityStateData.abilityName;
48 auto task = [uid, abilityName, abilityId]() {
49 DelayedSingleton<BgContinuousTaskMgr>::GetInstance()->OnAbilityStateChanged(uid, abilityName, abilityId);
50 };
51 if (!handler_) {
52 BGTASK_LOGE("handler_ null");
53 return;
54 }
55 handler_->PostTask(task, TASK_ON_ABILITY_STATE_CHANGED);
56 }
57
OnAppCacheStateChanged(const AppExecFwk::AppStateData & appStateData)58 void AppStateObserver::OnAppCacheStateChanged(const AppExecFwk::AppStateData &appStateData)
59 {
60 if (appStateData.state != static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_CACHED)) {
61 return;
62 }
63 if (!handler_) {
64 BGTASK_LOGE("handler_ null");
65 return;
66 }
67 BGTASK_LOGI("app cache, name : %{public}s, uid : %{public}d, pid : %{public}d, state : %{public}d,",
68 appStateData.bundleName.c_str(), appStateData.uid, appStateData.pid, appStateData.state);
69 int32_t uid = appStateData.uid;
70 int32_t pid = appStateData.pid;
71 std::string bundleName = appStateData.bundleName;
72 auto task = [uid, pid, bundleName]() {
73 DelayedSingleton<BgTransientTaskMgr>::GetInstance()->OnAppCacheStateChanged(uid, pid, bundleName);
74 };
75 handler_->PostTask(task, TASK_ON_APP_CACHE_STATE_CHANGED);
76 }
77
OnProcessDied(const AppExecFwk::ProcessData & processData)78 void AppStateObserver::OnProcessDied(const AppExecFwk::ProcessData &processData)
79 {
80 BGTASK_LOGD("process died, uid : %{public}d, pid : %{public}d", processData.uid, processData.pid);
81 OnProcessDiedEfficiencyRes(processData);
82 }
83
OnProcessDiedEfficiencyRes(const AppExecFwk::ProcessData & processData)84 void AppStateObserver::OnProcessDiedEfficiencyRes(const AppExecFwk::ProcessData &processData)
85 {
86 DelayedSingleton<BgEfficiencyResourcesMgr>::GetInstance()->
87 RemoveProcessRecord(processData.uid, processData.pid, processData.bundleName);
88 }
89
OnAppStopped(const AppExecFwk::AppStateData & appStateData)90 void AppStateObserver::OnAppStopped(const AppExecFwk::AppStateData &appStateData)
91 {
92 BGTASK_LOGD("app stopped, uid : %{public}d", appStateData.uid);
93 if (!ValidateAppStateData(appStateData)) {
94 BGTASK_LOGE("%{public}s : validate app state data failed!", __func__);
95 return;
96 }
97 auto uid = appStateData.uid;
98 auto bundleName = appStateData.bundleName;
99 auto task = [uid]() {
100 DelayedSingleton<BgContinuousTaskMgr>::GetInstance()->OnAppStopped(uid);
101 };
102 if (!handler_) {
103 BGTASK_LOGE("handler_ null.");
104 } else {
105 handler_->PostTask(task, TASK_ON_APP_DIED);
106 }
107 DelayedSingleton<BgEfficiencyResourcesMgr>::GetInstance()->RemoveAppRecord(uid, bundleName, false);
108 }
109
ValidateAppStateData(const AppExecFwk::AppStateData & appStateData)110 bool AppStateObserver::ValidateAppStateData(const AppExecFwk::AppStateData &appStateData)
111 {
112 return appStateData.uid > 0 && appStateData.bundleName.size() > 0;
113 }
114
SetEventHandler(const std::shared_ptr<AppExecFwk::EventHandler> & handler)115 void AppStateObserver::SetEventHandler(const std::shared_ptr<AppExecFwk::EventHandler> &handler)
116 {
117 handler_ = handler;
118 }
119 } // namespace BackgroundTaskMgr
120 } // namespace OHOS