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 return res;
98 }
99
RequestUpdateBackgroundRunning(ContinuousTaskParam & taskParam)100 ErrCode BackgroundTaskManager::RequestUpdateBackgroundRunning(ContinuousTaskParam &taskParam)
101 {
102 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
103 "BackgroundTaskManager::ContinuousTask::Mgr::RequestUpdateBackgroundRunning");
104
105 std::lock_guard<std::mutex> lock(mutex_);
106 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
107
108 sptr<ContinuousTaskParam> taskParamPtr = new (std::nothrow) ContinuousTaskParam(taskParam);
109 if (taskParamPtr == nullptr) {
110 BGTASK_LOGE("Failed to create continuous task param");
111 return ERR_BGTASK_NO_MEMORY;
112 }
113
114 BGTASK_LOGD(" %{public}u = %{public}u, %{public}d = %{public}d, abilityId = %{public}d",
115 static_cast<uint32_t>(taskParamPtr->bgModeIds_.size()),
116 static_cast<uint32_t>(taskParam.bgModeIds_.size()), taskParamPtr->isBatchApi_, taskParam.isBatchApi_,
117 taskParamPtr->abilityId_);
118 ErrCode ret = proxy_->UpdateBackgroundRunning(taskParamPtr);
119 taskParam.notificationId_ = taskParamPtr->notificationId_;
120 return ret;
121 }
122
RequestBackgroundRunningForInner(const ContinuousTaskParamForInner & taskParam)123 ErrCode BackgroundTaskManager::RequestBackgroundRunningForInner(const ContinuousTaskParamForInner &taskParam)
124 {
125 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
126 "BackgroundTaskManager::ContinuousTask::Mgr::RequestBackgroundRunningForInner");
127
128 std::lock_guard<std::mutex> lock(mutex_);
129 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
130
131 sptr<ContinuousTaskParamForInner> taskParamPtr = new (std::nothrow) ContinuousTaskParamForInner(taskParam);
132 if (taskParamPtr == nullptr) {
133 BGTASK_LOGE("Failed to create continuous task param");
134 return ERR_BGTASK_NO_MEMORY;
135 }
136
137 return proxy_->RequestBackgroundRunningForInner(taskParamPtr);
138 }
139
RequestStopBackgroundRunning(const std::string & abilityName,const sptr<IRemoteObject> & abilityToken,int32_t abilityId)140 ErrCode BackgroundTaskManager::RequestStopBackgroundRunning(const std::string &abilityName,
141 const sptr<IRemoteObject> &abilityToken, int32_t abilityId)
142 {
143 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
144 "BackgroundTaskManager::ContinuousTask::Mgr::RequestStopBackgroundRunning");
145
146 std::lock_guard<std::mutex> lock(mutex_);
147 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
148
149 return proxy_->StopBackgroundRunning(abilityName, abilityToken, abilityId);
150 }
151
SubscribeBackgroundTask(const BackgroundTaskSubscriber & subscriber)152 __attribute__((no_sanitize("cfi"))) ErrCode BackgroundTaskManager::SubscribeBackgroundTask(
153 const BackgroundTaskSubscriber &subscriber)
154 {
155 std::lock_guard<std::mutex> lock(mutex_);
156 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
157
158 sptr<BackgroundTaskSubscriber::BackgroundTaskSubscriberImpl> subscriberSptr = subscriber.GetImpl();
159 if (subscriberSptr == nullptr) {
160 BGTASK_LOGE("subscriberSptr is nullptr");
161 return ERR_BGTASK_INVALID_PARAM;
162 }
163 return proxy_->SubscribeBackgroundTask(subscriberSptr);
164 }
165
UnsubscribeBackgroundTask(const BackgroundTaskSubscriber & subscriber)166 ErrCode BackgroundTaskManager::UnsubscribeBackgroundTask(const BackgroundTaskSubscriber &subscriber)
167 {
168 std::lock_guard<std::mutex> lock(mutex_);
169 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
170
171 sptr<BackgroundTaskSubscriber::BackgroundTaskSubscriberImpl> subscriberSptr = subscriber.GetImpl();
172 if (subscriberSptr == nullptr) {
173 BGTASK_LOGE("subscriberSptr is nullptr");
174 return ERR_BGTASK_INVALID_PARAM;
175 }
176 return proxy_->UnsubscribeBackgroundTask(subscriberSptr);
177 }
178
GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> & list)179 ErrCode BackgroundTaskManager::GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> &list)
180 {
181 std::lock_guard<std::mutex> lock(mutex_);
182 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
183
184 return proxy_->GetTransientTaskApps(list);
185 }
186
PauseTransientTaskTimeForInner(int32_t uid)187 ErrCode BackgroundTaskManager::PauseTransientTaskTimeForInner(int32_t uid)
188 {
189 std::lock_guard<std::mutex> lock(mutex_);
190 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
191
192 return proxy_->PauseTransientTaskTimeForInner(uid);
193 }
194
StartTransientTaskTimeForInner(int32_t uid)195 ErrCode BackgroundTaskManager::StartTransientTaskTimeForInner(int32_t uid)
196 {
197 std::lock_guard<std::mutex> lock(mutex_);
198 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
199
200 return proxy_->StartTransientTaskTimeForInner(uid);
201 }
202
ApplyEfficiencyResources(const EfficiencyResourceInfo & resourceInfo)203 ErrCode BackgroundTaskManager::ApplyEfficiencyResources(const EfficiencyResourceInfo &resourceInfo)
204 {
205 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
206 "BackgroundTaskManager::EfficiencyResource::Mgr::ApplyEfficiencyResources");
207
208 std::lock_guard<std::mutex> lock(mutex_);
209 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
210
211 sptr<EfficiencyResourceInfo> resourceInfoPtr = new (std::nothrow) EfficiencyResourceInfo(resourceInfo);
212 if (resourceInfoPtr == nullptr) {
213 BGTASK_LOGE("Failed to create efficiency resource info");
214 return ERR_BGTASK_NO_MEMORY;
215 }
216 return proxy_->ApplyEfficiencyResources(resourceInfoPtr);
217 }
218
ResetAllEfficiencyResources()219 ErrCode BackgroundTaskManager::ResetAllEfficiencyResources()
220 {
221 HitraceScoped traceScoped(HITRACE_TAG_OHOS,
222 "BackgroundTaskManager::EfficiencyResource::Mgr::ResetAllEfficiencyResources");
223
224 std::lock_guard<std::mutex> lock(mutex_);
225 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
226
227 return proxy_->ResetAllEfficiencyResources();
228 }
229
GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<ResourceCallbackInfo>> & appList,std::vector<std::shared_ptr<ResourceCallbackInfo>> & procList)230 ErrCode BackgroundTaskManager::GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<ResourceCallbackInfo>> &appList,
231 std::vector<std::shared_ptr<ResourceCallbackInfo>> &procList)
232 {
233 std::lock_guard<std::mutex> lock(mutex_);
234 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
235
236 return proxy_->GetEfficiencyResourcesInfos(appList, procList);
237 }
238
GetBackgroundTaskManagerProxy()239 bool BackgroundTaskManager::GetBackgroundTaskManagerProxy()
240 {
241 if (proxy_ != nullptr) {
242 return true;
243 }
244 sptr<ISystemAbilityManager> systemAbilityManager =
245 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
246 if (systemAbilityManager == nullptr) {
247 BGTASK_LOGE("GetBackgroundTaskManagerProxy GetSystemAbilityManager failed.");
248 return false;
249 }
250
251 sptr<IRemoteObject> remoteObject =
252 systemAbilityManager->GetSystemAbility(BACKGROUND_TASK_MANAGER_SERVICE_ID);
253 if (remoteObject == nullptr) {
254 BGTASK_LOGE("GetBackgroundTaskManagerProxy GetSystemAbility failed.");
255 return false;
256 }
257
258 proxy_ = iface_cast<BackgroundTaskMgr::IBackgroundTaskMgr>(remoteObject);
259 if ((proxy_ == nullptr) || (proxy_->AsObject() == nullptr)) {
260 BGTASK_LOGE("GetBackgroundTaskManagerProxy iface_cast remoteObject failed.");
261 return false;
262 }
263
264 recipient_ = new (std::nothrow) BgTaskMgrDeathRecipient(*this);
265 if (recipient_ == nullptr) {
266 return false;
267 }
268 proxy_->AsObject()->AddDeathRecipient(recipient_);
269 return true;
270 }
271
GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> & list)272 ErrCode BackgroundTaskManager::GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> &list)
273 {
274 std::lock_guard<std::mutex> lock(mutex_);
275 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
276
277 return proxy_->GetContinuousTaskApps(list);
278 }
279
StopContinuousTask(int32_t uid,int32_t pid,uint32_t taskType,const std::string & key)280 ErrCode BackgroundTaskManager::StopContinuousTask(int32_t uid, int32_t pid, uint32_t taskType, const std::string &key)
281 {
282 std::lock_guard<std::mutex> lock(mutex_);
283 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
284
285 return proxy_->StopContinuousTask(uid, pid, taskType, key);
286 }
287
ResetBackgroundTaskManagerProxy()288 void BackgroundTaskManager::ResetBackgroundTaskManagerProxy()
289 {
290 std::lock_guard<std::mutex> lock(mutex_);
291 if ((proxy_ != nullptr) && (proxy_->AsObject() != nullptr)) {
292 proxy_->AsObject()->RemoveDeathRecipient(recipient_);
293 }
294 proxy_ = nullptr;
295 }
296
SetBgTaskConfig(const std::string & configData,int32_t sourceType)297 ErrCode BackgroundTaskManager::SetBgTaskConfig(const std::string &configData, int32_t sourceType)
298 {
299 std::lock_guard<std::mutex> lock(mutex_);
300 GET_BACK_GROUND_TASK_MANAGER_PROXY_RETURN
301
302 return proxy_->SetBgTaskConfig(configData, sourceType);
303 }
304
BgTaskMgrDeathRecipient(BackgroundTaskManager & backgroundTaskManager)305 BackgroundTaskManager::BgTaskMgrDeathRecipient::BgTaskMgrDeathRecipient(BackgroundTaskManager &backgroundTaskManager)
306 : backgroundTaskManager_(backgroundTaskManager) {}
307
~BgTaskMgrDeathRecipient()308 BackgroundTaskManager::BgTaskMgrDeathRecipient::~BgTaskMgrDeathRecipient() {}
309
OnRemoteDied(const wptr<IRemoteObject> & remote)310 void BackgroundTaskManager::BgTaskMgrDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
311 {
312 backgroundTaskManager_.ResetBackgroundTaskManagerProxy();
313 }
314 } // namespace BackgroundTaskMgr
315 } // namespace OHOS