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 "background_task_manager.h"
17
18 #include "hitrace_meter.h"
19 #include "iservice_registry.h"
20 #include "system_ability_definition.h"
21
22 #include "bgtaskmgr_inner_errors.h"
23 #include "bgtaskmgr_log_wrapper.h"
24 #include "delay_suspend_info.h"
25
26 namespace OHOS {
27 namespace BackgroundTaskMgr {
BackgroundTaskManager()28 BackgroundTaskManager::BackgroundTaskManager() {}
29
~BackgroundTaskManager()30 BackgroundTaskManager::~BackgroundTaskManager() {}
31
32 #define GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN \
33 if (!GetBackgroundTaskManagerProxy()) { \
34 BGTASK_LOGE("GetBackgroundTaskManager Proxy failed."); \
35 return ERR_BGTASK_SERVICE_NOT_CONNECTED; \
36 }
37
CancelSuspendDelay(int32_t requestId)38 ErrCode BackgroundTaskManager::CancelSuspendDelay(int32_t requestId)
39 {
40 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
41 "BackgroundTaskManager::TransientTask::Mgr::CancelSuspendDelay");
42
43 std::lock_guard<std::mutex> lock(mutex_);
44 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
45
46 return proxy_->CancelSuspendDelay(requestId);
47 }
48
RequestSuspendDelay(const std::u16string & reason,const ExpiredCallback & callback,std::shared_ptr<DelaySuspendInfo> & delayInfo)49 ErrCode BackgroundTaskManager::RequestSuspendDelay(const std::u16string &reason,
50 const ExpiredCallback &callback, std::shared_ptr<DelaySuspendInfo> &delayInfo)
51 {
52 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
53 "BackgroundTaskManager::TransientTask::Mgr::RequestSuspendDelay");
54
55 std::lock_guard<std::mutex> lock(mutex_);
56 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
57
58 sptr<ExpiredCallback::ExpiredCallbackImpl> callbackSptr = callback.GetImpl();
59 if (callbackSptr == nullptr) {
60 BGTASK_LOGE("callbackSptr is nullptr");
61 return ERR_CALLBACK_NULL_OR_TYPE_ERR;
62 }
63 return proxy_->RequestSuspendDelay(reason, callbackSptr, delayInfo);
64 }
65
GetRemainingDelayTime(int32_t requestId,int32_t & delayTime)66 ErrCode BackgroundTaskManager::GetRemainingDelayTime(int32_t requestId, int32_t &delayTime)
67 {
68 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
69 "BackgroundTaskManager::TransientTask::Mgr::GetRemainingDelayTime");
70
71 std::lock_guard<std::mutex> lock(mutex_);
72 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
73
74 return proxy_->GetRemainingDelayTime(requestId, delayTime);
75 }
76
RequestStartBackgroundRunning(ContinuousTaskParam & taskParam)77 ErrCode BackgroundTaskManager::RequestStartBackgroundRunning(ContinuousTaskParam &taskParam)
78 {
79 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
80 "BackgroundTaskManager::ContinuousTask::Mgr::RequestStartBackgroundRunning");
81
82 std::lock_guard<std::mutex> lock(mutex_);
83 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
84
85 sptr<ContinuousTaskParam> taskParamPtr = new (std::nothrow) ContinuousTaskParam(taskParam);
86 if (taskParamPtr == nullptr) {
87 BGTASK_LOGE("Failed to create continuous task param");
88 return ERR_BGTASK_NO_MEMORY;
89 }
90 BGTASK_LOGD("%{public}u = %{public}u, %{public}d = %{public}d, abilityId = %{public}d",
91 static_cast<uint32_t>(taskParamPtr->bgModeIds_.size()),
92 static_cast<uint32_t>(taskParam.bgModeIds_.size()),
93 taskParamPtr->isBatchApi_, taskParam.isBatchApi_,
94 taskParamPtr->abilityId_);
95 ErrCode res = proxy_->StartBackgroundRunning(taskParamPtr);
96 taskParam.notificationId_ = taskParamPtr->notificationId_;
97 taskParam.continuousTaskId_ = taskParamPtr->continuousTaskId_;
98 return res;
99 }
100
RequestUpdateBackgroundRunning(ContinuousTaskParam & taskParam)101 ErrCode BackgroundTaskManager::RequestUpdateBackgroundRunning(ContinuousTaskParam &taskParam)
102 {
103 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
104 "BackgroundTaskManager::ContinuousTask::Mgr::RequestUpdateBackgroundRunning");
105
106 std::lock_guard<std::mutex> lock(mutex_);
107 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
108
109 sptr<ContinuousTaskParam> taskParamPtr = new (std::nothrow) ContinuousTaskParam(taskParam);
110 if (taskParamPtr == nullptr) {
111 BGTASK_LOGE("Failed to create continuous task param");
112 return ERR_BGTASK_NO_MEMORY;
113 }
114
115 BGTASK_LOGD(" %{public}u = %{public}u, %{public}d = %{public}d, abilityId = %{public}d",
116 static_cast<uint32_t>(taskParamPtr->bgModeIds_.size()),
117 static_cast<uint32_t>(taskParam.bgModeIds_.size()), taskParamPtr->isBatchApi_, taskParam.isBatchApi_,
118 taskParamPtr->abilityId_);
119 ErrCode ret = proxy_->UpdateBackgroundRunning(taskParamPtr);
120 taskParam.notificationId_ = taskParamPtr->notificationId_;
121 taskParam.continuousTaskId_ = taskParamPtr->continuousTaskId_;
122 return ret;
123 }
124
RequestBackgroundRunningForInner(const ContinuousTaskParamForInner & taskParam)125 ErrCode BackgroundTaskManager::RequestBackgroundRunningForInner(const ContinuousTaskParamForInner &taskParam)
126 {
127 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
128 "BackgroundTaskManager::ContinuousTask::Mgr::RequestBackgroundRunningForInner");
129
130 std::lock_guard<std::mutex> lock(mutex_);
131 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
132
133 sptr<ContinuousTaskParamForInner> taskParamPtr = new (std::nothrow) ContinuousTaskParamForInner(taskParam);
134 if (taskParamPtr == nullptr) {
135 BGTASK_LOGE("Failed to create continuous task param");
136 return ERR_BGTASK_NO_MEMORY;
137 }
138
139 return proxy_->RequestBackgroundRunningForInner(taskParamPtr);
140 }
141
RequestStopBackgroundRunning(const std::string & abilityName,const sptr<IRemoteObject> & abilityToken,int32_t abilityId)142 ErrCode BackgroundTaskManager::RequestStopBackgroundRunning(const std::string &abilityName,
143 const sptr<IRemoteObject> &abilityToken, int32_t abilityId)
144 {
145 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
146 "BackgroundTaskManager::ContinuousTask::Mgr::RequestStopBackgroundRunning");
147
148 std::lock_guard<std::mutex> lock(mutex_);
149 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
150
151 return proxy_->StopBackgroundRunning(abilityName, abilityToken, abilityId);
152 }
153
SubscribeBackgroundTask(const BackgroundTaskSubscriber & subscriber)154 __attribute__((no_sanitize("cfi"))) ErrCode BackgroundTaskManager::SubscribeBackgroundTask(
155 const BackgroundTaskSubscriber &subscriber)
156 {
157 std::lock_guard<std::mutex> lock(mutex_);
158 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
159
160 sptr<BackgroundTaskSubscriber::BackgroundTaskSubscriberImpl> subscriberSptr = subscriber.GetImpl();
161 if (subscriberSptr == nullptr) {
162 BGTASK_LOGE("subscriberSptr is nullptr");
163 return ERR_BGTASK_INVALID_PARAM;
164 }
165 return proxy_->SubscribeBackgroundTask(subscriberSptr);
166 }
167
UnsubscribeBackgroundTask(const BackgroundTaskSubscriber & subscriber)168 ErrCode BackgroundTaskManager::UnsubscribeBackgroundTask(const BackgroundTaskSubscriber &subscriber)
169 {
170 std::lock_guard<std::mutex> lock(mutex_);
171 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
172
173 sptr<BackgroundTaskSubscriber::BackgroundTaskSubscriberImpl> subscriberSptr = subscriber.GetImpl();
174 if (subscriberSptr == nullptr) {
175 BGTASK_LOGE("subscriberSptr is nullptr");
176 return ERR_BGTASK_INVALID_PARAM;
177 }
178 return proxy_->UnsubscribeBackgroundTask(subscriberSptr);
179 }
180
GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> & list)181 ErrCode BackgroundTaskManager::GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> &list)
182 {
183 std::lock_guard<std::mutex> lock(mutex_);
184 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
185
186 return proxy_->GetTransientTaskApps(list);
187 }
188
PauseTransientTaskTimeForInner(int32_t uid)189 ErrCode BackgroundTaskManager::PauseTransientTaskTimeForInner(int32_t uid)
190 {
191 std::lock_guard<std::mutex> lock(mutex_);
192 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
193
194 return proxy_->PauseTransientTaskTimeForInner(uid);
195 }
196
StartTransientTaskTimeForInner(int32_t uid)197 ErrCode BackgroundTaskManager::StartTransientTaskTimeForInner(int32_t uid)
198 {
199 std::lock_guard<std::mutex> lock(mutex_);
200 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
201
202 return proxy_->StartTransientTaskTimeForInner(uid);
203 }
204
ApplyEfficiencyResources(const EfficiencyResourceInfo & resourceInfo)205 ErrCode BackgroundTaskManager::ApplyEfficiencyResources(const EfficiencyResourceInfo &resourceInfo)
206 {
207 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
208 "BackgroundTaskManager::EfficiencyResource::Mgr::ApplyEfficiencyResources");
209
210 std::lock_guard<std::mutex> lock(mutex_);
211 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
212
213 sptr<EfficiencyResourceInfo> resourceInfoPtr = new (std::nothrow) EfficiencyResourceInfo(resourceInfo);
214 if (resourceInfoPtr == nullptr) {
215 BGTASK_LOGE("Failed to create efficiency resource info");
216 return ERR_BGTASK_NO_MEMORY;
217 }
218 return proxy_->ApplyEfficiencyResources(resourceInfoPtr);
219 }
220
ResetAllEfficiencyResources()221 ErrCode BackgroundTaskManager::ResetAllEfficiencyResources()
222 {
223 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
224 "BackgroundTaskManager::EfficiencyResource::Mgr::ResetAllEfficiencyResources");
225
226 std::lock_guard<std::mutex> lock(mutex_);
227 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
228
229 return proxy_->ResetAllEfficiencyResources();
230 }
231
GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<ResourceCallbackInfo>> & appList,std::vector<std::shared_ptr<ResourceCallbackInfo>> & procList)232 ErrCode BackgroundTaskManager::GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<ResourceCallbackInfo>> &appList,
233 std::vector<std::shared_ptr<ResourceCallbackInfo>> &procList)
234 {
235 std::lock_guard<std::mutex> lock(mutex_);
236 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
237
238 return proxy_->GetEfficiencyResourcesInfos(appList, procList);
239 }
240
GetBackgroundTaskManagerProxy()241 bool BackgroundTaskManager::GetBackgroundTaskManagerProxy()
242 {
243 if (proxy_ != nullptr) {
244 return true;
245 }
246 sptr<ISystemAbilityManager> systemAbilityManager =
247 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
248 if (systemAbilityManager == nullptr) {
249 BGTASK_LOGE("GetBackgroundTaskManagerProxy GetSystemAbilityManager failed.");
250 return false;
251 }
252
253 sptr<IRemoteObject> remoteObject =
254 systemAbilityManager->GetSystemAbility(BACKGROUND_TASK_MANAGER_SERVICE_ID);
255 if (remoteObject == nullptr) {
256 BGTASK_LOGE("GetBackgroundTaskManagerProxy GetSystemAbility failed.");
257 return false;
258 }
259
260 proxy_ = iface_cast<BackgroundTaskMgr::IBackgroundTaskMgr>(remoteObject);
261 if ((proxy_ == nullptr) || (proxy_->AsObject() == nullptr)) {
262 BGTASK_LOGE("GetBackgroundTaskManagerProxy iface_cast remoteObject failed.");
263 return false;
264 }
265
266 recipient_ = new (std::nothrow) BgTaskMgrDeathRecipient(*this);
267 if (recipient_ == nullptr) {
268 return false;
269 }
270 proxy_->AsObject()->AddDeathRecipient(recipient_);
271 return true;
272 }
273
GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> & list)274 ErrCode BackgroundTaskManager::GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> &list)
275 {
276 std::lock_guard<std::mutex> lock(mutex_);
277 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
278
279 return proxy_->GetContinuousTaskApps(list);
280 }
281
StopContinuousTask(int32_t uid,int32_t pid,uint32_t taskType,const std::string & key)282 ErrCode BackgroundTaskManager::StopContinuousTask(int32_t uid, int32_t pid, uint32_t taskType, const std::string &key)
283 {
284 std::lock_guard<std::mutex> lock(mutex_);
285 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
286
287 return proxy_->StopContinuousTask(uid, pid, taskType, key);
288 }
289
ResetBackgroundTaskManagerProxy()290 void BackgroundTaskManager::ResetBackgroundTaskManagerProxy()
291 {
292 std::lock_guard<std::mutex> lock(mutex_);
293 if ((proxy_ != nullptr) && (proxy_->AsObject() != nullptr)) {
294 proxy_->AsObject()->RemoveDeathRecipient(recipient_);
295 }
296 proxy_ = nullptr;
297 }
298
SetBgTaskConfig(const std::string & configData,int32_t sourceType)299 ErrCode BackgroundTaskManager::SetBgTaskConfig(const std::string &configData, int32_t sourceType)
300 {
301 std::lock_guard<std::mutex> lock(mutex_);
302 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
303
304 return proxy_->SetBgTaskConfig(configData, sourceType);
305 }
306
BgTaskMgrDeathRecipient(BackgroundTaskManager & backgroundTaskManager)307 BackgroundTaskManager::BgTaskMgrDeathRecipient::BgTaskMgrDeathRecipient(BackgroundTaskManager &backgroundTaskManager)
308 : backgroundTaskManager_(backgroundTaskManager) {}
309
~BgTaskMgrDeathRecipient()310 BackgroundTaskManager::BgTaskMgrDeathRecipient::~BgTaskMgrDeathRecipient() {}
311
OnRemoteDied(const wptr<IRemoteObject> & remote)312 void BackgroundTaskManager::BgTaskMgrDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
313 {
314 backgroundTaskManager_.ResetBackgroundTaskManagerProxy();
315 }
316 } // namespace BackgroundTaskMgr
317 } // namespace OHOS