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