1 /*
2 * Copyright (c) 2022-2023 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 "background_task_observer.h"
17
18 #ifdef CONFIG_BGTASK_MGR
19 #include "cgroup_sched_log.h"
20 #include "sched_controller.h"
21 #include "cgroup_event_handler.h"
22 #include "ressched_utils.h"
23 #include "res_type.h"
24
25 #undef LOG_TAG
26 #define LOG_TAG "BackgroundTaskObserver"
27
28 namespace OHOS {
29 namespace ResourceSchedule {
MarshallingTransientTaskAppInfo(const std::shared_ptr<TransientTaskAppInfo> & info,nlohmann::json & payload)30 void BackgroundTaskObserver::MarshallingTransientTaskAppInfo(
31 const std::shared_ptr<TransientTaskAppInfo>& info, nlohmann::json& payload)
32 {
33 payload["pid"] = std::to_string(info->GetPid());
34 payload["uid"] = std::to_string(info->GetUid());
35 payload["bundleName"] = info->GetPackageName();
36 }
37
OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)38 void BackgroundTaskObserver::OnTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info)
39 {
40 if (!ValidateTaskInfo(info)) {
41 return;
42 }
43 /* class TransientTaskAppInfo {std::string& GetPackageName(); int32_t GetUid(); int32_t GetPid();} */
44 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
45 if (cgHandler) {
46 auto uid = info->GetUid();
47 auto pid = info->GetPid();
48 auto pkgName = info->GetPackageName();
49
50 cgHandler->PostTask([cgHandler, uid, pid, pkgName] {
51 cgHandler->HandleTransientTaskStart(uid, pid, pkgName);
52 });
53 }
54
55 nlohmann::json payload;
56 MarshallingTransientTaskAppInfo(info, payload);
57 ResSchedUtils::GetInstance().ReportDataInProcess(
58 ResType::RES_TYPE_TRANSIENT_TASK, ResType::TransientTaskStatus::TRANSIENT_TASK_START, payload);
59 }
60
OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)61 void BackgroundTaskObserver::OnTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info)
62 {
63 if (!ValidateTaskInfo(info)) {
64 CGS_LOGE("%{public}s failed, invalid app info!", __func__);
65 return;
66 }
67 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
68 if (cgHandler) {
69 auto uid = info->GetUid();
70 auto pid = info->GetPid();
71 auto pkgName = info->GetPackageName();
72
73 cgHandler->PostTask([cgHandler, uid, pid, pkgName] {
74 cgHandler->HandleTransientTaskEnd(uid, pid, pkgName);
75 });
76 }
77
78 nlohmann::json payload;
79 MarshallingTransientTaskAppInfo(info, payload);
80 ResSchedUtils::GetInstance().ReportDataInProcess(
81 ResType::RES_TYPE_TRANSIENT_TASK, ResType::TransientTaskStatus::TRANSIENT_TASK_END, payload);
82 }
83
OnTransientTaskErr(const std::shared_ptr<TransientTaskAppInfo> & info)84 void BackgroundTaskObserver::OnTransientTaskErr(const std::shared_ptr<TransientTaskAppInfo>& info)
85 {
86 if (!ValidateTaskInfo(info)) {
87 CGS_LOGE("%{public}s failed, invalid app info!", __func__);
88 return;
89 }
90
91 nlohmann::json payload;
92 MarshallingTransientTaskAppInfo(info, payload);
93 ResSchedUtils::GetInstance().ReportDataInProcess(
94 ResType::RES_TYPE_TRANSIENT_TASK, ResType::TransientTaskStatus::TRANSIENT_TASK_ERR, payload);
95 }
96
OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo> & info)97 void BackgroundTaskObserver::OnAppTransientTaskStart(const std::shared_ptr<TransientTaskAppInfo>& info)
98 {
99 nlohmann::json payload;
100 MarshallingTransientTaskAppInfo(info, payload);
101 ResSchedUtils::GetInstance().ReportDataInProcess(
102 ResType::RES_TYPE_TRANSIENT_TASK, ResType::TransientTaskStatus::APP_TRANSIENT_TASK_START, payload);
103 }
104
OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo> & info)105 void BackgroundTaskObserver::OnAppTransientTaskEnd(const std::shared_ptr<TransientTaskAppInfo>& info)
106 {
107 nlohmann::json payload;
108 MarshallingTransientTaskAppInfo(info, payload);
109 ResSchedUtils::GetInstance().ReportDataInProcess(
110 ResType::RES_TYPE_TRANSIENT_TASK, ResType::TransientTaskStatus::APP_TRANSIENT_TASK_END, payload);
111 }
112
MarshallingContinuousTaskCallbackInfo(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo,nlohmann::json & payload)113 void BackgroundTaskObserver::MarshallingContinuousTaskCallbackInfo(
114 const std::shared_ptr<ContinuousTaskCallbackInfo>& continuousTaskCallbackInfo, nlohmann::json& payload)
115 {
116 payload["pid"] = std::to_string(continuousTaskCallbackInfo->GetCreatorPid());
117 payload["uid"] = std::to_string(continuousTaskCallbackInfo->GetCreatorUid());
118 payload["abilityName"] = continuousTaskCallbackInfo->GetAbilityName();
119 payload["isBatchApi"] = std::to_string(continuousTaskCallbackInfo->IsBatchApi());
120 payload["typeId"] = std::to_string(continuousTaskCallbackInfo->GetTypeId());
121 payload["abilityId"] = std::to_string(continuousTaskCallbackInfo->GetAbilityId());
122 payload["isFromWebview"] = continuousTaskCallbackInfo->IsFromWebview();
123 payload["typeIds"] = continuousTaskCallbackInfo->GetTypeIds();
124 payload["tokenId"] = continuousTaskCallbackInfo->GetTokenId();
125 }
126
OnContinuousTaskStart(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)127 void BackgroundTaskObserver::OnContinuousTaskStart(
128 const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo)
129 {
130 if (!ValidateTaskInfo(continuousTaskCallbackInfo)) {
131 CGS_LOGE("%{public}s failed, invalid event data!", __func__);
132 return;
133 }
134 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
135 if (cgHandler) {
136 auto uid = continuousTaskCallbackInfo->GetCreatorUid();
137 auto pid = continuousTaskCallbackInfo->GetCreatorPid();
138 auto abilityId = continuousTaskCallbackInfo->GetAbilityId();
139 auto typeIds = continuousTaskCallbackInfo->GetTypeIds();
140 cgHandler->PostTask([cgHandler, uid, pid, typeIds, abilityId] {
141 cgHandler->HandleContinuousTaskUpdate(uid, pid, typeIds, abilityId);
142 });
143 }
144
145 nlohmann::json payload;
146 MarshallingContinuousTaskCallbackInfo(continuousTaskCallbackInfo, payload);
147 ResSchedUtils::GetInstance().ReportDataInProcess(
148 ResType::RES_TYPE_CONTINUOUS_TASK, ResType::ContinuousTaskStatus::CONTINUOUS_TASK_START, payload);
149 }
150
OnContinuousTaskStop(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)151 void BackgroundTaskObserver::OnContinuousTaskStop(
152 const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo)
153 {
154 if (!ValidateTaskInfo(continuousTaskCallbackInfo)) {
155 CGS_LOGE("%{public}s failed, invalid event data!", __func__);
156 return;
157 }
158 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
159 if (cgHandler) {
160 auto uid = continuousTaskCallbackInfo->GetCreatorUid();
161 auto pid = continuousTaskCallbackInfo->GetCreatorPid();
162 auto typeId = continuousTaskCallbackInfo->GetTypeId();
163 auto abilityId = continuousTaskCallbackInfo->GetAbilityId();
164
165 cgHandler->PostTask([cgHandler, uid, pid, typeId, abilityId] {
166 cgHandler->HandleContinuousTaskCancel(uid, pid, typeId, abilityId);
167 });
168 }
169
170 nlohmann::json payload;
171 MarshallingContinuousTaskCallbackInfo(continuousTaskCallbackInfo, payload);
172 ResSchedUtils::GetInstance().ReportDataInProcess(
173 ResType::RES_TYPE_CONTINUOUS_TASK, ResType::ContinuousTaskStatus::CONTINUOUS_TASK_END, payload);
174 }
175
OnContinuousTaskUpdate(const std::shared_ptr<ContinuousTaskCallbackInfo> & continuousTaskCallbackInfo)176 void BackgroundTaskObserver::OnContinuousTaskUpdate(
177 const std::shared_ptr<ContinuousTaskCallbackInfo> &continuousTaskCallbackInfo)
178 {
179 if (!ValidateTaskInfo(continuousTaskCallbackInfo)) {
180 CGS_LOGE("%{public}s failed, invalid event data!", __func__);
181 return;
182 }
183 auto cgHandler = SchedController::GetInstance().GetCgroupEventHandler();
184 if (cgHandler) {
185 auto uid = continuousTaskCallbackInfo->GetCreatorUid();
186 auto pid = continuousTaskCallbackInfo->GetCreatorPid();
187 auto typeIds = continuousTaskCallbackInfo->GetTypeIds();
188 auto abilityId = continuousTaskCallbackInfo->GetAbilityId();
189
190 cgHandler->PostTask([cgHandler, uid, pid, typeIds, abilityId] {
191 cgHandler->HandleContinuousTaskUpdate(uid, pid, typeIds, abilityId);
192 });
193 }
194
195 nlohmann::json payload;
196 MarshallingContinuousTaskCallbackInfo(continuousTaskCallbackInfo, payload);
197 ResSchedUtils::GetInstance().ReportDataInProcess(
198 ResType::RES_TYPE_CONTINUOUS_TASK, ResType::ContinuousTaskStatus::CONTINUOUS_TASK_UPDATE, payload);
199 }
200
OnRemoteDied(const wptr<IRemoteObject> & object)201 void BackgroundTaskObserver::OnRemoteDied(const wptr<IRemoteObject> &object)
202 {
203 CGS_LOGI("%{public}s.", __func__);
204 }
205
MarshallingResourceInfo(const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> & resourceInfo,nlohmann::json & payload)206 void BackgroundTaskObserver::MarshallingResourceInfo(
207 const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> &resourceInfo, nlohmann::json &payload)
208 {
209 if (!resourceInfo) {
210 CGS_LOGE("%{public}s : resourceInfo nullptr!", __func__);
211 return;
212 }
213 payload["pid"] = resourceInfo->GetPid();
214 payload["uid"] = resourceInfo->GetUid();
215 payload["resourceNumber"] = resourceInfo->GetResourceNumber();
216 payload["bundleName"] = resourceInfo->GetBundleName();
217 }
218
OnAppEfficiencyResourcesApply(const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> & resourceInfo)219 void BackgroundTaskObserver::OnAppEfficiencyResourcesApply(
220 const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> &resourceInfo)
221 {
222 nlohmann::json payload;
223 MarshallingResourceInfo(resourceInfo, payload);
224 ResSchedUtils::GetInstance().ReportDataInProcess(
225 ResType::RES_TYPE_EFFICIENCY_RESOURCES_STATE_CHANGED,
226 ResType::EfficiencyResourcesStatus::APP_EFFICIENCY_RESOURCES_APPLY,
227 payload);
228 }
229
OnAppEfficiencyResourcesReset(const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> & resourceInfo)230 void BackgroundTaskObserver::OnAppEfficiencyResourcesReset(
231 const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> &resourceInfo)
232 {
233 nlohmann::json payload;
234 MarshallingResourceInfo(resourceInfo, payload);
235 ResSchedUtils::GetInstance().ReportDataInProcess(
236 ResType::RES_TYPE_EFFICIENCY_RESOURCES_STATE_CHANGED,
237 ResType::EfficiencyResourcesStatus::APP_EFFICIENCY_RESOURCES_RESET,
238 payload);
239 }
240
OnProcEfficiencyResourcesApply(const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> & resourceInfo)241 void BackgroundTaskObserver::OnProcEfficiencyResourcesApply(
242 const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> &resourceInfo)
243 {
244 nlohmann::json payload;
245 MarshallingResourceInfo(resourceInfo, payload);
246 ResSchedUtils::GetInstance().ReportDataInProcess(
247 ResType::RES_TYPE_EFFICIENCY_RESOURCES_STATE_CHANGED,
248 ResType::EfficiencyResourcesStatus::PROC_EFFICIENCY_RESOURCES_APPLY,
249 payload);
250 }
251
OnProcEfficiencyResourcesReset(const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> & resourceInfo)252 void BackgroundTaskObserver::OnProcEfficiencyResourcesReset(
253 const std::shared_ptr<BackgroundTaskMgr::ResourceCallbackInfo> &resourceInfo)
254 {
255 nlohmann::json payload;
256 MarshallingResourceInfo(resourceInfo, payload);
257 ResSchedUtils::GetInstance().ReportDataInProcess(
258 ResType::RES_TYPE_EFFICIENCY_RESOURCES_STATE_CHANGED,
259 ResType::EfficiencyResourcesStatus::PROC_EFFICIENCY_RESOURCES_RESET,
260 payload);
261 }
262 } // namespace ResourceSchedule
263 } // namespace OHOS
264 #endif
265