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_subscriber_stub.h"
17  
18  #include <errors.h>
19  #include <ipc_skeleton.h>
20  
21  #include "transient_task_log.h"
22  #include "background_task_subscriber_proxy.h"
23  #include "ibackground_task_subscriber_ipc_interface_code.h"
24  
25  namespace OHOS {
26  namespace BackgroundTaskMgr {
27  namespace {
28  constexpr int32_t APP_FIRST_UID = 10000;
29  }
30  
BackgroundTaskSubscriberStub()31  BackgroundTaskSubscriberStub::BackgroundTaskSubscriberStub() {}
~BackgroundTaskSubscriberStub()32  BackgroundTaskSubscriberStub::~BackgroundTaskSubscriberStub() {}
33  
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)34  ErrCode BackgroundTaskSubscriberStub::OnRemoteRequest(uint32_t code,
35      MessageParcel& data, MessageParcel& reply, MessageOption& option)
36  {
37      std::u16string descriptor = BackgroundTaskSubscriberStub::GetDescriptor();
38      std::u16string remoteDescriptor = data.ReadInterfaceToken();
39      if (descriptor != remoteDescriptor) {
40          BGTASK_LOGE("BackgroundTaskSubscriberStub Local descriptor not match remote.");
41          return ERR_TRANSACTION_FAILED;
42      }
43  
44      auto uid = IPCSkeleton::GetCallingUid();
45      if (uid >= APP_FIRST_UID) {
46          BGTASK_LOGE("BackgroundTaskSubscriberStub OnRemoteRequest failed, illegal calling uid %d.", uid);
47          return ERR_INVALID_DATA;
48      }
49  
50      return OnRemoteRequestInner(code, data, reply, option);
51  }
52  
OnRemoteRequestInner(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)53  ErrCode BackgroundTaskSubscriberStub::OnRemoteRequestInner(uint32_t code,
54      MessageParcel& data, MessageParcel& reply, MessageOption& option)
55  {
56      switch (code) {
57          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_CONNECTED): {
58              return HandleOnConnected();
59          }
60          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_DISCONNECTED): {
61              return HandleOnDisconnected();
62          }
63          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_START):
64          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_END):
65          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_ERR):
66          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_TRANSIENT_TASK_START):
67              [[fallthrough]];
68          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_TRANSIENT_TASK_END): {
69              return HandleTransientTask(code, data);
70          }
71          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_CONTINUOUS_TASK_START): {
72              return HandleOnContinuousTaskStart(data);
73          }
74          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_CONTINUOUS_TASK_UPDATE): {
75              return HandleOnContinuousTaskUpdate(data);
76          }
77          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_CONTINUOUS_TASK_STOP): {
78              return HandleOnContinuousTaskCancel(data);
79          }
80          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_CONTINUOUS_TASK_STOP): {
81              return HandleOnAppContinuousTaskStop(data);
82          }
83          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_EFFICIENCY_RESOURCES_APPLY): {
84              return HandleOnAppEfficiencyResourcesApply(data);
85          }
86          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_EFFICIENCY_RESOURCES_RESET): {
87              return HandleOnAppEfficiencyResourcesReset(data);
88          }
89          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_PROC_EFFICIENCY_RESOURCES_APPLY): {
90              return HandleOnProcEfficiencyResourcesApply(data);
91          }
92          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_PROC_EFFICIENCY_RESOURCES_RESET): {
93              return HandleOnProcEfficiencyResourcesReset(data);
94          }
95          default:
96              return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
97      }
98      return ERR_OK;
99  }
100  
HandleTransientTask(uint32_t code,MessageParcel & data)101  ErrCode BackgroundTaskSubscriberStub::HandleTransientTask(uint32_t code, MessageParcel &data)
102  {
103      switch (code) {
104          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_START): {
105              return HandleOnTransientTaskStart(data);
106          }
107          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_END): {
108              return HandleOnTransientTaskEnd(data);
109          }
110          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_TRANSIENT_TASK_ERR): {
111              return HandleOnTransientTaskErr(data);
112          }
113          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_TRANSIENT_TASK_START): {
114              return HandleOnAppTransientTaskStart(data);
115          }
116          case static_cast<uint32_t>(IBackgroundTaskSubscriberInterfaceCode::ON_APP_TRANSIENT_TASK_END): {
117              return HandleOnAppTransientTaskEnd(data);
118          }
119      }
120      return ERR_OK;
121  }
122  
HandleOnConnected()123  ErrCode BackgroundTaskSubscriberStub::HandleOnConnected()
124  {
125      OnConnected();
126      return ERR_OK;
127  }
128  
HandleOnDisconnected()129  ErrCode BackgroundTaskSubscriberStub::HandleOnDisconnected()
130  {
131      OnDisconnected();
132      return ERR_OK;
133  }
134  
HandleOnTransientTaskStart(MessageParcel & data)135  ErrCode BackgroundTaskSubscriberStub::HandleOnTransientTaskStart(MessageParcel& data)
136  {
137      auto info = TransientTaskAppInfo::Unmarshalling(data);
138      if (info == nullptr) {
139          BGTASK_LOGE("HandleOnTransientTaskStart Read parcel failed.");
140          return ERR_INVALID_DATA;
141      }
142      OnTransientTaskStart(info);
143      return ERR_NONE;
144  }
145  
HandleOnTransientTaskEnd(MessageParcel & data)146  ErrCode BackgroundTaskSubscriberStub::HandleOnTransientTaskEnd(MessageParcel& data)
147  {
148      auto info = TransientTaskAppInfo::Unmarshalling(data);
149      if (info == nullptr) {
150          BGTASK_LOGE("HandleOnTransientTaskEnd Read parcel failed.");
151          return ERR_INVALID_DATA;
152      }
153      OnTransientTaskEnd(info);
154      return ERR_NONE;
155  }
156  
HandleOnTransientTaskErr(MessageParcel & data)157  ErrCode BackgroundTaskSubscriberStub::HandleOnTransientTaskErr(MessageParcel& data)
158  {
159      auto info = TransientTaskAppInfo::Unmarshalling(data);
160      if (info == nullptr) {
161          BGTASK_LOGE("HandleOnTransientTaskErr Read parcel failed.");
162          return ERR_INVALID_DATA;
163      }
164      OnTransientTaskErr(info);
165      return ERR_NONE;
166  }
167  
HandleOnAppTransientTaskStart(MessageParcel & data)168  ErrCode BackgroundTaskSubscriberStub::HandleOnAppTransientTaskStart(MessageParcel& data)
169  {
170      auto info = TransientTaskAppInfo::Unmarshalling(data);
171      if (info == nullptr) {
172          BGTASK_LOGE("HandleOnAppTransientTaskStart Read parcel failed.");
173          return ERR_INVALID_DATA;
174      }
175      OnAppTransientTaskStart(info);
176      return ERR_NONE;
177  }
178  
HandleOnAppTransientTaskEnd(MessageParcel & data)179  ErrCode BackgroundTaskSubscriberStub::HandleOnAppTransientTaskEnd(MessageParcel& data)
180  {
181      auto info = TransientTaskAppInfo::Unmarshalling(data);
182      if (info == nullptr) {
183          BGTASK_LOGE("HandleOnAppTransientTaskEnd Read parcel failed.");
184          return ERR_INVALID_DATA;
185      }
186      OnAppTransientTaskEnd(info);
187      return ERR_NONE;
188  }
189  
HandleOnContinuousTaskStart(MessageParcel & data)190  ErrCode BackgroundTaskSubscriberStub::HandleOnContinuousTaskStart(MessageParcel &data)
191  {
192      std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
193          = std::shared_ptr<ContinuousTaskCallbackInfo>(data.ReadParcelable<ContinuousTaskCallbackInfo>());
194      if (!continuousTaskCallbackInfo) {
195          BGTASK_LOGE("HandleOnContinuousTaskStart ContinuousTaskCallbackInfo ReadParcelable failed");
196          return ERR_BGTASK_PARCELABLE_FAILED;
197      }
198  
199      OnContinuousTaskStart(continuousTaskCallbackInfo);
200      return ERR_OK;
201  }
202  
HandleOnContinuousTaskUpdate(MessageParcel & data)203  ErrCode BackgroundTaskSubscriberStub::HandleOnContinuousTaskUpdate(MessageParcel &data)
204  {
205      std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
206          = std::shared_ptr<ContinuousTaskCallbackInfo>(data.ReadParcelable<ContinuousTaskCallbackInfo>());
207      if (!continuousTaskCallbackInfo) {
208          BGTASK_LOGE("HandleOnContinuousTaskUpdate ContinuousTaskCallbackInfo ReadParcelable failed");
209          return ERR_BGTASK_PARCELABLE_FAILED;
210      }
211  
212      OnContinuousTaskUpdate(continuousTaskCallbackInfo);
213      return ERR_OK;
214  }
215  
HandleOnContinuousTaskCancel(MessageParcel & data)216  ErrCode BackgroundTaskSubscriberStub::HandleOnContinuousTaskCancel(MessageParcel &data)
217  {
218      std::shared_ptr<ContinuousTaskCallbackInfo> continuousTaskCallbackInfo
219          = std::shared_ptr<ContinuousTaskCallbackInfo>(data.ReadParcelable<ContinuousTaskCallbackInfo>());
220      if (!continuousTaskCallbackInfo) {
221          BGTASK_LOGE("HandleOnContinuousTaskCancel ContinuousTaskCallbackInfo ReadParcelable failed");
222          return ERR_BGTASK_PARCELABLE_FAILED;
223      }
224  
225      OnContinuousTaskStop(continuousTaskCallbackInfo);
226      return ERR_OK;
227  }
228  
HandleOnAppContinuousTaskStop(MessageParcel & data)229  ErrCode BackgroundTaskSubscriberStub::HandleOnAppContinuousTaskStop(MessageParcel &data)
230  {
231      int32_t uid;
232      if (!data.ReadInt32(uid)) {
233          BGTASK_LOGE("HandleOnAppContinuousTaskStop read uid failed");
234          return ERR_BGTASK_PARCELABLE_FAILED;
235      }
236  
237      OnAppContinuousTaskStop(uid);
238      return ERR_OK;
239  }
240  
HandleOnAppEfficiencyResourcesApply(MessageParcel & data)241  ErrCode BackgroundTaskSubscriberStub::HandleOnAppEfficiencyResourcesApply(MessageParcel &data)
242  {
243      std::shared_ptr<ResourceCallbackInfo> resourceCallbackInfo
244          = std::shared_ptr<ResourceCallbackInfo>(data.ReadParcelable<ResourceCallbackInfo>());
245      if (!resourceCallbackInfo) {
246          BGTASK_LOGE("HandleOnAppEfficiencyResourcesApply ReadParcelable failed");
247          return ERR_BGTASK_PARCELABLE_FAILED;
248      }
249      OnAppEfficiencyResourcesApply(resourceCallbackInfo);
250      return ERR_OK;
251  }
252  
HandleOnAppEfficiencyResourcesReset(MessageParcel & data)253  ErrCode BackgroundTaskSubscriberStub::HandleOnAppEfficiencyResourcesReset(MessageParcel &data)
254  {
255      std::shared_ptr<ResourceCallbackInfo> resourceCallbackInfo
256          = std::shared_ptr<ResourceCallbackInfo>(data.ReadParcelable<ResourceCallbackInfo>());
257      if (!resourceCallbackInfo) {
258          BGTASK_LOGE("HandleOnAppEfficiencyResourcesReset ReadParcelable failed");
259          return ERR_BGTASK_PARCELABLE_FAILED;
260      }
261      OnAppEfficiencyResourcesReset(resourceCallbackInfo);
262      return ERR_OK;
263  }
264  
HandleOnProcEfficiencyResourcesApply(MessageParcel & data)265  ErrCode BackgroundTaskSubscriberStub::HandleOnProcEfficiencyResourcesApply(MessageParcel &data)
266  {
267      std::shared_ptr<ResourceCallbackInfo> resourceCallbackInfo
268          = std::shared_ptr<ResourceCallbackInfo>(data.ReadParcelable<ResourceCallbackInfo>());
269      if (!resourceCallbackInfo) {
270          BGTASK_LOGE("HandleOnProcEfficiencyResourcesApply ContinuousTaskCallbackInfo ReadParcelable failed");
271          return ERR_BGTASK_PARCELABLE_FAILED;
272      }
273      OnProcEfficiencyResourcesApply(resourceCallbackInfo);
274      return ERR_OK;
275  }
276  
HandleOnProcEfficiencyResourcesReset(MessageParcel & data)277  ErrCode BackgroundTaskSubscriberStub::HandleOnProcEfficiencyResourcesReset(MessageParcel &data)
278  {
279      std::shared_ptr<ResourceCallbackInfo> resourceCallbackInfo
280          = std::shared_ptr<ResourceCallbackInfo>(data.ReadParcelable<ResourceCallbackInfo>());
281      if (!resourceCallbackInfo) {
282          BGTASK_LOGE("HandleOnProcEfficiencyResourcesReset ReadParcelable failed");
283          return ERR_BGTASK_PARCELABLE_FAILED;
284      }
285      OnProcEfficiencyResourcesReset(resourceCallbackInfo);
286      return ERR_OK;
287  }
288  }  // namespace BackgroundTaskMgr
289  }  // namespace OHOS