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 "sched_controller.h"
19 #include "cgroup_event_handler.h"
20 #include "cgroup_sched_log.h"
21 #include "ressched_utils.h"
22 #include "res_type.h"
23 #include "supervisor.h"
24
25 namespace OHOS {
26 namespace ResourceSchedule {
27 namespace {
28 constexpr HiviewDFX::HiLogLabel LOG_LABEL = {LOG_CORE, LOG_TAG_DOMAIN_ID_RMS, "RmsAppStateObserver"};
29 }
30
OnForegroundApplicationChanged(const AppStateData & appStateData)31 void RmsApplicationStateObserver::OnForegroundApplicationChanged(const AppStateData &appStateData)
32 {
33 if (!ValidateAppStateData(appStateData)) {
34 CGS_LOGE("%{public}s : validate app state data failed!", __func__);
35 return;
36 }
37 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
38 if (cgHandler) {
39 auto uid = appStateData.uid;
40 auto bundleName = appStateData.bundleName;
41 auto state = appStateData.state;
42
43 cgHandler->PostTask([cgHandler, uid, bundleName, state] {
44 cgHandler->HandleForegroundApplicationChanged(uid, bundleName, state);
45 });
46 }
47
48 nlohmann::json payload;
49 payload["pid"] = std::to_string(appStateData.pid);
50 payload["uid"] = std::to_string(appStateData.uid);
51 payload["bundleName"] = appStateData.bundleName;
52 ResSchedUtils::GetInstance().ReportDataInProcess(ResType::RES_TYPE_APP_STATE_CHANGE, appStateData.state, payload);
53 }
54
OnAbilityStateChanged(const AbilityStateData & abilityStateData)55 void RmsApplicationStateObserver::OnAbilityStateChanged(const AbilityStateData &abilityStateData)
56 {
57 if (!ValidateAbilityStateData(abilityStateData)) {
58 CGS_LOGE("%{public}s : validate ability state data failed!", __func__);
59 return;
60 }
61 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
62 if (cgHandler) {
63 auto uid = abilityStateData.uid;
64 auto pid = abilityStateData.pid;
65 auto bundleName = abilityStateData.bundleName;
66 auto abilityName = abilityStateData.abilityName;
67 auto token = reinterpret_cast<uintptr_t>(abilityStateData.token.GetRefPtr());
68 auto abilityState = abilityStateData.abilityState;
69 auto abilityType = abilityStateData.abilityType;
70
71 cgHandler->PostTask([cgHandler, uid, pid, bundleName, abilityName, token, abilityState, abilityType] {
72 cgHandler->HandleAbilityStateChanged(uid, pid, bundleName, abilityName,
73 token, abilityState, abilityType);
74 });
75 }
76
77 nlohmann::json payload;
78 payload["pid"] = std::to_string(abilityStateData.pid);
79 payload["uid"] = std::to_string(abilityStateData.uid);
80 payload["bundleName"] = abilityStateData.bundleName;
81 ResSchedUtils::GetInstance().ReportDataInProcess(ResType::RES_TYPE_ABILITY_STATE_CHANGE,
82 abilityStateData.abilityState, payload);
83 }
84
OnExtensionStateChanged(const AbilityStateData & abilityStateData)85 void RmsApplicationStateObserver::OnExtensionStateChanged(const AbilityStateData &abilityStateData)
86 {
87 if (!ValidateAbilityStateData(abilityStateData)) {
88 CGS_LOGE("%{public}s : validate extension state data failed!", __func__);
89 return;
90 }
91 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
92 if (cgHandler) {
93 auto uid = abilityStateData.uid;
94 auto pid = abilityStateData.pid;
95 auto bundleName = abilityStateData.bundleName;
96 auto abilityName = abilityStateData.abilityName;
97 auto token = reinterpret_cast<uintptr_t>(abilityStateData.token.GetRefPtr());
98 auto abilityState = abilityStateData.abilityState;
99 auto abilityType = abilityStateData.abilityType;
100
101 cgHandler->PostTask([cgHandler, uid, pid, bundleName, abilityName, token, abilityState, abilityType] {
102 cgHandler->HandleExtensionStateChanged(uid, pid, bundleName, abilityName,
103 token, abilityState, abilityType);
104 });
105 }
106
107 nlohmann::json payload;
108 payload["pid"] = std::to_string(abilityStateData.pid);
109 payload["uid"] = std::to_string(abilityStateData.uid);
110 payload["bundleName"] = abilityStateData.bundleName;
111 ResSchedUtils::GetInstance().ReportDataInProcess(ResType::RES_TYPE_EXTENSION_STATE_CHANGE,
112 abilityStateData.abilityState, payload);
113 }
114
OnProcessCreated(const ProcessData & processData)115 void RmsApplicationStateObserver::OnProcessCreated(const ProcessData &processData)
116 {
117 if (!ValidateProcessData(processData)) {
118 CGS_LOGE("%{public}s : validate process data failed!", __func__);
119 return;
120 }
121 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
122 if (cgHandler) {
123 auto uid = processData.uid;
124 auto pid = processData.pid;
125 auto bundleName = processData.bundleName;
126
127 cgHandler->PostTask([cgHandler, uid, pid, bundleName] {
128 cgHandler->HandleProcessCreated(uid, pid, bundleName);
129 });
130 }
131
132 nlohmann::json payload;
133 payload["pid"] = std::to_string(processData.pid);
134 payload["uid"] = std::to_string(processData.uid);
135 payload["bundleName"] = processData.bundleName;
136 ResSchedUtils::GetInstance().ReportDataInProcess(
137 ResType::RES_TYPE_PROCESS_STATE_CHANGE, ResType::ProcessStatus::PROCESS_CREATED, payload);
138 }
139
OnProcessDied(const ProcessData & processData)140 void RmsApplicationStateObserver::OnProcessDied(const ProcessData &processData)
141 {
142 if (!ValidateProcessData(processData)) {
143 CGS_LOGE("%{public}s : validate process data failed!", __func__);
144 return;
145 }
146 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
147 if (cgHandler) {
148 auto uid = processData.uid;
149 auto pid = processData.pid;
150 auto bundleName = processData.bundleName;
151
152 cgHandler->PostTask([cgHandler, uid, pid, bundleName] {
153 cgHandler->HandleProcessDied(uid, pid, bundleName);
154 });
155 }
156
157 nlohmann::json payload;
158 payload["pid"] = std::to_string(processData.pid);
159 payload["uid"] = std::to_string(processData.uid);
160 payload["bundleName"] = processData.bundleName;
161 ResSchedUtils::GetInstance().ReportDataInProcess(
162 ResType::RES_TYPE_PROCESS_STATE_CHANGE, ResType::ProcessStatus::PROCESS_DIED, payload);
163 }
164
OnApplicationStateChanged(const AppStateData & appStateData)165 void RmsApplicationStateObserver::OnApplicationStateChanged(const AppStateData &appStateData)
166 {
167 if (!ValidateAppStateData(appStateData)) {
168 CGS_LOGE("%{public}s : validate app state data failed!", __func__);
169 return;
170 }
171
172 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
173 if (cgHandler) {
174 auto uid = appStateData.uid;
175 auto bundleName = appStateData.bundleName;
176 auto state = appStateData.state;
177
178 cgHandler->PostTask([cgHandler, uid, bundleName, state] {
179 cgHandler->HandleApplicationStateChanged(uid, bundleName, state);
180 });
181 }
182
183 nlohmann::json payload;
184 payload["pid"] = std::to_string(appStateData.pid);
185 payload["uid"] = std::to_string(appStateData.uid);
186 payload["bundleName"] = appStateData.bundleName;
187 ResSchedUtils::GetInstance().ReportDataInProcess(ResType::RES_TYPE_APP_STATE_CHANGE, appStateData.state, payload);
188 }
189 } // namespace ResourceSchedule
190 } // namespace OHOS
191