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