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