1 /*
2 * Copyright (c) 2022-2023 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 "app_control_host.h"
17
18 #include "app_control_constants.h"
19 #include "app_log_tag_wrapper.h"
20 #include "app_log_wrapper.h"
21 #include "appexecfwk_errors.h"
22 #include "bundle_framework_core_ipc_interface_code.h"
23 #include "bundle_memory_guard.h"
24 #include "disposed_rule.h"
25 #include "ipc_types.h"
26
27 namespace OHOS {
28 namespace AppExecFwk {
AppControlHost()29 AppControlHost::AppControlHost()
30 {
31 LOG_D(BMS_TAG_DEFAULT, "create AppControlHost");
32 }
33
~AppControlHost()34 AppControlHost::~AppControlHost()
35 {
36 LOG_D(BMS_TAG_DEFAULT, "destroy AppControlHost");
37 }
38
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)39 int AppControlHost::OnRemoteRequest(
40 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
41 {
42 BundleMemoryGuard memoryGuard;
43 LOG_I(BMS_TAG_DEFAULT, "AppControlHost OnRemoteRequest, message code : %{public}u", code);
44 std::u16string descriptor = AppControlHost::GetDescriptor();
45 std::u16string remoteDescriptor = data.ReadInterfaceToken();
46 if (descriptor != remoteDescriptor) {
47 LOG_E(BMS_TAG_DEFAULT, "descriptor invalid");
48 return OBJECT_NULL;
49 }
50
51 switch (code) {
52 case static_cast<uint32_t>(AppControlManagerInterfaceCode::ADD_APP_INSTALL_CONTROL_RULE):
53 return HandleAddAppInstallControlRule(data, reply);
54 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_APP_INSTALL_CONTROL_RULE):
55 return HandleDeleteAppInstallControlRule(data, reply);
56 case static_cast<uint32_t>(AppControlManagerInterfaceCode::CLEAN_APP_INSTALL_CONTROL_RULE):
57 return HandleCleanAppInstallControlRule(data, reply);
58 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_APP_INSTALL_CONTROL_RULE):
59 return HandleGetAppInstallControlRule(data, reply);
60 case static_cast<uint32_t>(AppControlManagerInterfaceCode::ADD_APP_RUNNING_CONTROL_RULE):
61 return HandleAddAppRunningControlRule(data, reply);
62 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_APP_RUNNING_CONTROL_RULE):
63 return HandleDeleteAppRunningControlRule(data, reply);
64 case static_cast<uint32_t>(AppControlManagerInterfaceCode::CLEAN_APP_RUNNING_CONTROL_RULE):
65 return HandleCleanAppRunningControlRule(data, reply);
66 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_APP_RUNNING_CONTROL_RULE):
67 return HandleGetAppRunningControlRule(data, reply);
68 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_APP_RUNNING_CONTROL_RULE_RESULT):
69 return HandleGetAppRunningControlRuleResult(data, reply);
70 case static_cast<uint32_t>(AppControlManagerInterfaceCode::CONFIRM_APP_JUMP_CONTROL_RULE):
71 return HandleConfirmAppJumpControlRule(data, reply);
72 case static_cast<uint32_t>(AppControlManagerInterfaceCode::ADD_APP_JUMP_CONTROL_RULE):
73 return HandleAddAppJumpControlRule(data, reply);
74 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_APP_JUMP_CONTROL_RULE):
75 return HandleDeleteAppJumpControlRule(data, reply);
76 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_APP_JUMP_CONTROL_RULE_BY_CALLER):
77 return HandleDeleteRuleByCallerBundleName(data, reply);
78 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_APP_JUMP_CONTROL_RULE_BY_TARGET):
79 return HandleDeleteRuleByTargetBundleName(data, reply);
80 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_APP_JUMP_CONTROL_RULE):
81 return HandleGetAppJumpControlRule(data, reply);
82 case static_cast<uint32_t>(AppControlManagerInterfaceCode::SET_DISPOSED_STATUS):
83 return HandleSetDisposedStatus(data, reply);
84 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_DISPOSED_STATUS):
85 return HandleGetDisposedStatus(data, reply);
86 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_DISPOSED_STATUS):
87 return HandleDeleteDisposedStatus(data, reply);
88 case static_cast<uint32_t>(AppControlManagerInterfaceCode::SET_DISPOSED_RULE):
89 return HandleSetDisposedRule(data, reply);
90 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_DISPOSED_RULE):
91 return HandleGetDisposedRule(data, reply);
92 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_ABILITY_RUNNING_CONTROL_RULE):
93 return HandleGetAbilityRunningControlRule(data, reply);
94 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_DISPOSED_RULE_FOR_CLONE_APP):
95 return HandleGetDisposedRuleForCloneApp(data, reply);
96 case static_cast<uint32_t>(AppControlManagerInterfaceCode::SET_DISPOSED_RULE_FOR_CLONE_APP):
97 return HandleSetDisposedRuleForCloneApp(data, reply);
98 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_DISPOSED_RULE_FOR_CLONE_APP):
99 return HandleDeleteDisposedRuleForCloneApp(data, reply);
100 case static_cast<uint32_t>(AppControlManagerInterfaceCode::SET_UNINSTALL_DISPOSED_RULE):
101 return HandleSetUninstallDisposedRule(data, reply);
102 case static_cast<uint32_t>(AppControlManagerInterfaceCode::GET_UNINSTALL_DISPOSED_RULE):
103 return HandleGetUninstallDisposedRule(data, reply);
104 case static_cast<uint32_t>(AppControlManagerInterfaceCode::DELETE_UNINSTALL_DISPOSED_RULE):
105 return HandleDeleteUninstallDisposedRule(data, reply);
106 default:
107 LOG_W(BMS_TAG_DEFAULT, "AppControlHost receive unknown code, code = %{public}d", code);
108 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
109 }
110 }
111
HandleAddAppInstallControlRule(MessageParcel & data,MessageParcel & reply)112 ErrCode AppControlHost::HandleAddAppInstallControlRule(MessageParcel& data, MessageParcel& reply)
113 {
114 std::vector<std::string> appIds;
115 int32_t appIdSize = data.ReadInt32();
116 if (appIdSize > AppControlConstants::LIST_MAX_SIZE || appIdSize < 0) {
117 LOG_E(BMS_TAG_DEFAULT, "HandleAddAppInstallControlRule parameter is invalid");
118 return ERR_BUNDLE_MANAGER_INVALID_PARAMETER;
119 }
120 for (int32_t i = 0; i < appIdSize; i++) {
121 appIds.emplace_back(data.ReadString());
122 }
123 AppInstallControlRuleType controlRuleType = static_cast<AppInstallControlRuleType>(data.ReadInt32());
124 int32_t userId = data.ReadInt32();
125 int32_t ret = AddAppInstallControlRule(appIds, controlRuleType, userId);
126 if (ret != ERR_OK) {
127 LOG_E(BMS_TAG_DEFAULT, "HandleAddAppInstallControlRule failed");
128 }
129 return ret;
130 }
131
HandleDeleteAppInstallControlRule(MessageParcel & data,MessageParcel & reply)132 ErrCode AppControlHost::HandleDeleteAppInstallControlRule(MessageParcel& data, MessageParcel& reply)
133 {
134 AppInstallControlRuleType controlRuleType = static_cast<AppInstallControlRuleType>(data.ReadInt32());
135 std::vector<std::string> appIds;
136 int32_t appIdSize = data.ReadInt32();
137 if (appIdSize > AppControlConstants::LIST_MAX_SIZE || appIdSize < 0) {
138 LOG_E(BMS_TAG_DEFAULT, "HandleDeleteAppInstallControlRule parameter is invalid");
139 return ERR_BUNDLE_MANAGER_INVALID_PARAMETER;
140 }
141 for (int32_t i = 0; i < appIdSize; i++) {
142 appIds.emplace_back(data.ReadString());
143 }
144 int32_t userId = data.ReadInt32();
145 int32_t ret = DeleteAppInstallControlRule(controlRuleType, appIds, userId);
146 if (ret != ERR_OK) {
147 LOG_E(BMS_TAG_DEFAULT, "HandleDeleteAppInstallControlRule failed");
148 }
149 return ret;
150 }
151
HandleCleanAppInstallControlRule(MessageParcel & data,MessageParcel & reply)152 ErrCode AppControlHost::HandleCleanAppInstallControlRule(MessageParcel& data, MessageParcel& reply)
153 {
154 AppInstallControlRuleType controlRuleType = static_cast<AppInstallControlRuleType>(data.ReadInt32());
155 int32_t userId = data.ReadInt32();
156 int32_t ret = DeleteAppInstallControlRule(controlRuleType, userId);
157 if (ret != ERR_OK) {
158 LOG_E(BMS_TAG_DEFAULT, "HandleCleanAppInstallControlRule failed");
159 }
160 return ret;
161 }
162
HandleGetAppInstallControlRule(MessageParcel & data,MessageParcel & reply)163 ErrCode AppControlHost::HandleGetAppInstallControlRule(MessageParcel& data, MessageParcel& reply)
164 {
165 AppInstallControlRuleType controlRuleType = static_cast<AppInstallControlRuleType>(data.ReadInt32());
166 int32_t userId = data.ReadInt32();
167 std::vector<std::string> appIds;
168 int32_t ret = GetAppInstallControlRule(controlRuleType, userId, appIds);
169 if (ret != ERR_OK) {
170 LOG_E(BMS_TAG_DEFAULT, "HandleGetAppInstallControlRule failed");
171 return ret;
172 }
173 if (!WriteStringVector(appIds, reply)) {
174 LOG_E(BMS_TAG_DEFAULT, "write appIds failed");
175 return ERR_APPEXECFWK_PARCEL_ERROR;
176 }
177 return ERR_OK;
178 }
179
HandleAddAppRunningControlRule(MessageParcel & data,MessageParcel & reply)180 ErrCode AppControlHost::HandleAddAppRunningControlRule(MessageParcel& data, MessageParcel& reply)
181 {
182 std::vector<AppRunningControlRule> controlRules;
183 auto ret = ReadParcelableVector(data, controlRules);
184 if (ret != ERR_OK) {
185 LOG_E(BMS_TAG_DEFAULT, "AddAppRunningControlRule read controlRuleParam failed");
186 return ret;
187 }
188 int32_t userId = data.ReadInt32();
189 return AddAppRunningControlRule(controlRules, userId);
190 }
191
HandleDeleteAppRunningControlRule(MessageParcel & data,MessageParcel & reply)192 ErrCode AppControlHost::HandleDeleteAppRunningControlRule(MessageParcel& data, MessageParcel& reply)
193 {
194 std::vector<AppRunningControlRule> controlRules;
195 auto ret = ReadParcelableVector(data, controlRules);
196 if (ret != ERR_OK) {
197 LOG_E(BMS_TAG_DEFAULT, "DeleteAppRunningControlRule read controlRuleParam failed");
198 return ret;
199 }
200 int32_t userId = data.ReadInt32();
201 return DeleteAppRunningControlRule(controlRules, userId);
202 }
203
HandleCleanAppRunningControlRule(MessageParcel & data,MessageParcel & reply)204 ErrCode AppControlHost::HandleCleanAppRunningControlRule(MessageParcel& data, MessageParcel& reply)
205 {
206 int32_t userId = data.ReadInt32();
207 int32_t ret = DeleteAppRunningControlRule(userId);
208 if (ret != ERR_OK) {
209 LOG_E(BMS_TAG_DEFAULT, "HandleCleanAppInstallControlRule failed");
210 }
211 return ret;
212 }
213
HandleGetAppRunningControlRule(MessageParcel & data,MessageParcel & reply)214 ErrCode AppControlHost::HandleGetAppRunningControlRule(MessageParcel& data, MessageParcel& reply)
215 {
216 int32_t userId = data.ReadInt32();
217 std::vector<std::string> appIds;
218 int32_t ret = GetAppRunningControlRule(userId, appIds);
219 if (ret != ERR_OK) {
220 LOG_E(BMS_TAG_DEFAULT, "HandleGetAppRunningControlRule failed");
221 return ret;
222 }
223 if (!WriteStringVector(appIds, reply)) {
224 LOG_E(BMS_TAG_DEFAULT, "write appIds failed");
225 return ERR_APPEXECFWK_PARCEL_ERROR;
226 }
227 return ERR_OK;
228 }
229
HandleGetAppRunningControlRuleResult(MessageParcel & data,MessageParcel & reply)230 ErrCode AppControlHost::HandleGetAppRunningControlRuleResult(MessageParcel& data, MessageParcel& reply)
231 {
232 std::string bundleName = data.ReadString();
233 int32_t userId = data.ReadInt32();
234 AppRunningControlRuleResult ruleResult;
235 int32_t ret = GetAppRunningControlRule(bundleName, userId, ruleResult);
236 if (ret != ERR_OK) {
237 LOG_E(BMS_TAG_DEFAULT, "HandleGetAppRunningControlRuleResult failed");
238 }
239 if (!reply.WriteInt32(ret)) {
240 LOG_E(BMS_TAG_DEFAULT, "write result failed");
241 return ERR_APPEXECFWK_PARCEL_ERROR;
242 }
243 if ((ret == ERR_OK) && !reply.WriteParcelable(&ruleResult)) {
244 LOG_E(BMS_TAG_DEFAULT, "write AppRunningControlRuleResult failed");
245 return ERR_APPEXECFWK_PARCEL_ERROR;
246 }
247 return ERR_OK;
248 }
249
HandleConfirmAppJumpControlRule(MessageParcel & data,MessageParcel & reply)250 ErrCode AppControlHost::HandleConfirmAppJumpControlRule(MessageParcel& data, MessageParcel& reply)
251 {
252 std::string callerBundleName = data.ReadString();
253 std::string targetBundleName = data.ReadString();
254 int32_t userId = data.ReadInt32();
255 int32_t ret = ConfirmAppJumpControlRule(callerBundleName, targetBundleName, userId);
256 if (ret != ERR_OK) {
257 LOG_E(BMS_TAG_DEFAULT, "HandleConfirmAppJumpControlRule failed");
258 }
259 return ret;
260 }
261
HandleAddAppJumpControlRule(MessageParcel & data,MessageParcel & reply)262 ErrCode AppControlHost::HandleAddAppJumpControlRule(MessageParcel& data, MessageParcel& reply)
263 {
264 std::vector<AppJumpControlRule> controlRules;
265 auto ret = ReadParcelableVector(data, controlRules);
266 if (ret != ERR_OK) {
267 LOG_E(BMS_TAG_DEFAULT, "HandleAddAppJumpControlRule read controlRuleParam failed");
268 return ret;
269 }
270 int32_t userId = data.ReadInt32();
271 return AddAppJumpControlRule(controlRules, userId);
272 }
273
HandleDeleteAppJumpControlRule(MessageParcel & data,MessageParcel & reply)274 ErrCode AppControlHost::HandleDeleteAppJumpControlRule(MessageParcel& data, MessageParcel& reply)
275 {
276 std::vector<AppJumpControlRule> controlRules;
277 auto ret = ReadParcelableVector(data, controlRules);
278 if (ret != ERR_OK) {
279 LOG_E(BMS_TAG_DEFAULT, "HandleDeleteAppJumpControlRule read controlRuleParam failed");
280 return ret;
281 }
282 int32_t userId = data.ReadInt32();
283 return DeleteAppJumpControlRule(controlRules, userId);
284 }
285
HandleDeleteRuleByCallerBundleName(MessageParcel & data,MessageParcel & reply)286 ErrCode AppControlHost::HandleDeleteRuleByCallerBundleName(MessageParcel& data, MessageParcel& reply)
287 {
288 std::string callerBundleName = data.ReadString();
289 int32_t userId = data.ReadInt32();
290 int32_t ret = DeleteRuleByCallerBundleName(callerBundleName, userId);
291 if (ret != ERR_OK) {
292 LOG_E(BMS_TAG_DEFAULT, "HandleDeleteRuleByCallerBundleName failed");
293 }
294 return ret;
295 }
296
HandleDeleteRuleByTargetBundleName(MessageParcel & data,MessageParcel & reply)297 ErrCode AppControlHost::HandleDeleteRuleByTargetBundleName(MessageParcel& data, MessageParcel& reply)
298 {
299 std::string targetBundleName = data.ReadString();
300 int32_t userId = data.ReadInt32();
301 int32_t ret = DeleteRuleByTargetBundleName(targetBundleName, userId);
302 if (ret != ERR_OK) {
303 LOG_E(BMS_TAG_DEFAULT, "HandleDeleteRuleByTargetBundleName failed");
304 }
305 return ret;
306 }
307
HandleGetAppJumpControlRule(MessageParcel & data,MessageParcel & reply)308 ErrCode AppControlHost::HandleGetAppJumpControlRule(MessageParcel& data, MessageParcel& reply)
309 {
310 std::string callerBundleName = data.ReadString();
311 std::string targetBundleName = data.ReadString();
312 int32_t userId = data.ReadInt32();
313 AppJumpControlRule rule;
314 int32_t ret = GetAppJumpControlRule(callerBundleName, targetBundleName, userId, rule);
315 if (ret != ERR_OK) {
316 LOG_E(BMS_TAG_DEFAULT, "HandleGetAppJumpControlRule failed");
317 }
318 if (!reply.WriteInt32(ret)) {
319 LOG_E(BMS_TAG_DEFAULT, "write result failed");
320 return ERR_APPEXECFWK_PARCEL_ERROR;
321 }
322 if ((ret == ERR_OK) && !reply.WriteParcelable(&rule)) {
323 LOG_E(BMS_TAG_DEFAULT, "write AppJumpControlRule failed");
324 return ERR_APPEXECFWK_PARCEL_ERROR;
325 }
326 return ERR_OK;
327 }
328
HandleSetDisposedStatus(MessageParcel & data,MessageParcel & reply)329 ErrCode AppControlHost::HandleSetDisposedStatus(MessageParcel& data, MessageParcel& reply)
330 {
331 std::string appId = data.ReadString();
332 std::unique_ptr<Want> want(data.ReadParcelable<Want>());
333 int32_t userId = data.ReadInt32();
334 if (want == nullptr) {
335 LOG_E(BMS_TAG_DEFAULT, "ReadParcelable<Want> failed");
336 return ERR_APPEXECFWK_PARCEL_ERROR;
337 }
338 ErrCode ret = SetDisposedStatus(appId, *want, userId);
339 if (!reply.WriteInt32(ret)) {
340 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
341 return ERR_APPEXECFWK_PARCEL_ERROR;
342 }
343 return ERR_OK;
344 }
345
HandleDeleteDisposedStatus(MessageParcel & data,MessageParcel & reply)346 ErrCode AppControlHost::HandleDeleteDisposedStatus(MessageParcel& data, MessageParcel &reply)
347 {
348 std::string appId = data.ReadString();
349 int32_t userId = data.ReadInt32();
350 ErrCode ret = DeleteDisposedStatus(appId, userId);
351 if (!reply.WriteInt32(ret)) {
352 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
353 return ERR_APPEXECFWK_PARCEL_ERROR;
354 }
355 return ERR_OK;
356 }
357
HandleGetDisposedStatus(MessageParcel & data,MessageParcel & reply)358 ErrCode AppControlHost::HandleGetDisposedStatus(MessageParcel& data, MessageParcel &reply)
359 {
360 std::string appId = data.ReadString();
361 int32_t userId = data.ReadInt32();
362 Want want;
363 ErrCode ret = GetDisposedStatus(appId, want, userId);
364 if (!reply.WriteInt32(ret)) {
365 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
366 return ERR_APPEXECFWK_PARCEL_ERROR;
367 }
368 if (ret == ERR_OK) {
369 if (!reply.WriteParcelable(&want)) {
370 LOG_E(BMS_TAG_DEFAULT, "write failed");
371 return ERR_APPEXECFWK_PARCEL_ERROR;
372 }
373 }
374 return ERR_OK;
375 }
376
HandleGetDisposedRule(MessageParcel & data,MessageParcel & reply)377 ErrCode AppControlHost::HandleGetDisposedRule(MessageParcel& data, MessageParcel &reply)
378 {
379 std::string appId = data.ReadString();
380 int32_t userId = data.ReadInt32();
381 DisposedRule rule;
382 ErrCode ret = GetDisposedRule(appId, rule, userId);
383 if (!reply.WriteInt32(ret)) {
384 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
385 return ERR_APPEXECFWK_PARCEL_ERROR;
386 }
387 if (ret == ERR_OK) {
388 if (!reply.WriteParcelable(&rule)) {
389 LOG_E(BMS_TAG_DEFAULT, "write failed");
390 return ERR_APPEXECFWK_PARCEL_ERROR;
391 }
392 }
393 return ERR_OK;
394 }
395
HandleSetDisposedRule(MessageParcel & data,MessageParcel & reply)396 ErrCode AppControlHost::HandleSetDisposedRule(MessageParcel& data, MessageParcel& reply)
397 {
398 std::string appId = data.ReadString();
399 std::unique_ptr<DisposedRule> disposedRule(data.ReadParcelable<DisposedRule>());
400 int32_t userId = data.ReadInt32();
401 if (disposedRule == nullptr) {
402 LOG_E(BMS_TAG_DEFAULT, "ReadParcelable<disposedRule> failed");
403 return ERR_APPEXECFWK_PARCEL_ERROR;
404 }
405 ErrCode ret = SetDisposedRule(appId, *disposedRule, userId);
406 if (!reply.WriteInt32(ret)) {
407 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
408 return ERR_APPEXECFWK_PARCEL_ERROR;
409 }
410 return ERR_OK;
411 }
412
HandleGetAbilityRunningControlRule(MessageParcel & data,MessageParcel & reply)413 ErrCode AppControlHost::HandleGetAbilityRunningControlRule(MessageParcel& data, MessageParcel& reply)
414 {
415 std::string bundleName = data.ReadString();
416 int32_t userId = data.ReadInt32();
417 int32_t appIndex = data.ReadInt32();
418 std::vector<DisposedRule> rules;
419 ErrCode ret = GetAbilityRunningControlRule(bundleName, userId, rules, appIndex);
420 if (!reply.WriteInt32(ret)) {
421 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
422 return ERR_APPEXECFWK_PARCEL_ERROR;
423 }
424 if (ret == ERR_OK) {
425 if (!WriteParcelableVector(rules, reply)) {
426 LOG_E(BMS_TAG_DEFAULT, "write failed");
427 return ERR_APPEXECFWK_PARCEL_ERROR;
428 }
429 }
430 return ERR_OK;
431 }
432
HandleGetDisposedRuleForCloneApp(MessageParcel & data,MessageParcel & reply)433 ErrCode AppControlHost::HandleGetDisposedRuleForCloneApp(MessageParcel& data, MessageParcel &reply)
434 {
435 std::string appId = data.ReadString();
436 int32_t userId = data.ReadInt32();
437 int32_t appIndex = data.ReadInt32();
438 DisposedRule rule;
439 ErrCode ret = GetDisposedRuleForCloneApp(appId, rule, appIndex, userId);
440 if (!reply.WriteInt32(ret)) {
441 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
442 return ERR_APPEXECFWK_PARCEL_ERROR;
443 }
444 if (ret == ERR_OK) {
445 if (!reply.WriteParcelable(&rule)) {
446 LOG_E(BMS_TAG_DEFAULT, "write failed");
447 return ERR_APPEXECFWK_PARCEL_ERROR;
448 }
449 }
450 return ERR_OK;
451 }
452
HandleSetDisposedRuleForCloneApp(MessageParcel & data,MessageParcel & reply)453 ErrCode AppControlHost::HandleSetDisposedRuleForCloneApp(MessageParcel& data, MessageParcel& reply)
454 {
455 std::string appId = data.ReadString();
456 std::unique_ptr<DisposedRule> disposedRule(data.ReadParcelable<DisposedRule>());
457 int32_t userId = data.ReadInt32();
458 int32_t appIndex = data.ReadInt32();
459 if (disposedRule == nullptr) {
460 LOG_E(BMS_TAG_DEFAULT, "ReadParcelable<disposedRule> failed");
461 return ERR_APPEXECFWK_PARCEL_ERROR;
462 }
463 ErrCode ret = SetDisposedRuleForCloneApp(appId, *disposedRule, appIndex, userId);
464 if (!reply.WriteInt32(ret)) {
465 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
466 return ERR_APPEXECFWK_PARCEL_ERROR;
467 }
468 return ERR_OK;
469 }
470
HandleDeleteDisposedRuleForCloneApp(MessageParcel & data,MessageParcel & reply)471 ErrCode AppControlHost::HandleDeleteDisposedRuleForCloneApp(MessageParcel& data, MessageParcel& reply)
472 {
473 std::string appId = data.ReadString();
474 int32_t userId = data.ReadInt32();
475 int32_t appIndex = data.ReadInt32();
476 ErrCode ret = DeleteDisposedRuleForCloneApp(appId, appIndex, userId);
477 if (!reply.WriteInt32(ret)) {
478 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
479 return ERR_APPEXECFWK_PARCEL_ERROR;
480 }
481 return ERR_OK;
482 }
483
WriteStringVector(const std::vector<std::string> & stringVector,MessageParcel & reply)484 bool AppControlHost::WriteStringVector(const std::vector<std::string> &stringVector, MessageParcel &reply)
485 {
486 if (!reply.WriteInt32(stringVector.size())) {
487 LOG_E(BMS_TAG_DEFAULT, "write ParcelableVector failed");
488 return false;
489 }
490
491 for (auto &string : stringVector) {
492 if (!reply.WriteString(string)) {
493 LOG_E(BMS_TAG_DEFAULT, "write string failed");
494 return false;
495 }
496 }
497 return true;
498 }
499
500 template<typename T>
WriteParcelableVector(std::vector<T> & parcelableVector,MessageParcel & reply)501 bool AppControlHost::WriteParcelableVector(std::vector<T> &parcelableVector, MessageParcel &reply)
502 {
503 if (!reply.WriteInt32(parcelableVector.size())) {
504 LOG_E(BMS_TAG_DEFAULT, "write ParcelableVector failed");
505 return false;
506 }
507
508 for (auto &parcelable : parcelableVector) {
509 if (!reply.WriteParcelable(&parcelable)) {
510 LOG_E(BMS_TAG_DEFAULT, "write ParcelableVector failed");
511 return false;
512 }
513 }
514 return true;
515 }
516
517 template<typename T>
ReadParcelableVector(MessageParcel & data,std::vector<T> & parcelableInfos)518 ErrCode AppControlHost::ReadParcelableVector(MessageParcel &data, std::vector<T> &parcelableInfos)
519 {
520 int32_t infoSize = data.ReadInt32();
521 if (infoSize > AppControlConstants::LIST_MAX_SIZE) {
522 LOG_E(BMS_TAG_DEFAULT, "elements num exceeds the limit %{public}d", AppControlConstants::LIST_MAX_SIZE);
523 return ERR_BUNDLE_MANAGER_INVALID_PARAMETER;
524 }
525 for (int32_t i = 0; i < infoSize; i++) {
526 std::unique_ptr<T> info(data.ReadParcelable<T>());
527 if (info == nullptr) {
528 LOG_E(BMS_TAG_DEFAULT, "read parcelable infos failed");
529 return ERR_APPEXECFWK_PARCEL_ERROR;
530 }
531 parcelableInfos.emplace_back(*info);
532 }
533 LOG_D(BMS_TAG_DEFAULT, "read parcelable infos success");
534 return ERR_OK;
535 }
536
HandleGetUninstallDisposedRule(MessageParcel & data,MessageParcel & reply)537 ErrCode AppControlHost::HandleGetUninstallDisposedRule(MessageParcel& data, MessageParcel& reply)
538 {
539 std::string appIdentifier = data.ReadString();
540 int32_t userId = data.ReadInt32();
541 int32_t appIndex = data.ReadInt32();
542 UninstallDisposedRule rule;
543 ErrCode ret = GetUninstallDisposedRule(appIdentifier, appIndex, userId, rule);
544 if (!reply.WriteInt32(ret)) {
545 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
546 return ERR_APPEXECFWK_PARCEL_ERROR;
547 }
548 if (ret == ERR_OK) {
549 if (!reply.WriteParcelable(&rule)) {
550 LOG_E(BMS_TAG_DEFAULT, "write failed");
551 return ERR_APPEXECFWK_PARCEL_ERROR;
552 }
553 }
554 return ERR_OK;
555 }
556
HandleSetUninstallDisposedRule(MessageParcel & data,MessageParcel & reply)557 ErrCode AppControlHost::HandleSetUninstallDisposedRule(MessageParcel& data, MessageParcel& reply)
558 {
559 std::string appIdentifier = data.ReadString();
560 std::unique_ptr<UninstallDisposedRule> uninstallDisposedRule(data.ReadParcelable<UninstallDisposedRule>());
561 if (uninstallDisposedRule == nullptr) {
562 LOG_E(BMS_TAG_DEFAULT, "ReadParcelable<uninstalldisposedRule> failed");
563 return ERR_APPEXECFWK_PARCEL_ERROR;
564 }
565 int32_t userId = data.ReadInt32();
566 int32_t appIndex = data.ReadInt32();
567 ErrCode ret = SetUninstallDisposedRule(appIdentifier, *uninstallDisposedRule, appIndex, userId);
568 if (!reply.WriteInt32(ret)) {
569 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
570 return ERR_APPEXECFWK_PARCEL_ERROR;
571 }
572 return ERR_OK;
573 }
574
HandleDeleteUninstallDisposedRule(MessageParcel & data,MessageParcel & reply)575 ErrCode AppControlHost::HandleDeleteUninstallDisposedRule(MessageParcel& data, MessageParcel& reply)
576 {
577 std::string appIdentifier = data.ReadString();
578 int32_t userId = data.ReadInt32();
579 int32_t appIndex = data.ReadInt32();
580 ErrCode ret = DeleteUninstallDisposedRule(appIdentifier, appIndex, userId);
581 if (!reply.WriteInt32(ret)) {
582 LOG_E(BMS_TAG_DEFAULT, "write ret failed");
583 return ERR_APPEXECFWK_PARCEL_ERROR;
584 }
585 return ERR_OK;
586 }
587 } // AppExecFwk
588 } // OHOS
589