1 /*
2 * Copyright (c) 2022-2024 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 "privacy_manager_proxy.h"
17
18 #include "accesstoken_common_log.h"
19 #include "privacy_error.h"
20
21 namespace OHOS {
22 namespace Security {
23 namespace AccessToken {
24 namespace {
25
26 #ifdef SECURITY_COMPONENT_ENHANCE_ENABLE
27 static const int MAX_SEC_COMP_ENHANCE_SIZE = 1000;
28 #endif
29 // if change this, copy value in privacy_kit_test.cpp should change together
30 static const uint32_t MAX_PERMISSION_USED_TYPE_SIZE = 2000;
31 }
32
PrivacyManagerProxy(const sptr<IRemoteObject> & impl)33 PrivacyManagerProxy::PrivacyManagerProxy(const sptr<IRemoteObject>& impl)
34 : IRemoteProxy<IPrivacyManager>(impl) {
35 }
36
~PrivacyManagerProxy()37 PrivacyManagerProxy::~PrivacyManagerProxy()
38 {}
39
AddPermissionUsedRecord(const AddPermParamInfoParcel & infoParcel,bool asyncMode)40 int32_t PrivacyManagerProxy::AddPermissionUsedRecord(const AddPermParamInfoParcel& infoParcel, bool asyncMode)
41 {
42 MessageParcel addData;
43 addData.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
44 if (!addData.WriteParcelable(&infoParcel)) {
45 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteParcelable(infoParcel)");
46 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
47 }
48
49 MessageParcel reply;
50 if (!SendRequest(PrivacyInterfaceCode::ADD_PERMISSION_USED_RECORD, addData, reply, asyncMode)) {
51 return PrivacyError::ERR_SERVICE_ABNORMAL;
52 }
53 int32_t result = reply.ReadInt32();
54 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
55 return result;
56 }
57
SetPermissionUsedRecordToggleStatus(int32_t userID,bool status)58 int32_t PrivacyManagerProxy::SetPermissionUsedRecordToggleStatus(int32_t userID, bool status)
59 {
60 MessageParcel data;
61 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
62 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
63 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
64 }
65 if (!data.WriteInt32(userID)) {
66 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write userID");
67 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
68 }
69 if (!data.WriteBool(status)) {
70 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write status");
71 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
72 }
73
74 MessageParcel reply;
75 if (!SendRequest(PrivacyInterfaceCode::SET_PERMISSION_USED_RECORD_TOGGLE_STATUS, data, reply)) {
76 return PrivacyError::ERR_SERVICE_ABNORMAL;
77 }
78
79 int32_t result = 0;
80 if (!reply.ReadInt32(result)) {
81 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server (error=%{public}d)", result);
82 return ERR_READ_PARCEL_FAILED;
83 }
84 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
85 return result;
86 }
87
GetPermissionUsedRecordToggleStatus(int32_t userID,bool & status)88 int32_t PrivacyManagerProxy::GetPermissionUsedRecordToggleStatus(int32_t userID, bool& status)
89 {
90 MessageParcel data;
91 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
92 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
93 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
94 }
95 if (!data.WriteInt32(userID)) {
96 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write userID");
97 return ERR_WRITE_PARCEL_FAILED;
98 }
99
100 MessageParcel reply;
101 if (!SendRequest(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORD_TOGGLE_STATUS, data, reply)) {
102 return PrivacyError::ERR_SERVICE_ABNORMAL;
103 }
104
105 int32_t result = 0;
106 if (!reply.ReadInt32(result)) {
107 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server (error=%{public}d)", result);
108 return ERR_READ_PARCEL_FAILED;
109 }
110 if (result != RET_SUCCESS) {
111 LOGE(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
112 return result;
113 }
114
115 if (!reply.ReadBool(status)) {
116 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to read status");
117 return ERR_READ_PARCEL_FAILED;
118 }
119 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
120 return result;
121 }
122
StartUsingPermission(const PermissionUsedTypeInfoParcel & infoParcel,const sptr<IRemoteObject> & anonyStub)123 int32_t PrivacyManagerProxy::StartUsingPermission(
124 const PermissionUsedTypeInfoParcel &infoParcel, const sptr<IRemoteObject>& anonyStub)
125 {
126 MessageParcel startData;
127 startData.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
128 if (!startData.WriteParcelable(&infoParcel)) {
129 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write permission used info parcel.");
130 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
131 }
132 if (!startData.WriteRemoteObject(anonyStub)) {
133 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write remote object.");
134 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
135 }
136
137 MessageParcel reply;
138 if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION, startData, reply)) {
139 return PrivacyError::ERR_SERVICE_ABNORMAL;
140 }
141
142 int32_t result = reply.ReadInt32();
143 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
144 return result;
145 }
146
StartUsingPermission(const PermissionUsedTypeInfoParcel & infoParcel,const sptr<IRemoteObject> & callback,const sptr<IRemoteObject> & anonyStub)147 int32_t PrivacyManagerProxy::StartUsingPermission(
148 const PermissionUsedTypeInfoParcel &infoParcel,
149 const sptr<IRemoteObject>& callback, const sptr<IRemoteObject>& anonyStub)
150 {
151 MessageParcel data;
152 data.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
153 if (!data.WriteParcelable(&infoParcel)) {
154 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write permission used info parcel.");
155 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
156 }
157 if (!data.WriteRemoteObject(callback)) {
158 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write remote object.");
159 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
160 }
161
162 if (!data.WriteRemoteObject(anonyStub)) {
163 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write remote object.");
164 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
165 }
166
167 MessageParcel reply;
168 if (!SendRequest(PrivacyInterfaceCode::START_USING_PERMISSION_CALLBACK, data, reply)) {
169 LOGE(PRI_DOMAIN, PRI_TAG, "SendRequest fail");
170 return PrivacyError::ERR_SERVICE_ABNORMAL;
171 }
172
173 int32_t result = reply.ReadInt32();
174 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
175 return result;
176 }
177
StopUsingPermission(AccessTokenID tokenID,int32_t pid,const std::string & permissionName)178 int32_t PrivacyManagerProxy::StopUsingPermission(
179 AccessTokenID tokenID, int32_t pid, const std::string& permissionName)
180 {
181 MessageParcel stopData;
182 stopData.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
183 if (!stopData.WriteUint32(tokenID)) {
184 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write tokenID");
185 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
186 }
187 if (!stopData.WriteInt32(pid)) {
188 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write pid");
189 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
190 }
191 if (!stopData.WriteString(permissionName)) {
192 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write permissionName");
193 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
194 }
195
196 MessageParcel reply;
197 if (!SendRequest(PrivacyInterfaceCode::STOP_USING_PERMISSION, stopData, reply)) {
198 return PrivacyError::ERR_SERVICE_ABNORMAL;
199 }
200
201 int32_t result = reply.ReadInt32();
202 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
203 return result;
204 }
205
RemovePermissionUsedRecords(AccessTokenID tokenID)206 int32_t PrivacyManagerProxy::RemovePermissionUsedRecords(AccessTokenID tokenID)
207 {
208 MessageParcel data;
209 data.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
210 if (!data.WriteUint32(tokenID)) {
211 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", tokenID);
212 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
213 }
214
215 MessageParcel reply;
216 if (!SendRequest(PrivacyInterfaceCode::DELETE_PERMISSION_USED_RECORDS, data, reply)) {
217 return PrivacyError::ERR_SERVICE_ABNORMAL;
218 }
219
220 int32_t result = reply.ReadInt32();
221 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
222 return result;
223 }
224
GetPermissionUsedRecords(const PermissionUsedRequestParcel & request,PermissionUsedResultParcel & result)225 int32_t PrivacyManagerProxy::GetPermissionUsedRecords(const PermissionUsedRequestParcel& request,
226 PermissionUsedResultParcel& result)
227 {
228 MessageParcel data;
229 data.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
230 if (!data.WriteParcelable(&request)) {
231 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteParcelable(request)");
232 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
233 }
234
235 MessageParcel reply;
236 if (!SendRequest(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORDS, data, reply)) {
237 return PrivacyError::ERR_SERVICE_ABNORMAL;
238 }
239
240 int32_t ret = reply.ReadInt32();
241 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", ret);
242 if (ret != RET_SUCCESS) {
243 return ret;
244 }
245 sptr<PermissionUsedResultParcel> resultSptr = reply.ReadParcelable<PermissionUsedResultParcel>();
246 if (resultSptr == nullptr) {
247 LOGE(PRI_DOMAIN, PRI_TAG, "ReadParcelable fail");
248 return PrivacyError::ERR_READ_PARCEL_FAILED;
249 }
250 result = *resultSptr;
251 return ret;
252 }
253
GetPermissionUsedRecords(const PermissionUsedRequestParcel & request,const sptr<OnPermissionUsedRecordCallback> & callback)254 int32_t PrivacyManagerProxy::GetPermissionUsedRecords(const PermissionUsedRequestParcel& request,
255 const sptr<OnPermissionUsedRecordCallback>& callback)
256 {
257 MessageParcel data;
258 data.WriteInterfaceToken(IPrivacyManager::GetDescriptor());
259 if (!data.WriteParcelable(&request)) {
260 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteParcelable(request)");
261 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
262 }
263 if (!data.WriteRemoteObject(callback->AsObject())) {
264 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteRemoteObject(callback)");
265 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
266 }
267
268 MessageParcel reply;
269 if (!SendRequest(PrivacyInterfaceCode::GET_PERMISSION_USED_RECORDS_ASYNC, data, reply)) {
270 return PrivacyError::ERR_SERVICE_ABNORMAL;
271 }
272
273 int32_t result = reply.ReadInt32();
274 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
275 return result;
276 }
277
RegisterPermActiveStatusCallback(std::vector<std::string> & permList,const sptr<IRemoteObject> & callback)278 int32_t PrivacyManagerProxy::RegisterPermActiveStatusCallback(
279 std::vector<std::string>& permList, const sptr<IRemoteObject>& callback)
280 {
281 MessageParcel data;
282 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
283 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
284 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
285 }
286
287 uint32_t listSize = permList.size();
288 if (!data.WriteUint32(listSize)) {
289 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write listSize");
290 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
291 }
292 for (uint32_t i = 0; i < listSize; i++) {
293 if (!data.WriteString(permList[i])) {
294 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write permList[%{public}d], %{public}s", i, permList[i].c_str());
295 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
296 }
297 }
298
299 if (!data.WriteRemoteObject(callback)) {
300 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write remote object.");
301 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
302 }
303 MessageParcel reply;
304 if (!SendRequest(PrivacyInterfaceCode::REGISTER_PERM_ACTIVE_STATUS_CHANGE_CALLBACK, data, reply)) {
305 return PrivacyError::ERR_SERVICE_ABNORMAL;
306 }
307
308 int32_t result = reply.ReadInt32();
309 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
310 return result;
311 }
312
UnRegisterPermActiveStatusCallback(const sptr<IRemoteObject> & callback)313 int32_t PrivacyManagerProxy::UnRegisterPermActiveStatusCallback(const sptr<IRemoteObject>& callback)
314 {
315 MessageParcel data;
316 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
317 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
318 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
319 }
320 if (!data.WriteRemoteObject(callback)) {
321 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write remote object.");
322 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
323 }
324 MessageParcel reply;
325 if (!SendRequest(
326 PrivacyInterfaceCode::UNREGISTER_PERM_ACTIVE_STATUS_CHANGE_CALLBACK, data, reply)) {
327 return PrivacyError::ERR_SERVICE_ABNORMAL;
328 }
329
330 int32_t result = reply.ReadInt32();
331 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
332 return result;
333 }
334
IsAllowedUsingPermission(AccessTokenID tokenID,const std::string & permissionName,int32_t pid)335 bool PrivacyManagerProxy::IsAllowedUsingPermission(AccessTokenID tokenID, const std::string& permissionName,
336 int32_t pid)
337 {
338 MessageParcel data;
339 MessageParcel reply;
340 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
341 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
342 return false;
343 }
344 if (!data.WriteUint32(tokenID)) {
345 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", tokenID);
346 return false;
347 }
348 if (!data.WriteString(permissionName)) {
349 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteString(%{public}s)", permissionName.c_str());
350 return false;
351 }
352 if (!data.WriteInt32(pid)) {
353 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteInt32(%{public}d)", pid);
354 return false;
355 }
356 if (!SendRequest(PrivacyInterfaceCode::IS_ALLOWED_USING_PERMISSION, data, reply)) {
357 return false;
358 }
359
360 bool result = reply.ReadBool();
361 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
362 return result;
363 }
364
365 #ifdef SECURITY_COMPONENT_ENHANCE_ENABLE
RegisterSecCompEnhance(const SecCompEnhanceDataParcel & enhance)366 int32_t PrivacyManagerProxy::RegisterSecCompEnhance(const SecCompEnhanceDataParcel& enhance)
367 {
368 MessageParcel data;
369 MessageParcel reply;
370 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
371 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
372 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
373 }
374
375 if (!data.WriteParcelable(&enhance)) {
376 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write parcel.");
377 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
378 }
379
380 if (!SendRequest(PrivacyInterfaceCode::REGISTER_SEC_COMP_ENHANCE, data, reply, true)) {
381 return PrivacyError::ERR_SERVICE_ABNORMAL;
382 }
383
384 int32_t result = reply.ReadInt32();
385 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
386 return result;
387 }
388
UpdateSecCompEnhance(int32_t pid,uint32_t seqNum)389 int32_t PrivacyManagerProxy::UpdateSecCompEnhance(int32_t pid, uint32_t seqNum)
390 {
391 MessageParcel data;
392 MessageParcel reply;
393 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
394 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write GetDescriptor.");
395 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
396 }
397 if (!data.WriteInt32(pid)) {
398 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write pid=%{public}d.", pid);
399 return false;
400 }
401 if (!data.WriteUint32(seqNum)) {
402 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write seqNum=%{public}u.", seqNum);
403 return false;
404 }
405 if (!SendRequest(PrivacyInterfaceCode::UPDATE_SEC_COMP_ENHANCE, data, reply)) {
406 return PrivacyError::ERR_SERVICE_ABNORMAL;
407 }
408
409 int32_t result = reply.ReadInt32();
410 LOGI(PRI_DOMAIN, PRI_TAG, "Result=%{public}d", result);
411 return result;
412 }
413
GetSecCompEnhance(int32_t pid,SecCompEnhanceDataParcel & enhanceParcel)414 int32_t PrivacyManagerProxy::GetSecCompEnhance(int32_t pid, SecCompEnhanceDataParcel& enhanceParcel)
415 {
416 MessageParcel data;
417 MessageParcel reply;
418 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
419 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
420 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
421 }
422 if (!data.WriteInt32(pid)) {
423 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteInt32(%{public}d)", pid);
424 return false;
425 }
426 if (!SendRequest(PrivacyInterfaceCode::GET_SEC_COMP_ENHANCE, data, reply)) {
427 return PrivacyError::ERR_SERVICE_ABNORMAL;
428 }
429
430 int32_t result = reply.ReadInt32();
431 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
432 if (result != RET_SUCCESS) {
433 return result;
434 }
435
436 sptr<SecCompEnhanceDataParcel> parcel = reply.ReadParcelable<SecCompEnhanceDataParcel>();
437 if (parcel != nullptr) {
438 enhanceParcel = *parcel;
439 }
440 return result;
441 }
442
GetSpecialSecCompEnhance(const std::string & bundleName,std::vector<SecCompEnhanceDataParcel> & enhanceParcelList)443 int32_t PrivacyManagerProxy::GetSpecialSecCompEnhance(const std::string& bundleName,
444 std::vector<SecCompEnhanceDataParcel>& enhanceParcelList)
445 {
446 MessageParcel data;
447 MessageParcel reply;
448 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
449 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
450 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
451 }
452
453 if (!data.WriteString(bundleName)) {
454 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write string.");
455 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
456 }
457
458 if (!SendRequest(PrivacyInterfaceCode::GET_SPECIAL_SEC_COMP_ENHANCE, data, reply)) {
459 return PrivacyError::ERR_SERVICE_ABNORMAL;
460 }
461
462 int32_t result = reply.ReadInt32();
463 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server data = %{public}d", result);
464 if (result != RET_SUCCESS) {
465 return result;
466 }
467
468 uint32_t size = reply.ReadUint32();
469 if (size > MAX_SEC_COMP_ENHANCE_SIZE) {
470 LOGE(PRI_DOMAIN, PRI_TAG, "Size = %{public}d get from request is invalid", size);
471 return PrivacyError::ERR_OVERSIZE;
472 }
473 for (uint32_t i = 0; i < size; i++) {
474 sptr<SecCompEnhanceDataParcel> parcel = reply.ReadParcelable<SecCompEnhanceDataParcel>();
475 if (parcel != nullptr) {
476 enhanceParcelList.emplace_back(*parcel);
477 }
478 }
479 return result;
480 }
481 #endif
482
GetPermissionUsedTypeInfos(const AccessTokenID tokenId,const std::string & permissionName,std::vector<PermissionUsedTypeInfoParcel> & resultsParcel)483 int32_t PrivacyManagerProxy::GetPermissionUsedTypeInfos(const AccessTokenID tokenId, const std::string& permissionName,
484 std::vector<PermissionUsedTypeInfoParcel>& resultsParcel)
485 {
486 MessageParcel data;
487 MessageParcel reply;
488 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
489 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
490 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
491 }
492 if (!data.WriteUint32(tokenId)) {
493 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", tokenId);
494 return false;
495 }
496 if (!data.WriteString(permissionName)) {
497 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteString(%{public}s)", permissionName.c_str());
498 return false;
499 }
500
501 if (!SendRequest(PrivacyInterfaceCode::GET_PERMISSION_USED_TYPE_INFOS, data, reply)) {
502 return PrivacyError::ERR_SERVICE_ABNORMAL;
503 }
504
505 int32_t result = reply.ReadInt32();
506 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server is %{public}d.", result);
507 if (result != RET_SUCCESS) {
508 return result;
509 }
510
511 uint32_t size = reply.ReadUint32();
512 if (size > MAX_PERMISSION_USED_TYPE_SIZE) {
513 LOGE(PRI_DOMAIN, PRI_TAG, "Failed, results oversize %{public}d, please add query params!", size);
514 return PrivacyError::ERR_OVERSIZE;
515 }
516 for (uint32_t i = 0; i < size; i++) {
517 sptr<PermissionUsedTypeInfoParcel> parcel = reply.ReadParcelable<PermissionUsedTypeInfoParcel>();
518 if (parcel != nullptr) {
519 resultsParcel.emplace_back(*parcel);
520 }
521 }
522 return result;
523 }
524
SetMutePolicy(uint32_t policyType,uint32_t callerType,bool isMute,AccessTokenID tokenID)525 int32_t PrivacyManagerProxy::SetMutePolicy(uint32_t policyType, uint32_t callerType, bool isMute, AccessTokenID tokenID)
526 {
527 MessageParcel data;
528 MessageParcel reply;
529 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
530 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
531 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
532 }
533
534 if (!data.WriteUint32(policyType)) {
535 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", policyType);
536 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
537 }
538 if (!data.WriteUint32(callerType)) {
539 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", callerType);
540 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
541 }
542 if (!data.WriteBool(isMute)) {
543 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteBool(%{public}d)", isMute);
544 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
545 }
546 if (!data.WriteUint32(tokenID)) {
547 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", tokenID);
548 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
549 }
550 if (!SendRequest(PrivacyInterfaceCode::SET_MUTE_POLICY, data, reply)) {
551 return PrivacyError::ERR_SERVICE_ABNORMAL;
552 }
553 int32_t result = reply.ReadInt32();
554 LOGI(PRI_DOMAIN, PRI_TAG, "result from server is %{public}d.", result);
555 return result;
556 }
557
SetHapWithFGReminder(uint32_t tokenId,bool isAllowed)558 int32_t PrivacyManagerProxy::SetHapWithFGReminder(uint32_t tokenId, bool isAllowed)
559 {
560 MessageParcel data;
561 MessageParcel reply;
562 if (!data.WriteInterfaceToken(IPrivacyManager::GetDescriptor())) {
563 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to write WriteInterfaceToken.");
564 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
565 }
566
567 if (!data.WriteUint32(tokenId)) {
568 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteUint32(%{public}d)", tokenId);
569 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
570 }
571
572 if (!data.WriteBool(isAllowed)) {
573 LOGE(PRI_DOMAIN, PRI_TAG, "Failed to WriteBool(%{public}d)", isAllowed);
574 return PrivacyError::ERR_WRITE_PARCEL_FAILED;
575 }
576 if (!SendRequest(PrivacyInterfaceCode::SET_HAP_WITH_FOREGROUND_REMINDER, data, reply)) {
577 return PrivacyError::ERR_SERVICE_ABNORMAL;
578 }
579 int32_t result = reply.ReadInt32();
580 LOGI(PRI_DOMAIN, PRI_TAG, "Result from server is %{public}d.", result);
581 return result;
582 }
583
SendRequest(PrivacyInterfaceCode code,MessageParcel & data,MessageParcel & reply,bool asyncMode)584 bool PrivacyManagerProxy::SendRequest(
585 PrivacyInterfaceCode code, MessageParcel& data, MessageParcel& reply, bool asyncMode)
586 {
587 int flag = 0;
588 if (asyncMode) {
589 flag = static_cast<int>(MessageOption::TF_ASYNC);
590 } else {
591 flag = static_cast<int>(MessageOption::TF_SYNC);
592 }
593 MessageOption option(flag);
594 sptr<IRemoteObject> remote = Remote();
595 if (remote == nullptr) {
596 LOGE(PRI_DOMAIN, PRI_TAG, "Remote service null.");
597 return false;
598 }
599
600 int32_t result = remote->SendRequest(static_cast<uint32_t>(code), data, reply, option);
601 if (result != NO_ERROR) {
602 LOGE(PRI_DOMAIN, PRI_TAG, "SendRequest(code=%{public}d) fail, result: %{public}d", code, result);
603 return false;
604 }
605 return true;
606 }
607 } // namespace AccessToken
608 } // namespace Security
609 } // namespace OHOS
610