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 "continuous_task_log.h"
24 #include "bg_efficiency_resources_mgr.h"
25
26 namespace OHOS {
27 namespace BackgroundTaskMgr {
28 namespace {
29 const std::string TASK_ON_PROCESS_DIED = "OnProcessDiedTask";
30 const std::string TASK_ON_ABILITY_STATE_CHANGED = "OnAbilityStateChangedTask";
31 }
32
AppStateObserver()33 AppStateObserver::AppStateObserver() {}
34
~AppStateObserver()35 AppStateObserver::~AppStateObserver() {}
36
CheckParamValid()37 bool AppStateObserver::CheckParamValid()
38 {
39 if (handler_.expired()) {
40 BGTASK_LOGE("AppStateObserver handler is null");
41 return false;
42 }
43 if (bgContinuousTaskMgr_.expired()) {
44 BGTASK_LOGE("AppStateObserver bgContinuousTaskMgr is null");
45 return false;
46 }
47 return true;
48 }
49
OnAbilityStateChanged(const AppExecFwk::AbilityStateData & abilityStateData)50 void AppStateObserver::OnAbilityStateChanged(const AppExecFwk::AbilityStateData &abilityStateData)
51 {
52 if (abilityStateData.abilityState != static_cast<int32_t>(AppExecFwk::AbilityState::ABILITY_STATE_TERMINATED)) {
53 return;
54 }
55 BGTASK_LOGD("ability state changed, uid: %{public}d abilityName: %{public}s, abilityState: %{public}d",
56 abilityStateData.uid, abilityStateData.abilityName.c_str(), abilityStateData.abilityState);
57 if (!CheckParamValid()) {
58 return;
59 }
60 int32_t uid = abilityStateData.uid;
61 std::string abilityName = abilityStateData.abilityName;
62 auto task = [this, uid, abilityName]() {
63 this->bgContinuousTaskMgr_.lock()->OnAbilityStateChanged(uid, abilityName);
64 };
65 handler_.lock()->PostTask(task, TASK_ON_ABILITY_STATE_CHANGED);
66 }
67
OnProcessDied(const AppExecFwk::ProcessData & processData)68 void AppStateObserver::OnProcessDied(const AppExecFwk::ProcessData &processData)
69 {
70 BGTASK_LOGD("process died, uid : %{public}d, pid : %{public}d", processData.uid, processData.pid);
71 OnProcessDiedContinuousTask(processData);
72 OnProcessDiedEfficiencyRes(processData);
73 }
74
OnProcessDiedContinuousTask(const AppExecFwk::ProcessData & processData)75 void AppStateObserver::OnProcessDiedContinuousTask(const AppExecFwk::ProcessData &processData)
76 {
77 if (!CheckParamValid()) {
78 return;
79 }
80 auto task = [this, processData]() {
81 this->bgContinuousTaskMgr_.lock()->OnProcessDied(processData.uid, processData.pid);
82 };
83 handler_.lock()->PostTask(task, TASK_ON_PROCESS_DIED);
84 }
85
OnProcessDiedEfficiencyRes(const AppExecFwk::ProcessData & processData)86 void AppStateObserver::OnProcessDiedEfficiencyRes(const AppExecFwk::ProcessData &processData)
87 {
88 auto bgEfficiencyResourcesMgr = bgEfficiencyResourcesMgr_.lock();
89 if (!bgEfficiencyResourcesMgr) {
90 BGTASK_LOGE("bgEfficiencyResourcesMgr is null");
91 return;
92 }
93 bgEfficiencyResourcesMgr->RemoveProcessRecord(processData.uid, processData.pid, processData.bundleName);
94 }
95
OnApplicationStateChanged(const AppExecFwk::AppStateData & appStateData)96 void AppStateObserver::OnApplicationStateChanged(const AppExecFwk::AppStateData &appStateData)
97 {
98 if (!ValidateAppStateData(appStateData)) {
99 BGTASK_LOGD("%{public}s : validate app state data failed!", __func__);
100 return;
101 }
102 auto uid = appStateData.uid;
103 auto bundleName = appStateData.bundleName;
104 auto state = appStateData.state;
105 if (state == static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_TERMINATED) || state ==
106 static_cast<int32_t>(AppExecFwk::ApplicationState::APP_STATE_END)) {
107 auto bgEfficiencyResourcesMgr = bgEfficiencyResourcesMgr_.lock();
108 if (!bgEfficiencyResourcesMgr) {
109 BGTASK_LOGE("bgEfficiencyResourcesMgr is null");
110 return;
111 }
112 bgEfficiencyResourcesMgr->RemoveAppRecord(uid, bundleName, false);
113 }
114 }
115
ValidateAppStateData(const AppExecFwk::AppStateData & appStateData)116 inline bool AppStateObserver::ValidateAppStateData(const AppExecFwk::AppStateData &appStateData)
117 {
118 return appStateData.uid > 0 && appStateData.bundleName.size() > 0;
119 }
120
SetEventHandler(const std::shared_ptr<AppExecFwk::EventHandler> & handler)121 void AppStateObserver::SetEventHandler(const std::shared_ptr<AppExecFwk::EventHandler> &handler)
122 {
123 handler_ = handler;
124 }
125
SetBgContinuousTaskMgr(const std::shared_ptr<BgContinuousTaskMgr> & bgContinuousTaskMgr)126 void AppStateObserver::SetBgContinuousTaskMgr(const std::shared_ptr<BgContinuousTaskMgr> &bgContinuousTaskMgr)
127 {
128 bgContinuousTaskMgr_ = bgContinuousTaskMgr;
129 }
130
SetBgEfficiencyResourcesMgr(const std::shared_ptr<BgEfficiencyResourcesMgr> & resourceMgr)131 void AppStateObserver::SetBgEfficiencyResourcesMgr(const std::shared_ptr<BgEfficiencyResourcesMgr> &resourceMgr)
132 {
133 bgEfficiencyResourcesMgr_ = resourceMgr;
134 }
135
Subscribe()136 bool AppStateObserver::Subscribe()
137 {
138 std::lock_guard<std::mutex> lock(mutex_);
139
140 if (!Connect()) {
141 return false;
142 }
143 appMgrProxy_->RegisterApplicationStateObserver(iface_cast<AppExecFwk::IApplicationStateObserver>(this));
144 return true;
145 }
146
Unsubscribe()147 bool AppStateObserver::Unsubscribe()
148 {
149 std::lock_guard<std::mutex> lock(mutex_);
150 if (!Connect()) {
151 return false;
152 }
153 appMgrProxy_->UnregisterApplicationStateObserver(iface_cast<AppExecFwk::IApplicationStateObserver>(this));
154 return true;
155 }
156
Connect()157 bool AppStateObserver::Connect()
158 {
159 if (appMgrProxy_ != nullptr) {
160 return true;
161 }
162
163 sptr<ISystemAbilityManager> systemAbilityManager =
164 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
165 if (systemAbilityManager == nullptr) {
166 BGTASK_LOGE("get SystemAbilityManager failed");
167 return false;
168 }
169
170 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(APP_MGR_SERVICE_ID);
171 if (remoteObject == nullptr) {
172 BGTASK_LOGE("get App Manager Service failed");
173 return false;
174 }
175
176 appMgrProxy_ = iface_cast<AppExecFwk::IAppMgr>(remoteObject);
177 if (!appMgrProxy_ || !appMgrProxy_->AsObject()) {
178 BGTASK_LOGE("get app mgr proxy failed!");
179 return false;
180 }
181 return true;
182 }
183 } // namespace BackgroundTaskMgr
184 } // namespace OHOS