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 <gtest/gtest.h>
17
18 #include "accesstoken_kit.h"
19 #include "accesstoken_log.h"
20 #include "audio_manager_privacy_client.h"
21 #include "camera_manager_privacy_client.h"
22 #include "constant.h"
23 #include "perm_active_status_change_callback_stub.h"
24 #define private public
25 #include "active_status_callback_manager.h"
26 #include "permission_record_manager.h"
27 #undef private
28 #include "perm_active_status_change_callback_stub.h"
29 #include "privacy_error.h"
30 #include "privacy_kit.h"
31 #include "state_change_callback.h"
32 #include "token_setproc.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36 using namespace OHOS;
37
38 namespace OHOS {
39 namespace Security {
40 namespace AccessToken {
41 namespace {
42 static AccessTokenID g_selfTokenId = 0;
43 constexpr const char* CAMERA_PERMISSION_NAME = "ohos.permission.CAMERA";
44 constexpr const char* MICROPHONE_PERMISSION_NAME = "ohos.permission.MICROPHONE";
45 constexpr const char* LOCATION_PERMISSION_NAME = "ohos.permission.LOCATION";
46 static constexpr uint32_t MAX_CALLBACK_SIZE = 1024;
47 static PermissionStateFull g_testState1 = {
48 .permissionName = "ohos.permission.CAMERA",
49 .isGeneral = true,
50 .resDeviceID = {"local"},
51 .grantStatus = {PermissionState::PERMISSION_GRANTED},
52 .grantFlags = {1}
53 };
54
55 static PermissionStateFull g_testState2 = {
56 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
57 .isGeneral = true,
58 .resDeviceID = {"local"},
59 .grantStatus = {PermissionState::PERMISSION_GRANTED},
60 .grantFlags = {1}
61 };
62
63 static HapPolicyParams g_PolicyPrams1 = {
64 .apl = APL_NORMAL,
65 .domain = "test.domain.A",
66 .permList = {},
67 .permStateList = {g_testState1, g_testState2}
68 };
69
70 static HapInfoParams g_InfoParms1 = {
71 .userID = 1,
72 .bundleName = "ohos.privacy_test.bundleA",
73 .instIndex = 0,
74 .appIDDesc = "privacy_test.bundleA"
75 };
76
77 static HapPolicyParams g_PolicyPrams2 = {
78 .apl = APL_NORMAL,
79 .domain = "test.domain.B",
80 .permList = {},
81 .permStateList = {g_testState1}
82 };
83
84 static HapInfoParams g_InfoParms2 = {
85 .userID = 1,
86 .bundleName = "ohos.privacy_test.bundleB",
87 .instIndex = 0,
88 .appIDDesc = "privacy_test.bundleB"
89 };
90
91 static PermissionRecord g_recordA1 = {
92 .opCode = Constant::OP_CAMERA,
93 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
94 .timestamp = 0L,
95 .accessDuration = 0L,
96 .accessCount = 1,
97 .rejectCount = 0
98 };
99
100 static PermissionRecord g_recordA2 = {
101 .opCode = Constant::OP_MICROPHONE,
102 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
103 .timestamp = 0L,
104 .accessDuration = 0L,
105 .accessCount = 1,
106 .rejectCount = 0
107 };
108
109 static PermissionRecord g_recordB1 = {
110 .opCode = Constant::OP_CAMERA,
111 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
112 .timestamp = 0L,
113 .accessDuration = 0L,
114 .accessCount = 1,
115 .rejectCount = 0
116 };
117
118 static PermissionRecord g_recordB2 = {
119 .opCode = Constant::OP_MICROPHONE,
120 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
121 .timestamp = 0L,
122 .accessDuration = 0L,
123 .accessCount = 1,
124 .rejectCount = 0
125 };
126 }
127 class PermissionRecordManagerTest : public testing::Test {
128 public:
129 static void SetUpTestCase();
130
131 static void TearDownTestCase();
132
133 void SetUp();
134
135 void TearDown();
136 };
137
SetUpTestCase()138 void PermissionRecordManagerTest::SetUpTestCase()
139 {
140 g_selfTokenId = GetSelfTokenID();
141 }
142
TearDownTestCase()143 void PermissionRecordManagerTest::TearDownTestCase()
144 {
145 }
146
SetUp()147 void PermissionRecordManagerTest::SetUp()
148 {
149 PermissionRecordManager::GetInstance().Register();
150 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
151 AccessTokenKit::AllocHapToken(g_InfoParms2, g_PolicyPrams2);
152 }
153
TearDown()154 void PermissionRecordManagerTest::TearDown()
155 {
156 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
157 g_InfoParms1.instIndex);
158 AccessTokenKit::DeleteToken(tokenId);
159 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
160 g_InfoParms2.instIndex);
161 AccessTokenKit::DeleteToken(tokenId);
162 SetSelfTokenID(g_selfTokenId);
163 }
164
165 class CbCustomizeTest1 : public StateCustomizedCbk {
166 public:
CbCustomizeTest1()167 CbCustomizeTest1()
168 {}
169
~CbCustomizeTest1()170 ~CbCustomizeTest1()
171 {}
172
StateChangeNotify(AccessTokenID tokenId,bool isShow)173 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
174 {}
175
Stop()176 void Stop()
177 {}
178 };
179
180 class CbCustomizeTest2 : public IRemoteObject {
181 public:
CbCustomizeTest2()182 CbCustomizeTest2()
183 {}
184
~CbCustomizeTest2()185 ~CbCustomizeTest2()
186 {}
187 };
188
189
190 /**
191 * @tc.name: RegisterPermActiveStatusCallback001
192 * @tc.desc: RegisterPermActiveStatusCallback with invalid parameter.
193 * @tc.type: FUNC
194 * @tc.require: issueI5RWX8
195 */
196 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback001, TestSize.Level1)
197 {
198 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
199 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
200 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(permList, nullptr));
201 }
202
203
204 class PermActiveStatusChangeCallback : public PermActiveStatusChangeCallbackStub {
205 public:
206 PermActiveStatusChangeCallback() = default;
207 virtual ~PermActiveStatusChangeCallback() = default;
208
ActiveStatusChangeCallback(ActiveChangeResponse & result)209 void ActiveStatusChangeCallback(ActiveChangeResponse& result) {}
210 };
211
212 /**
213 * @tc.name: RegisterPermActiveStatusCallback002
214 * @tc.desc: RegisterPermActiveStatusCallback with exceed limitation.
215 * @tc.type: FUNC
216 * @tc.require: issueI5RWX8
217 */
218 HWTEST_F(PermissionRecordManagerTest, RegisterPermActiveStatusCallback002, TestSize.Level1)
219 {
220 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
221 std::vector<sptr<PermActiveStatusChangeCallback>> callbacks;
222
223 for (size_t i = 0; i < MAX_CALLBACK_SIZE; ++i) {
224 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
225 ASSERT_NE(nullptr, callback);
226 ASSERT_EQ(RET_SUCCESS,
227 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(permList, callback->AsObject()));
228 callbacks.emplace_back(callback);
229 }
230
231 sptr<PermActiveStatusChangeCallback> callback = new (std::nothrow) PermActiveStatusChangeCallback();
232 ASSERT_NE(nullptr, callback);
233 ASSERT_EQ(PrivacyError::ERR_CALLBACKS_EXCEED_LIMITATION,
234 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(permList, callback->AsObject()));
235
236 for (size_t i = 0; i < callbacks.size(); ++i) {
237 ASSERT_EQ(RET_SUCCESS,
238 PermissionRecordManager::GetInstance().UnRegisterPermActiveStatusCallback(callbacks[i]->AsObject()));
239 }
240 }
241
242 /**
243 * @tc.name: UnRegisterPermActiveStatusCallback001
244 * @tc.desc: UnRegisterPermActiveStatusCallback with invalid parameter.
245 * @tc.type: FUNC
246 * @tc.require: issueI5RWX8
247 */
248 HWTEST_F(PermissionRecordManagerTest, UnRegisterPermActiveStatusCallback001, TestSize.Level1)
249 {
250 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
251 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
252 PermissionRecordManager::GetInstance().RegisterPermActiveStatusCallback(permList, nullptr));
253 }
254
255 /*
256 * @tc.name: AppStatusListener001
257 * @tc.desc: register and startusing permissions then use NotifyAppStateChange
258 * @tc.type: FUNC
259 * @tc.require: issueI5SZHG
260 */
261 HWTEST_F(PermissionRecordManagerTest, AppStatusListener001, TestSize.Level1)
262 {
263 AccessTokenID tokenId1 = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
264 g_InfoParms1.instIndex);
265 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
266 AccessTokenID tokenId2 = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
267 g_InfoParms2.instIndex);
268 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId2);
269
270 g_recordA1.tokenId = tokenId1;
271 g_recordA2.tokenId = tokenId1;
272 g_recordB1.tokenId = tokenId2;
273 g_recordB2.tokenId = tokenId2;
274 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(g_recordA1);
275 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(g_recordA2);
276 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(g_recordB1);
277 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(g_recordB2);
278
279 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PERM_ACTIVE_IN_FOREGROUND);
280 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PERM_ACTIVE_IN_FOREGROUND);
281 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PERM_ACTIVE_IN_FOREGROUND);
282 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PERM_ACTIVE_IN_FOREGROUND);
283 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PERM_ACTIVE_IN_BACKGROUND);
284 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PERM_ACTIVE_IN_BACKGROUND);
285 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PERM_ACTIVE_IN_BACKGROUND);
286 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PERM_ACTIVE_IN_BACKGROUND);
287 }
288
289 /*
290 * @tc.name: FindRecordsToUpdateAndExecutedTest001
291 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
292 * @tc.type: FUNC
293 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
294 */
295 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest001, TestSize.Level1)
296 {
297 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
298 g_InfoParms1.instIndex);
299 ASSERT_NE(INVALID_TOKENID, tokenId);
300
301 SetSelfTokenID(tokenId);
302
303 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
304
305 PermissionRecord record1 = {
306 .tokenId = tokenId,
307 .opCode = Constant::OP_CAMERA,
308 };
309
310 CameraManagerPrivacyClient::GetInstance().MuteCamera(false);
311 PermissionRecordManager::GetInstance().AddRecordToStartList(record1);
312 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, false);
313
314 std::vector<std::string> permList;
315 std::vector<std::string> camPermList;
316
317 PermissionRecordManager::GetInstance().FindRecordsToUpdateAndExecuted(tokenId, status, permList, camPermList);
318 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, status);
319
320 PermissionRecord record;
321 PermissionRecordManager::GetInstance().GetRecordFromStartList(record1.tokenId, record1.opCode, record);
322
323 ASSERT_EQ(static_cast<size_t>(1), camPermList.size());
324 ASSERT_EQ(record1.tokenId, tokenId);
325 }
326
327 /*
328 * @tc.name: FindRecordsToUpdateAndExecutedTest002
329 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
330 * @tc.type: FUNC
331 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
332 */
333 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest002, TestSize.Level1)
334 {
335 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
336 g_InfoParms1.instIndex);
337 ASSERT_NE(INVALID_TOKENID, tokenId);
338 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
339
340 PermissionRecord record1 = {
341 .tokenId = tokenId,
342 .opCode = Constant::OP_MICROPHONE,
343 };
344 PermissionRecordManager::GetInstance().AddRecordToStartList(record1);
345 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, false);
346
347 std::vector<std::string> permList;
348 std::vector<std::string> camPermList;
349
350 PermissionRecordManager::GetInstance().FindRecordsToUpdateAndExecuted(tokenId, status, permList, camPermList);
351 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, status);
352
353 PermissionRecord record;
354 PermissionRecordManager::GetInstance().GetRecordFromStartList(record1.tokenId, record1.opCode, record);
355
356 ASSERT_EQ(static_cast<size_t>(0), camPermList.size());
357 ASSERT_EQ(record1.tokenId, tokenId);
358 }
359
360 /*
361 * @tc.name: FindRecordsToUpdateAndExecutedTest003
362 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
363 * @tc.type: FUNC
364 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
365 */
366 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest003, TestSize.Level1)
367 {
368 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
369 g_InfoParms1.instIndex);
370 ASSERT_NE(INVALID_TOKENID, tokenId);
371 ActiveChangeType status = PERM_ACTIVE_IN_FOREGROUND;
372
373 PermissionRecord record1 = {
374 .tokenId = tokenId,
375 .opCode = Constant::OP_CAMERA,
376 };
377 PermissionRecordManager::GetInstance().AddRecordToStartList(record1);
378 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, false);
379
380 std::vector<std::string> permList;
381 std::vector<std::string> camPermList;
382
383 PermissionRecordManager::GetInstance().FindRecordsToUpdateAndExecuted(tokenId, status, permList, camPermList);
384
385 PermissionRecord record;
386 PermissionRecordManager::GetInstance().GetRecordFromStartList(record1.tokenId, record1.opCode, record);
387
388 ASSERT_EQ(static_cast<size_t>(0), camPermList.size());
389 ASSERT_EQ(record1.tokenId, tokenId);
390 }
391
392 /*
393 * @tc.name: FindRecordsToUpdateAndExecutedTest004
394 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
395 * @tc.type: FUNC
396 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
397 */
398 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest004, TestSize.Level1)
399 {
400 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
401 g_InfoParms1.instIndex);
402 ASSERT_NE(INVALID_TOKENID, tokenId);
403 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
404
405 PermissionRecord record1 = {
406 .tokenId = tokenId,
407 .opCode = Constant::OP_CAMERA,
408 };
409 PermissionRecordManager::GetInstance().AddRecordToStartList(record1);
410 PermissionRecordManager::GetInstance().NotifyCameraFloatWindowChange(tokenId, true);
411
412 std::vector<std::string> permList;
413 std::vector<std::string> camPermList;
414
415 PermissionRecordManager::GetInstance().FindRecordsToUpdateAndExecuted(tokenId, status, permList, camPermList);
416
417 PermissionRecord record;
418 PermissionRecordManager::GetInstance().GetRecordFromStartList(record1.tokenId, record1.opCode, record);
419
420 ASSERT_EQ(static_cast<size_t>(0), camPermList.size());
421 ASSERT_EQ(record1.tokenId, tokenId);
422 }
423
424 /*
425 * @tc.name: StartUsingPermissionTest001
426 * @tc.desc: StartUsingPermission function test with invaild tokenId.
427 * @tc.type: FUNC
428 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
429 */
430 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level1)
431 {
432 std::string permissionName = "ohos.permission.CAMERA";
433 auto callbackPtr = std::make_shared<CbCustomizeTest1>();
434 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
435 ASSERT_NE(nullptr, callbackPtr);
436 ASSERT_NE(nullptr, callbackWrap);
437 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
438 g_InfoParms1.instIndex);
439 ASSERT_NE(INVALID_TOKENID, tokenId);
440 ASSERT_EQ(ERR_TOKENID_NOT_EXIST,
441 PermissionRecordManager::GetInstance().StartUsingPermission(0, permissionName, callbackWrap->AsObject()));
442 }
443
444 /*
445 * @tc.name: StartUsingPermissionTest002
446 * @tc.desc: StartUsingPermission function test with invaild permissionName.
447 * @tc.type: FUNC
448 * @tc.require: issueI5RWXF
449 */
450 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest002, TestSize.Level1)
451 {
452 auto callbackPtr = std::make_shared<CbCustomizeTest1>();
453 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
454 ASSERT_NE(nullptr, callbackPtr);
455 ASSERT_NE(nullptr, callbackWrap);
456 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
457 g_InfoParms1.instIndex);
458 ASSERT_NE(INVALID_TOKENID, tokenId);
459 ASSERT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().StartUsingPermission(
460 tokenId, "ohos.permission.LOCATION", callbackWrap->AsObject()));
461 }
462
463 /*
464 * @tc.name: ExecuteCameraCallbackAsyncTest001
465 * @tc.desc: Verify the ExecuteCameraCallbackAsync abnormal branch function test with.
466 * @tc.type: FUNC
467 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
468 */
469 HWTEST_F(PermissionRecordManagerTest, ExecuteCameraCallbackAsyncTest001, TestSize.Level1)
470 {
471 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
472 g_InfoParms1.instIndex);
473 ASSERT_NE(INVALID_TOKENID, tokenId);
474
475 auto callbackPtr = std::make_shared<CbCustomizeTest1>();
476 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
477 ASSERT_NE(nullptr, callbackPtr);
478 ASSERT_NE(nullptr, callbackWrap);
479 PermissionRecordManager::GetInstance().SetCameraCallback(nullptr);
480 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId);
481
482 PermissionRecordManager::GetInstance().SetCameraCallback(callbackWrap->AsObject());
483 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId);
484 }
485
486 /*
487 * @tc.name: GetGlobalSwitchStatus001
488 * @tc.desc: GetGlobalSwitchStatus function test
489 * @tc.type: FUNC
490 * @tc.require: issueI5RWXF
491 */
492 HWTEST_F(PermissionRecordManagerTest, GetGlobalSwitchStatus001, TestSize.Level1)
493 {
494 bool isMuteMic = AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute();
495 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false); // false means open
496 ASSERT_EQ(false, AudioManagerPrivacyClient::GetInstance().IsMicrophoneMute());
497 ASSERT_EQ(true, PermissionRecordManager::GetInstance().GetGlobalSwitchStatus(MICROPHONE_PERMISSION_NAME));
498 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(isMuteMic);
499
500 bool isMuteCam = CameraManagerPrivacyClient::GetInstance().IsCameraMuted();
501 CameraManagerPrivacyClient::GetInstance().MuteCamera(false);
502 ASSERT_EQ(false, CameraManagerPrivacyClient::GetInstance().IsCameraMuted());
503 ASSERT_EQ(true, PermissionRecordManager::GetInstance().GetGlobalSwitchStatus(CAMERA_PERMISSION_NAME));
504 CameraManagerPrivacyClient::GetInstance().MuteCamera(isMuteCam);
505
506 // microphone is not sure
507 ASSERT_EQ(true, PermissionRecordManager::GetInstance().GetGlobalSwitchStatus(LOCATION_PERMISSION_NAME));
508 }
509
510 /*
511 * @tc.name: ShowGlobalDialog001
512 * @tc.desc: ShowGlobalDialog function test
513 * @tc.type: FUNC
514 * @tc.require: issueI5RWXF
515 */
516 HWTEST_F(PermissionRecordManagerTest, ShowGlobalDialog001, TestSize.Level1)
517 {
518 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog(CAMERA_PERMISSION_NAME));
519 sleep(3); // wait for dialog disappear
520 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog(MICROPHONE_PERMISSION_NAME));
521 sleep(3); // wait for dialog disappear
522 ASSERT_EQ(true, PermissionRecordManager::GetInstance().ShowGlobalDialog(LOCATION_PERMISSION_NAME)); // no dialog
523 }
524
525 /*
526 * @tc.name: MicSwitchChangeListener001
527 * @tc.desc: NotifyMicChange function test mic global switch is open
528 * @tc.type: FUNC
529 * @tc.require: issueI5RWXF
530 */
531 HWTEST_F(PermissionRecordManagerTest, MicSwitchChangeListener001, TestSize.Level1)
532 {
533 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false); // false means open
534 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
535 g_InfoParms1.instIndex);
536 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, CAMERA_PERMISSION_NAME));
537
538 PermissionRecordManager::GetInstance().NotifyMicChange(true); // fill opCode not mic branch
539 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, CAMERA_PERMISSION_NAME));
540 }
541
542 /*
543 * @tc.name: MicSwitchChangeListener002
544 * @tc.desc: NotifyMicChange function test mic global switch is open
545 * @tc.type: FUNC
546 * @tc.require: issueI5RWXF
547 */
548 HWTEST_F(PermissionRecordManagerTest, MicSwitchChangeListener002, TestSize.Level1)
549 {
550 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false); // false means open
551 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
552 g_InfoParms1.instIndex);
553 // status is background
554 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
555 PermissionRecordManager::GetInstance().NotifyMicChange(true); // fill true status is not inactive branch
556 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
557 }
558
559 /*
560 * @tc.name: MicSwitchChangeListener003
561 * @tc.desc: NotifyMicChange function test mic global switch is close
562 * @tc.type: FUNC
563 * @tc.require: issueI5RWXF
564 */
565 HWTEST_F(PermissionRecordManagerTest, MicSwitchChangeListener003, TestSize.Level1)
566 {
567 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(true); // true means close
568 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
569 g_InfoParms1.instIndex);
570 // status is inactive
571 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
572 sleep(3); // wait for dialog disappear
573 PermissionRecordManager::GetInstance().NotifyMicChange(true); // fill true status is inactive branch
574 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
575 }
576
577 /*
578 * @tc.name: MicSwitchChangeListener005
579 * @tc.desc: NotifyMicChange function test mic global switch is close
580 * @tc.type: FUNC
581 * @tc.require: issueI5RWXF
582 */
583 HWTEST_F(PermissionRecordManagerTest, MicSwitchChangeListener005, TestSize.Level1)
584 {
585 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(true); // true means close
586 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
587 g_InfoParms1.instIndex);
588 // status is inactive
589 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
590 sleep(3); // wait for dialog disappear
591 PermissionRecordManager::GetInstance().NotifyMicChange(false); // fill false status is inactive branch
592 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, MICROPHONE_PERMISSION_NAME));
593 AudioManagerPrivacyClient::GetInstance().SetMicrophoneMute(false); // false means open
594 }
595
596 /*
597 * @tc.name: TransferOpcodeToPermission001
598 * @tc.desc: Constant::TransferOpcodeToPermission function test return false
599 * @tc.type: FUNC
600 * @tc.require:
601 */
602 HWTEST_F(PermissionRecordManagerTest, TransferOpcodeToPermission001, TestSize.Level1)
603 {
604 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_INVALID);
605 std::string permissionName;
606 ASSERT_EQ(false, Constant::TransferOpcodeToPermission(opCode, permissionName));
607 }
608
609 /*
610 * @tc.name: OnCameraMute001
611 * @tc.desc: CameraServiceCallbackStub::OnCameraMute function test callback_ is null
612 * @tc.type: FUNC
613 * @tc.require:
614 */
615 HWTEST_F(PermissionRecordManagerTest, OnCameraMute001, TestSize.Level1)
616 {
617 bool muteMode = false;
618 ASSERT_EQ(false, muteMode);
619
620 std::shared_ptr<CameraServiceCallbackStub> callback = std::make_shared<CameraServiceCallbackStub>(
621 CameraServiceCallbackStub());
622 callback->OnCameraMute(muteMode);
623 }
624
625 /*
626 * @tc.name: OnMicStateUpdated001
627 * @tc.desc: MicGlobalSwitchChangeCallback::OnMicStateUpdated function test callback_ is null
628 * @tc.type: FUNC
629 * @tc.require:
630 */
631 HWTEST_F(PermissionRecordManagerTest, OnMicStateUpdated001, TestSize.Level1)
632 {
633 MicStateChangeEvent micStateChangeEvent;
634 micStateChangeEvent.mute = false;
635 ASSERT_EQ(false, micStateChangeEvent.mute);
636
637 std::shared_ptr<AudioRoutingManagerListenerStub> callback = std::make_shared<AudioRoutingManagerListenerStub>(
638 AudioRoutingManagerListenerStub());
639 callback->OnMicStateUpdated(micStateChangeEvent);
640 }
641
642 class PermActiveStatusChangeCallbackTest : public PermActiveStatusChangeCallbackStub {
643 public:
644 PermActiveStatusChangeCallbackTest() = default;
645 virtual ~PermActiveStatusChangeCallbackTest() = default;
646
647 void ActiveStatusChangeCallback(ActiveChangeResponse& result) override;
648 };
649
ActiveStatusChangeCallback(ActiveChangeResponse & result)650 void PermActiveStatusChangeCallbackTest::ActiveStatusChangeCallback(ActiveChangeResponse& result)
651 {
652 }
653
654 /*
655 * @tc.name: OnRemoteDied001
656 * @tc.desc: PermActiveStatusCallbackDeathRecipient::OnRemoteDied function test
657 * @tc.type: FUNC
658 * @tc.require:
659 */
660 HWTEST_F(PermissionRecordManagerTest, OnRemoteDied001, TestSize.Level1)
661 {
662 auto recipient = std::make_shared<PermActiveStatusCallbackDeathRecipient>();
663 ASSERT_NE(nullptr, recipient);
664
665 recipient->OnRemoteDied(nullptr); // remote is nullptr
666
667 // backup
668 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
669 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
670
671 std::vector<std::string> permList;
672 sptr<IRemoteObject> callback;
673 permList.emplace_back("ohos.permission.CAMERA");
674 wptr<IRemoteObject> remote = new (std::nothrow) PermActiveStatusChangeCallbackTest();
675 callback = remote.promote();
676 ActiveStatusCallbackManager::GetInstance().AddCallback(permList, callback);
677 ASSERT_EQ(static_cast<uint32_t>(1), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
678 recipient->OnRemoteDied(remote); // remote is not nullptr
679 ASSERT_EQ(static_cast<uint32_t>(0), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
680
681 // recovery
682 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
683 }
684
685 /*
686 * @tc.name: RemoveCallback001
687 * @tc.desc: ActiveStatusCallbackManager::RemoveCallback function test
688 * @tc.type: FUNC
689 * @tc.require:
690 */
691 HWTEST_F(PermissionRecordManagerTest, RemoveCallback001, TestSize.Level1)
692 {
693 std::vector<std::string> permList;
694 sptr<IRemoteObject> callback;
695
696 // callback is null
697 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, ActiveStatusCallbackManager::GetInstance().RemoveCallback(nullptr));
698
699 // backup
700 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
701 sptr<IRemoteObject::DeathRecipient> callbackDeathRecipient =
702 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_;
703 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
704 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = nullptr;
705
706 sptr<PermActiveStatusChangeCallbackTest> callback1 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
707 ASSERT_NE(nullptr, callback1);
708 sptr<PermActiveStatusChangeCallbackTest> callback2 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
709 ASSERT_NE(nullptr, callback2);
710 permList.emplace_back("ohos.permission.CAMERA");
711 callback = callback1->AsObject();
712 CallbackData data;
713 data.permList_ = permList;
714 data.callbackObject_ = callback;
715 ActiveStatusCallbackManager::GetInstance().callbackDataList_.emplace_back(data);
716 // callback != callbackObject_
717 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback2->AsObject()));
718
719 // callback == callbackObject_ + callbackDeathRecipient_ is null
720 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback));
721
722 // recovery
723 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
724 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = callbackDeathRecipient;
725 }
726 } // namespace AccessToken
727 } // namespace Security
728 } // namespace OHOS
729