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_mgr_proxy.h"
17
18 #include <message_parcel.h>
19 #include <string_ex.h>
20
21 #include "bgtaskmgr_log_wrapper.h"
22 #include "ibackground_task_mgr_ipc_interface_code.h"
23
24 using namespace std;
25
26 namespace OHOS {
27 namespace BackgroundTaskMgr {
BackgroundTaskMgrProxy(const sptr<IRemoteObject> & impl)28 BackgroundTaskMgrProxy::BackgroundTaskMgrProxy(const sptr<IRemoteObject>& impl)
29 :IRemoteProxy<IBackgroundTaskMgr>(impl) {}
~BackgroundTaskMgrProxy()30 BackgroundTaskMgrProxy::~BackgroundTaskMgrProxy() {}
31
RequestSuspendDelay(const std::u16string & reason,const sptr<IExpiredCallback> & callback,std::shared_ptr<DelaySuspendInfo> & delayInfo)32 ErrCode BackgroundTaskMgrProxy::RequestSuspendDelay(const std::u16string& reason,
33 const sptr<IExpiredCallback>& callback, std::shared_ptr<DelaySuspendInfo> &delayInfo)
34 {
35 if (callback == nullptr) {
36 BGTASK_LOGE("RequestSuspendDelay callback is null");
37 return ERR_CALLBACK_NULL_OR_TYPE_ERR;
38 }
39
40 MessageParcel data;
41 MessageParcel reply;
42 MessageOption option = {MessageOption::TF_SYNC};
43 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
44 BGTASK_LOGE("RequestSuspendDelay write descriptor failed");
45 return ERR_BGTASK_PARCELABLE_FAILED;
46 }
47 if (!data.WriteString16(reason)) {
48 BGTASK_LOGE("RequestSuspendDelay write reason failed");
49 return ERR_BGTASK_PARCELABLE_FAILED;
50 }
51 if (!data.WriteRemoteObject(callback->AsObject())) {
52 BGTASK_LOGE("RequestSuspendDelay write callback failed");
53 return ERR_BGTASK_PARCELABLE_FAILED;
54 }
55 ErrCode result = InnerTransact(static_cast<uint32_t>(
56 BackgroundTaskMgrStubInterfaceCode::REQUEST_SUSPEND_DELAY), option, data, reply);
57 if (result != ERR_OK) {
58 BGTASK_LOGE("RequestSuspendDelay transact ErrCode=%{public}d", result);
59 return ERR_BGTASK_TRANSACT_FAILED;
60 }
61 if (!reply.ReadInt32(result)) {
62 BGTASK_LOGE("RequestSuspendDelay fail: read result failed.");
63 return ERR_BGTASK_PARCELABLE_FAILED;
64 }
65 delayInfo = DelaySuspendInfo::Unmarshalling(reply);
66 if (delayInfo == nullptr) {
67 BGTASK_LOGE("RequestSuspendDelay read result failed");
68 return ERR_BGTASK_PARCELABLE_FAILED;
69 }
70 return result;
71 }
72
CancelSuspendDelay(int32_t requestId)73 ErrCode BackgroundTaskMgrProxy::CancelSuspendDelay(int32_t requestId)
74 {
75 MessageParcel data;
76 MessageParcel reply;
77 MessageOption option = {MessageOption::TF_SYNC};
78 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
79 BGTASK_LOGE("RequestSuspendDelay write descriptor failed");
80 return ERR_BGTASK_PARCELABLE_FAILED;
81 }
82 if (!data.WriteInt32(requestId)) {
83 BGTASK_LOGE("RequestSuspendDelay write requestId failed");
84 return ERR_BGTASK_PARCELABLE_FAILED;
85 }
86
87 ErrCode result = InnerTransact(static_cast<uint32_t>(
88 BackgroundTaskMgrStubInterfaceCode::CANCEL_SUSPEND_DELAY), option, data, reply);
89 if (result != ERR_OK) {
90 BGTASK_LOGE("RequestSuspendDelay fail: transact ErrCode=%{public}d", result);
91 return ERR_BGTASK_TRANSACT_FAILED;
92 }
93 if (!reply.ReadInt32(result)) {
94 BGTASK_LOGE("RequestSuspendDelay fail: read result failed.");
95 return ERR_BGTASK_PARCELABLE_FAILED;
96 }
97 return result;
98 }
99
GetRemainingDelayTime(int32_t requestId,int32_t & delayTime)100 ErrCode BackgroundTaskMgrProxy::GetRemainingDelayTime(int32_t requestId, int32_t &delayTime)
101 {
102 MessageParcel data;
103 MessageParcel reply;
104 MessageOption option = {MessageOption::TF_SYNC};
105 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
106 BGTASK_LOGE(" BackgroundTaskMgrProxy::%{public}s, write descriptor failed", __func__);
107 return ERR_BGTASK_PARCELABLE_FAILED;
108 }
109 if (!data.WriteInt32(requestId)) {
110 BGTASK_LOGE(" BackgroundTaskMgrProxy::%{public}s, write requestId failed", __func__);
111 return ERR_BGTASK_PARCELABLE_FAILED;
112 }
113
114 ErrCode result = InnerTransact(static_cast<uint32_t>(
115 BackgroundTaskMgrStubInterfaceCode::GET_REMAINING_DELAY_TIME), option, data, reply);
116 if (result != ERR_OK) {
117 BGTASK_LOGE("GetRemainingDelayTime fail: transact ErrCode=%{public}d", result);
118 return ERR_BGTASK_TRANSACT_FAILED;
119 }
120 if (!reply.ReadInt32(result)) {
121 BGTASK_LOGE("GetRemainingDelayTime fail: read result failed.");
122 return ERR_BGTASK_PARCELABLE_FAILED;
123 }
124 if (!reply.ReadInt32(delayTime)) {
125 BGTASK_LOGE("GetRemainingDelayTime fail: read result failed.");
126 return ERR_BGTASK_PARCELABLE_FAILED;
127 }
128 return result;
129 }
130
RequestBackgroundRunningForInner(const sptr<ContinuousTaskParamForInner> & taskParam)131 ErrCode BackgroundTaskMgrProxy::RequestBackgroundRunningForInner(const sptr<ContinuousTaskParamForInner> &taskParam)
132 {
133 if (taskParam == nullptr) {
134 return ERR_BGTASK_INVALID_PARAM;
135 }
136
137 MessageParcel dataInfo;
138 if (!dataInfo.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
139 return ERR_BGTASK_PARCELABLE_FAILED;
140 }
141
142 if (!dataInfo.WriteParcelable(taskParam)) {
143 return ERR_BGTASK_PARCELABLE_FAILED;
144 }
145
146 MessageParcel reply;
147 MessageOption option = {MessageOption::TF_SYNC};
148
149 ErrCode result = InnerTransact(static_cast<uint32_t>(
150 BackgroundTaskMgrStubInterfaceCode::REQUEST_BACKGROUND_RUNNING_FOR_INNER), option, dataInfo, reply);
151 if (result != ERR_OK) {
152 BGTASK_LOGE("RequestBackgroundRunningForInner fail: transact ErrCode=%{public}d", result);
153 return ERR_BGTASK_TRANSACT_FAILED;
154 }
155 if (!reply.ReadInt32(result)) {
156 BGTASK_LOGE("RequestBackgroundRunningForInner fail: read result failed.");
157 return ERR_BGTASK_PARCELABLE_FAILED;
158 }
159 return result;
160 }
161
StartBackgroundRunning(const sptr<ContinuousTaskParam> & taskParam)162 ErrCode BackgroundTaskMgrProxy::StartBackgroundRunning(const sptr<ContinuousTaskParam> &taskParam)
163 {
164 if (taskParam == nullptr) {
165 return ERR_BGTASK_INVALID_PARAM;
166 }
167
168 MessageParcel data;
169 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
170 return ERR_BGTASK_PARCELABLE_FAILED;
171 }
172
173 if (!data.WriteParcelable(taskParam)) {
174 return ERR_BGTASK_PARCELABLE_FAILED;
175 }
176
177 MessageParcel reply;
178 MessageOption option = {MessageOption::TF_SYNC};
179
180 ErrCode result = InnerTransact(static_cast<uint32_t>(
181 BackgroundTaskMgrStubInterfaceCode::START_BACKGROUND_RUNNING), option, data, reply);
182 if (result != ERR_OK) {
183 BGTASK_LOGE("StartBackgroundRunning fail: transact ErrCode=%{public}d", result);
184 return ERR_BGTASK_TRANSACT_FAILED;
185 }
186 if (!reply.ReadInt32(result)) {
187 BGTASK_LOGE("StartBackgroundRunning fail: read result failed.");
188 return ERR_BGTASK_PARCELABLE_FAILED;
189 }
190 int32_t notificationId = -1;
191 int32_t continuousTaskId = -1;
192 if (!reply.ReadInt32(notificationId)) {
193 BGTASK_LOGE("StartBackgroundRunning fail: read notificationId failed.");
194 return ERR_BGTASK_PARCELABLE_FAILED;
195 }
196 if (!reply.ReadInt32(continuousTaskId)) {
197 BGTASK_LOGE("StartBackgroundRunning fail: read continuousTaskId failed.");
198 return ERR_BGTASK_PARCELABLE_FAILED;
199 }
200 BGTASK_LOGI("BackgroundTaskMgrProxy read notificationId %{public}d, continuousTaskId %{public}d",
201 notificationId, continuousTaskId);
202 taskParam->notificationId_ = notificationId;
203 taskParam->continuousTaskId_ = continuousTaskId;
204 return result;
205 }
206
UpdateBackgroundRunning(const sptr<ContinuousTaskParam> & taskParam)207 ErrCode BackgroundTaskMgrProxy::UpdateBackgroundRunning(const sptr<ContinuousTaskParam> &taskParam)
208 {
209 if (taskParam == nullptr) {
210 return ERR_BGTASK_INVALID_PARAM;
211 }
212
213 MessageParcel data;
214 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
215 return ERR_BGTASK_PARCELABLE_FAILED;
216 }
217
218 if (!data.WriteParcelable(taskParam)) {
219 return ERR_BGTASK_PARCELABLE_FAILED;
220 }
221
222 MessageParcel reply;
223 MessageOption option = {MessageOption::TF_SYNC};
224
225 ErrCode result = InnerTransact(static_cast<uint32_t>(
226 BackgroundTaskMgrStubInterfaceCode::UPDATE_BACKGROUND_RUNNING), option, data, reply);
227 if (result != ERR_OK) {
228 BGTASK_LOGE("UpdateBackgroundRunning fail: transact ErrCode=%{public}d", result);
229 return ERR_BGTASK_TRANSACT_FAILED;
230 }
231 if (!reply.ReadInt32(result)) {
232 BGTASK_LOGE("UpdateBackgroundRunning fail: read result failed.");
233 return ERR_BGTASK_PARCELABLE_FAILED;
234 }
235 int32_t notificationId = -1;
236 if (!reply.ReadInt32(notificationId)) {
237 BGTASK_LOGE("UpdateBackgroundRunning fail: read notificationId failed.");
238 return ERR_BGTASK_PARCELABLE_FAILED;
239 }
240 int32_t continuousTaskId = -1;
241 if (!reply.ReadInt32(continuousTaskId)) {
242 BGTASK_LOGE("UpdateBackgroundRunning fail: read continuousTaskId failed.");
243 return ERR_BGTASK_PARCELABLE_FAILED;
244 }
245 BGTASK_LOGI("read notificationId %{public}d, continuousTaskId: %{public}d", notificationId, continuousTaskId);
246 taskParam->notificationId_ = notificationId;
247 taskParam->continuousTaskId_ = continuousTaskId;
248 return result;
249 }
250
StopBackgroundRunning(const std::string & abilityName,const sptr<IRemoteObject> & abilityToken,int32_t abilityId)251 ErrCode BackgroundTaskMgrProxy::StopBackgroundRunning(const std::string &abilityName,
252 const sptr<IRemoteObject> &abilityToken, int32_t abilityId)
253 {
254 MessageParcel data;
255 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
256 return ERR_BGTASK_PARCELABLE_FAILED;
257 }
258
259 std::u16string u16AbilityName = Str8ToStr16(abilityName);
260 if (!data.WriteString16(u16AbilityName)) {
261 BGTASK_LOGE("StopBackgroundRunning parcel ability Name failed");
262 return ERR_BGTASK_PARCELABLE_FAILED;
263 }
264
265 if (!data.WriteRemoteObject(abilityToken)) {
266 BGTASK_LOGE("StopBackgroundRunning parcel ability token failed");
267 return ERR_BGTASK_PARCELABLE_FAILED;
268 }
269
270 if (!data.WriteInt32(abilityId)) {
271 BGTASK_LOGE("StopBackgroundRunning parcel abilityId failed");
272 return ERR_BGTASK_PARCELABLE_FAILED;
273 }
274
275 MessageParcel reply;
276 MessageOption option = {MessageOption::TF_SYNC};
277
278 ErrCode result = InnerTransact(static_cast<uint32_t>(
279 BackgroundTaskMgrStubInterfaceCode::STOP_BACKGROUND_RUNNING), option, data, reply);
280 if (result != ERR_OK) {
281 BGTASK_LOGE("StopBackgroundRunning transact ErrCode=%{public}d", result);
282 return ERR_BGTASK_TRANSACT_FAILED;
283 }
284 if (!reply.ReadInt32(result)) {
285 BGTASK_LOGE("StopBackgroundRunning read result failed.");
286 return ERR_BGTASK_PARCELABLE_FAILED;
287 }
288 return result;
289 }
290
SubscribeBackgroundTask(const sptr<IBackgroundTaskSubscriber> & subscriber)291 ErrCode BackgroundTaskMgrProxy::SubscribeBackgroundTask(const sptr<IBackgroundTaskSubscriber>& subscriber)
292 {
293 if (subscriber == nullptr) {
294 BGTASK_LOGE("SubscribeBackgroundTask subscriber is null");
295 return ERR_BGTASK_PARCELABLE_FAILED;
296 }
297
298 MessageParcel data;
299 MessageParcel reply;
300 MessageOption option = {MessageOption::TF_SYNC};
301 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
302 BGTASK_LOGE("SubscribeBackgroundTask write descriptor failed");
303 return ERR_BGTASK_PARCELABLE_FAILED;
304 }
305 if (!data.WriteRemoteObject(subscriber->AsObject())) {
306 BGTASK_LOGE("SubscribeBackgroundTask write subscriber failed");
307 return ERR_BGTASK_PARCELABLE_FAILED;
308 }
309
310 ErrCode result = InnerTransact(static_cast<uint32_t>(
311 BackgroundTaskMgrStubInterfaceCode::SUBSCRIBE_BACKGROUND_TASK), option, data, reply);
312 if (result != ERR_OK) {
313 BGTASK_LOGE("SubscribeBackgroundTask fail: transact ErrCode=%{public}d", result);
314 return ERR_BGTASK_TRANSACT_FAILED;
315 }
316 if (!reply.ReadInt32(result)) {
317 BGTASK_LOGE("SubscribeBackgroundTask fail: read result failed.");
318 return ERR_BGTASK_PARCELABLE_FAILED;
319 }
320 return result;
321 }
322
UnsubscribeBackgroundTask(const sptr<IBackgroundTaskSubscriber> & subscriber)323 ErrCode BackgroundTaskMgrProxy::UnsubscribeBackgroundTask(const sptr<IBackgroundTaskSubscriber>& subscriber)
324 {
325 if (subscriber == nullptr) {
326 BGTASK_LOGE("UnsubscribeBackgroundTask subscriber is null");
327 return ERR_BGTASK_PARCELABLE_FAILED;
328 }
329
330 MessageParcel data;
331 MessageParcel reply;
332 MessageOption option = {MessageOption::TF_SYNC};
333 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
334 BGTASK_LOGE("UnsubscribeBackgroundTask write descriptor failed");
335 return ERR_BGTASK_PARCELABLE_FAILED;
336 }
337 if (!data.WriteRemoteObject(subscriber->AsObject())) {
338 BGTASK_LOGE("UnsubscribeBackgroundTask write subscriber failed");
339 return ERR_BGTASK_PARCELABLE_FAILED;
340 }
341
342 ErrCode result = InnerTransact(static_cast<uint32_t>(
343 BackgroundTaskMgrStubInterfaceCode::UNSUBSCRIBE_BACKGROUND_TASK), option, data, reply);
344 if (result != ERR_OK) {
345 BGTASK_LOGE("UnsubscribeBackgroundTask fail: transact ErrCode=%{public}d", result);
346 return ERR_BGTASK_TRANSACT_FAILED;
347 }
348 if (!reply.ReadInt32(result)) {
349 BGTASK_LOGE("UnsubscribeBackgroundTask fail: read result failed.");
350 return ERR_BGTASK_PARCELABLE_FAILED;
351 }
352 return result;
353 }
354
GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> & list)355 ErrCode BackgroundTaskMgrProxy::GetTransientTaskApps(std::vector<std::shared_ptr<TransientTaskAppInfo>> &list)
356 {
357 MessageParcel data;
358 MessageParcel reply;
359 MessageOption option = {MessageOption::TF_SYNC};
360 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
361 BGTASK_LOGE("GetTransientTaskApps write descriptor failed");
362 return ERR_BGTASK_PARCELABLE_FAILED;
363 }
364
365 ErrCode result = InnerTransact(static_cast<uint32_t>(
366 BackgroundTaskMgrStubInterfaceCode::GET_TRANSIENT_TASK_APPS), option, data, reply);
367 if (result != ERR_OK) {
368 BGTASK_LOGE("GetTransientTaskApps fail: transact ErrCode=%{public}d", result);
369 return ERR_BGTASK_TRANSACT_FAILED;
370 }
371 if (!reply.ReadInt32(result)) {
372 BGTASK_LOGE("GetTransientTaskApps fail: read result failed.");
373 return ERR_BGTASK_PARCELABLE_FAILED;
374 }
375
376 int32_t infoSize = reply.ReadInt32();
377 for (int32_t i = 0; i < infoSize; i++) {
378 auto info = TransientTaskAppInfo::Unmarshalling(reply);
379 if (!info) {
380 BGTASK_LOGE("GetTransientTaskApps Read Parcelable infos failed.");
381 return ERR_BGTASK_PARCELABLE_FAILED;
382 }
383 list.emplace_back(info);
384 }
385
386 return result;
387 }
388
PauseTransientTaskTimeForInner(int32_t uid)389 ErrCode BackgroundTaskMgrProxy::PauseTransientTaskTimeForInner(int32_t uid)
390 {
391 MessageParcel data;
392 MessageParcel reply;
393 MessageOption option = {MessageOption::TF_SYNC};
394 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
395 BGTASK_LOGE("PauseTransientTaskTimeForInner write descriptor failed");
396 return ERR_BGTASK_PARCELABLE_FAILED;
397 }
398 if (!data.WriteInt32(uid)) {
399 BGTASK_LOGE("PauseTransientTaskTimeForInner parcel uid failed");
400 return ERR_BGTASK_PARCELABLE_FAILED;
401 }
402 ErrCode result = InnerTransact(static_cast<uint32_t>(
403 BackgroundTaskMgrStubInterfaceCode::PAUSE_TRANSIENT_TASK_TIME_FOR_INNER), option, data, reply);
404 if (result != ERR_OK) {
405 BGTASK_LOGE("PauseTransientTaskTimeForInner fail: transact ErrCode=%{public}d", result);
406 return ERR_BGTASK_TRANSACT_FAILED;
407 }
408 if (!reply.ReadInt32(result)) {
409 BGTASK_LOGE("PauseTransientTaskTimeForInner fail: read result failed.");
410 return ERR_BGTASK_PARCELABLE_FAILED;
411 }
412 return result;
413 }
414
StartTransientTaskTimeForInner(int32_t uid)415 ErrCode BackgroundTaskMgrProxy::StartTransientTaskTimeForInner(int32_t uid)
416 {
417 MessageParcel data;
418 MessageParcel reply;
419 MessageOption option = {MessageOption::TF_SYNC};
420 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
421 BGTASK_LOGE("StartTransientTaskTimeForInner write descriptor failed");
422 return ERR_BGTASK_PARCELABLE_FAILED;
423 }
424 if (!data.WriteInt32(uid)) {
425 BGTASK_LOGE("StartTransientTaskTimeForInner parcel uid failed");
426 return ERR_BGTASK_PARCELABLE_FAILED;
427 }
428 ErrCode result = InnerTransact(static_cast<uint32_t>(
429 BackgroundTaskMgrStubInterfaceCode::START_TRANSIENT_TASK_TIME_FOR_INNER), option, data, reply);
430 if (result != ERR_OK) {
431 BGTASK_LOGE("StartTransientTaskTimeForInner fail: transact ErrCode=%{public}d", result);
432 return ERR_BGTASK_TRANSACT_FAILED;
433 }
434 if (!reply.ReadInt32(result)) {
435 BGTASK_LOGE("StartTransientTaskTimeForInner fail: read result failed.");
436 return ERR_BGTASK_PARCELABLE_FAILED;
437 }
438 return result;
439 }
440
GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> & list)441 ErrCode BackgroundTaskMgrProxy::GetContinuousTaskApps(std::vector<std::shared_ptr<ContinuousTaskCallbackInfo>> &list)
442 {
443 MessageParcel data;
444 MessageParcel reply;
445 MessageOption option = {MessageOption::TF_SYNC};
446 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
447 BGTASK_LOGE("GetContinuousTaskApps write descriptor failed");
448 return ERR_BGTASK_PARCELABLE_FAILED;
449 }
450
451 ErrCode result = InnerTransact(static_cast<uint32_t>(
452 BackgroundTaskMgrStubInterfaceCode::GET_CONTINUOUS_TASK_APPS), option, data, reply);
453 if (result != ERR_OK) {
454 BGTASK_LOGE("GetContinuousTaskApps fail: transact ErrCode=%{public}d", result);
455 return ERR_BGTASK_TRANSACT_FAILED;
456 }
457 if (!reply.ReadInt32(result)) {
458 BGTASK_LOGE("GetContinuousTaskApps fail: read result failed.");
459 return ERR_BGTASK_PARCELABLE_FAILED;
460 }
461
462 if (result != ERR_OK) {
463 BGTASK_LOGE("GetContinuousTaskApps failed.");
464 return result;
465 }
466
467 int32_t infoSize = reply.ReadInt32();
468 for (int32_t i = 0; i < infoSize; i++) {
469 auto info = ContinuousTaskCallbackInfo::Unmarshalling(reply);
470 if (!info) {
471 BGTASK_LOGE("GetContinuousTaskApps Read Parcelable infos failed.");
472 return ERR_BGTASK_PARCELABLE_FAILED;
473 }
474 list.emplace_back(info);
475 }
476
477 return result;
478 }
479
StopContinuousTask(int32_t uid,int32_t pid,uint32_t taskType,const std::string & key)480 ErrCode BackgroundTaskMgrProxy::StopContinuousTask(int32_t uid, int32_t pid, uint32_t taskType, const std::string &key)
481 {
482 MessageParcel data;
483 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
484 return ERR_BGTASK_PARCELABLE_FAILED;
485 }
486
487 if (!data.WriteInt32(uid)) {
488 BGTASK_LOGE("StopContinuousTask parcel uid failed");
489 return ERR_BGTASK_PARCELABLE_FAILED;
490 }
491
492 if (!data.WriteInt32(pid)) {
493 BGTASK_LOGE("StopContinuousTask parcel pid failed");
494 return ERR_BGTASK_PARCELABLE_FAILED;
495 }
496
497 if (!data.WriteUint32(taskType)) {
498 BGTASK_LOGE("StopContinuousTask parcel taskType failed");
499 return ERR_BGTASK_PARCELABLE_FAILED;
500 }
501
502 if (!data.WriteString(key)) {
503 BGTASK_LOGE("StopContinuousTask parcel key failed");
504 return ERR_BGTASK_PARCELABLE_FAILED;
505 }
506
507 MessageParcel reply;
508 MessageOption option = {MessageOption::TF_SYNC};
509
510 ErrCode result = InnerTransact(static_cast<uint32_t>(
511 BackgroundTaskMgrStubInterfaceCode::STOP_CONTINUOUS_TASK), option, data, reply);
512 if (result != ERR_OK) {
513 BGTASK_LOGE("StopContinuousTask transact ErrCode=%{public}d", result);
514 return ERR_BGTASK_TRANSACT_FAILED;
515 }
516 if (!reply.ReadInt32(result)) {
517 BGTASK_LOGE("StopContinuousTask read result failed.");
518 return ERR_BGTASK_PARCELABLE_FAILED;
519 }
520 return result;
521 }
522
InnerTransact(uint32_t code,MessageOption & flags,MessageParcel & data,MessageParcel & reply)523 ErrCode BackgroundTaskMgrProxy::InnerTransact(uint32_t code, MessageOption &flags,
524 MessageParcel &data, MessageParcel &reply)
525 {
526 auto remote = Remote();
527 if (remote == nullptr) {
528 BGTASK_LOGE("InnerTransact get Remote fail code %{public}d", code);
529 return ERR_DEAD_OBJECT;
530 }
531 int32_t err = remote->SendRequest(code, data, reply, flags);
532 switch (err) {
533 case NO_ERROR: {
534 return ERR_OK;
535 }
536 case DEAD_OBJECT: {
537 BGTASK_LOGE("[InnerTransact] fail: ipcErr=%{public}d code %{public}u", err, code);
538 return ERR_DEAD_OBJECT;
539 }
540 default: {
541 BGTASK_LOGE("[InnerTransact] fail: ipcErr=%{public}d code %{public}u", err, code);
542 return ERR_BGTASK_TRANSACT_FAILED;
543 }
544 }
545 }
546
ApplyEfficiencyResources(const sptr<EfficiencyResourceInfo> & resourceInfo)547 ErrCode BackgroundTaskMgrProxy::ApplyEfficiencyResources(const sptr<EfficiencyResourceInfo> &resourceInfo)
548 {
549 if (resourceInfo == nullptr) {
550 return ERR_BGTASK_INVALID_PARAM;
551 }
552
553 MessageParcel data;
554 MessageParcel reply;
555 MessageOption option = {MessageOption::TF_SYNC};
556 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
557 BGTASK_LOGE("ApplyEfficiencyResources write descriptor failed");
558 return ERR_BGTASK_PARCELABLE_FAILED;
559 }
560
561 if (!data.WriteParcelable(resourceInfo)) {
562 return ERR_BGTASK_PARCELABLE_FAILED;
563 }
564 BGTASK_LOGD("start send data in apply res function from bgtask proxy");
565 ErrCode result = InnerTransact(static_cast<uint32_t>(
566 BackgroundTaskMgrStubInterfaceCode::APPLY_EFFICIENCY_RESOURCES), option, data, reply);
567 if (result != ERR_OK) {
568 BGTASK_LOGE("ApplyEfficiencyResources fail: transact ErrCode=%{public}d", result);
569 return ERR_BGTASK_TRANSACT_FAILED;
570 }
571 if (!reply.ReadInt32(result)) {
572 BGTASK_LOGE("ApplyEfficiencyResources fail: read result failed.");
573 return ERR_BGTASK_PARCELABLE_FAILED;
574 }
575 return result;
576 }
577
ResetAllEfficiencyResources()578 ErrCode BackgroundTaskMgrProxy::ResetAllEfficiencyResources()
579 {
580 MessageParcel data;
581 MessageParcel reply;
582 MessageOption option = {MessageOption::TF_SYNC};
583 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
584 BGTASK_LOGE("ResetAllEfficiencyResources write descriptor failed");
585 return ERR_BGTASK_PARCELABLE_FAILED;
586 }
587 BGTASK_LOGD("start send data in reset all res function from bgtask proxy");
588 ErrCode result = InnerTransact(static_cast<uint32_t>(
589 BackgroundTaskMgrStubInterfaceCode::RESET_ALL_EFFICIENCY_RESOURCES), option, data, reply);
590 if (result != ERR_OK) {
591 BGTASK_LOGE("ResetAllEfficiencyResources fail: transact ErrCode=%{public}d", result);
592 return ERR_BGTASK_TRANSACT_FAILED;
593 }
594 if (!reply.ReadInt32(result)) {
595 BGTASK_LOGE("ResetAllEfficiencyResources fail: read result failed.");
596 return ERR_BGTASK_PARCELABLE_FAILED;
597 }
598 return result;
599 }
600
GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<ResourceCallbackInfo>> & appList,std::vector<std::shared_ptr<ResourceCallbackInfo>> & procList)601 ErrCode BackgroundTaskMgrProxy::GetEfficiencyResourcesInfos(std::vector<std::shared_ptr<
602 ResourceCallbackInfo>> &appList, std::vector<std::shared_ptr<ResourceCallbackInfo>> &procList)
603 {
604 MessageParcel data;
605 MessageParcel reply;
606 MessageOption option = {MessageOption::TF_SYNC};
607 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
608 BGTASK_LOGE("GetEfficiencyResourcesInfos write descriptor failed");
609 return ERR_BGTASK_PARCELABLE_FAILED;
610 }
611
612 ErrCode result = InnerTransact(static_cast<uint32_t>(
613 BackgroundTaskMgrStubInterfaceCode::GET_EFFICIENCY_RESOURCES_INFOS), option, data, reply);
614 if (result != ERR_OK) {
615 BGTASK_LOGE("GetEfficiencyResourcesInfos fail: transact ErrCode=%{public}d", result);
616 return ERR_BGTASK_TRANSACT_FAILED;
617 }
618 if (!reply.ReadInt32(result)) {
619 BGTASK_LOGE("GetEfficiencyResourcesInfos fail: read result failed.");
620 return ERR_BGTASK_PARCELABLE_FAILED;
621 }
622
623 if (result != ERR_OK) {
624 return result;
625 }
626
627 int32_t infoSize = reply.ReadInt32();
628 for (int32_t i = 0; i < infoSize; i++) {
629 auto info = ResourceCallbackInfo::Unmarshalling(reply);
630 if (!info) {
631 BGTASK_LOGE("GetContinuousTaskApps Read Parcelable infos failed.");
632 return ERR_BGTASK_PARCELABLE_FAILED;
633 }
634 appList.emplace_back(info);
635 }
636
637 infoSize = reply.ReadInt32();
638 for (int32_t i = 0; i < infoSize; i++) {
639 auto info = ResourceCallbackInfo::Unmarshalling(reply);
640 if (!info) {
641 BGTASK_LOGE("GetContinuousTaskApps Read Parcelable infos failed.");
642 return ERR_BGTASK_PARCELABLE_FAILED;
643 }
644 procList.emplace_back(info);
645 }
646
647 return result;
648 }
649
SetBgTaskConfig(const std::string & configData,int32_t sourceType)650 ErrCode BackgroundTaskMgrProxy::SetBgTaskConfig(const std::string &configData, int32_t sourceType)
651 {
652 MessageParcel data;
653 MessageParcel reply;
654 MessageOption option = {MessageOption::TF_SYNC};
655 if (!data.WriteInterfaceToken(BackgroundTaskMgrProxy::GetDescriptor())) {
656 BGTASK_LOGE("SetBgTaskConfig write descriptor failed");
657 return ERR_BGTASK_PARCELABLE_FAILED;
658 }
659 if (!data.WriteString(configData)) {
660 BGTASK_LOGE("SetBgTaskConfig write configData failed");
661 return ERR_BGTASK_PARCELABLE_FAILED;
662 }
663 if (!data.WriteInt32(sourceType)) {
664 BGTASK_LOGE("SetBgTaskConfig write sourceType failed");
665 return ERR_BGTASK_PARCELABLE_FAILED;
666 }
667 ErrCode result = InnerTransact(static_cast<uint32_t>(
668 BackgroundTaskMgrStubInterfaceCode::SET_BGTASK_CONFIG), option, data, reply);
669 if (result != ERR_OK) {
670 BGTASK_LOGE("SetBgTaskConfig fail: transact ErrCode=%{public}d", result);
671 return ERR_BGTASK_TRANSACT_FAILED;
672 }
673 if (!reply.ReadInt32(result)) {
674 BGTASK_LOGE("SetBgTaskConfig fail: read result failed.");
675 return ERR_BGTASK_PARCELABLE_FAILED;
676 }
677 return result;
678 }
679 } // namespace BackgroundTaskMgr
680 } // namespace OHOS