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 <cstdint>
17 #include <gtest/gtest.h>
18
19 #include "access_token.h"
20 #include "accesstoken_kit.h"
21 #include "accesstoken_log.h"
22 #include "audio_manager_privacy_client.h"
23 #include "camera_manager_privacy_client.h"
24 #include "constant.h"
25 #include "data_translator.h"
26 #include "permission_record.h"
27 #define private public
28 #include "active_status_callback_manager.h"
29 #include "permission_record_manager.h"
30 #include "permission_used_record_db.h"
31 #undef private
32 #include "perm_active_status_change_callback_stub.h"
33 #include "privacy_error.h"
34 #include "privacy_field_const.h"
35 #include "privacy_kit.h"
36 #include "state_change_callback.h"
37 #include "time_util.h"
38 #include "token_setproc.h"
39
40 using namespace testing;
41 using namespace testing::ext;
42 using namespace OHOS;
43
44 namespace OHOS {
45 namespace Security {
46 namespace AccessToken {
47 namespace {
48 static int32_t PID = -1;
49 static AccessTokenID g_selfTokenId = 0;
50 static AccessTokenID g_nativeToken = 0;
51 static constexpr int32_t MAX_DETAIL_NUM = 500;
52 static constexpr int64_t ONE_SECOND = 1000;
53 static constexpr int64_t TWO_SECOND = 2000;
54 static constexpr int64_t THREE_SECOND = 3000;
55 static constexpr int32_t PERMISSION_USED_TYPE_VALUE = 1;
56 static constexpr int32_t PERMISSION_USED_TYPE_WITH_PICKER_TYPE_VALUE = 3;
57 static constexpr int32_t RANDOM_TOKENID = 123;
58 static PermissionStateFull g_testState1 = {
59 .permissionName = "ohos.permission.CAMERA",
60 .isGeneral = true,
61 .resDeviceID = {"local"},
62 .grantStatus = {PermissionState::PERMISSION_GRANTED},
63 .grantFlags = {1}
64 };
65
66 static PermissionStateFull g_testState2 = {
67 .permissionName = "ohos.permission.MANAGE_CAMERA_CONFIG",
68 .isGeneral = true,
69 .resDeviceID = {"local"},
70 .grantStatus = {PermissionState::PERMISSION_GRANTED},
71 .grantFlags = {1}
72 };
73
74 static HapPolicyParams g_PolicyPrams1 = {
75 .apl = APL_NORMAL,
76 .domain = "test.domain.A",
77 .permList = {},
78 .permStateList = {g_testState1, g_testState2}
79 };
80
81 static HapInfoParams g_InfoParms1 = {
82 .userID = 1,
83 .bundleName = "ohos.privacy_test.bundleA",
84 .instIndex = 0,
85 .appIDDesc = "privacy_test.bundleA"
86 };
87
88 static HapPolicyParams g_PolicyPrams2 = {
89 .apl = APL_NORMAL,
90 .domain = "test.domain.B",
91 .permList = {},
92 .permStateList = {g_testState1}
93 };
94
95 static HapInfoParams g_InfoParms2 = {
96 .userID = 1,
97 .bundleName = "ohos.privacy_test.bundleB",
98 .instIndex = 0,
99 .appIDDesc = "privacy_test.bundleB"
100 };
101 }
102 class PermissionRecordManagerTest : public testing::Test {
103 public:
104 static void SetUpTestCase();
105
106 static void TearDownTestCase();
107
108 void SetUp();
109
110 void TearDown();
111 };
112
SetUpTestCase()113 void PermissionRecordManagerTest::SetUpTestCase()
114 {
115 g_selfTokenId = GetSelfTokenID();
116 g_nativeToken = AccessTokenKit::GetNativeTokenId("privacy_service");
117 }
118
TearDownTestCase()119 void PermissionRecordManagerTest::TearDownTestCase() {}
120
SetUp()121 void PermissionRecordManagerTest::SetUp()
122 {
123 PermissionRecordManager::GetInstance().Register();
124
125 AccessTokenKit::AllocHapToken(g_InfoParms1, g_PolicyPrams1);
126 AccessTokenKit::AllocHapToken(g_InfoParms2, g_PolicyPrams2);
127 }
128
TearDown()129 void PermissionRecordManagerTest::TearDown()
130 {
131 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
132 g_InfoParms1.instIndex);
133 AccessTokenKit::DeleteToken(tokenId);
134 tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
135 g_InfoParms2.instIndex);
136 AccessTokenKit::DeleteToken(tokenId);
137 EXPECT_EQ(0, SetSelfTokenID(g_selfTokenId));
138 }
139
140 class PermissionRecordManagerCoverTestCb1 : public StateCustomizedCbk {
141 public:
PermissionRecordManagerCoverTestCb1()142 PermissionRecordManagerCoverTestCb1()
143 {}
144
~PermissionRecordManagerCoverTestCb1()145 ~PermissionRecordManagerCoverTestCb1()
146 {}
147
StateChangeNotify(AccessTokenID tokenId,bool isShow)148 virtual void StateChangeNotify(AccessTokenID tokenId, bool isShow)
149 {}
150
Stop()151 void Stop()
152 {}
153 };
154
155 class PermissionRecordManagerCoverTestCb2 : public IRemoteObject {
156 public:
PermissionRecordManagerCoverTestCb2()157 PermissionRecordManagerCoverTestCb2()
158 {}
159
~PermissionRecordManagerCoverTestCb2()160 ~PermissionRecordManagerCoverTestCb2()
161 {}
162 };
163
164 /**
165 * @tc.name: OnAppStateChanged001
166 * @tc.desc: RegisterPermActiveStatusCallback with invalid parameter.
167 * @tc.type: FUNC
168 * @tc.require: issueI5RWX8
169 */
170 HWTEST_F(PermissionRecordManagerTest, OnAppStateChanged001, TestSize.Level1)
171 {
172 PrivacyAppStateObserver observer;
173 AppStateData appStateData;
174 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_FOREGROUND);
175 observer.OnAppStateChanged(appStateData);
176 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND);
177 observer.OnAppStateChanged(appStateData);
178 ASSERT_EQ(static_cast<int32_t>(ApplicationState::APP_STATE_BACKGROUND), appStateData.state);
179 }
180
181 /*
182 * @tc.name: AppStatusListener001
183 * @tc.desc: register and startusing permissions then use NotifyAppStateChange
184 * @tc.type: FUNC
185 * @tc.require: issueI5SZHG
186 */
187 HWTEST_F(PermissionRecordManagerTest, AppStatusListener001, TestSize.Level1)
188 {
189 AccessTokenID tokenId1 = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
190 g_InfoParms1.instIndex);
191 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId1);
192 AccessTokenID tokenId2 = AccessTokenKit::GetHapTokenID(g_InfoParms2.userID, g_InfoParms2.bundleName,
193 g_InfoParms2.instIndex);
194 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId2);
195
196 ContinusPermissionRecord recordA1 = {
197 .tokenId = tokenId1,
198 .opCode = Constant::OP_CAMERA,
199 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
200 };
201
202 ContinusPermissionRecord recordA2 = {
203 .tokenId = tokenId1,
204 .opCode = Constant::OP_MICROPHONE,
205 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
206 };
207
208 ContinusPermissionRecord recordB1 = {
209 .tokenId = tokenId2,
210 .opCode = Constant::OP_CAMERA,
211 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
212 };
213
214 ContinusPermissionRecord recordB2 = {
215 .tokenId = tokenId2,
216 .opCode = Constant::OP_MICROPHONE,
217 .status = ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND,
218 };
219
220 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(recordA1);
221 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(recordA2);
222 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(recordB1);
223 PermissionRecordManager::GetInstance().startRecordList_.emplace_back(recordB2);
224
225 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_FOREGROUND);
226 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_FOREGROUND);
227 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_FOREGROUND);
228 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_FOREGROUND);
229 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_BACKGROUND);
230 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_BACKGROUND);
231 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId1, PID, PERM_ACTIVE_IN_BACKGROUND);
232 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId2, PID, PERM_ACTIVE_IN_BACKGROUND);
233 }
234
235 /*
236 * @tc.name: FindRecordsToUpdateAndExecutedTest001
237 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
238 * @tc.type: FUNC
239 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
240 */
241 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest001, TestSize.Level1)
242 {
243 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
244 g_InfoParms1.instIndex);
245 ASSERT_NE(INVALID_TOKENID, tokenId);
246
247 EXPECT_EQ(0, SetSelfTokenID(tokenId));
248
249 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
250 std::string permission = "ohos.permission.CAMERA";
251 CameraManagerPrivacyClient::GetInstance().MuteCameraPersist(PolicyType::PRIVACY, false);
252 PermissionRecordManager::GetInstance().AddRecordToStartList(tokenId, PID, permission, status);
253 #ifdef CAMERA_FLOAT_WINDOW_ENABLE
254 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(false, tokenId, false);
255 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(true, tokenId, false);
256 #endif
257 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
258 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, status);
259
260 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, permission));
261 }
262
263 /*
264 * @tc.name: FindRecordsToUpdateAndExecutedTest002
265 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
266 * @tc.type: FUNC
267 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
268 */
269 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest002, TestSize.Level1)
270 {
271 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
272 g_InfoParms1.instIndex);
273 ASSERT_NE(INVALID_TOKENID, tokenId);
274 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
275 std::string permission = "ohos.permission.MICROPHONE";
276 PermissionRecordManager::GetInstance().AddRecordToStartList(tokenId, PID, permission, status);
277 #ifdef CAMERA_FLOAT_WINDOW_ENABLE
278 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(false, tokenId, false);
279 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(true, tokenId, false);
280 #endif
281 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
282 PermissionRecordManager::GetInstance().NotifyAppStateChange(tokenId, PID, status);
283
284 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, permission));
285 }
286
287 /*
288 * @tc.name: FindRecordsToUpdateAndExecutedTest003
289 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
290 * @tc.type: FUNC
291 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
292 */
293 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest003, TestSize.Level1)
294 {
295 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
296 g_InfoParms1.instIndex);
297 ASSERT_NE(INVALID_TOKENID, tokenId);
298 ActiveChangeType status = PERM_ACTIVE_IN_FOREGROUND;
299 std::string permission = "ohos.permission.CAMERA";
300 PermissionRecordManager::GetInstance().AddRecordToStartList(tokenId, PID, permission, status);
301 #ifdef CAMERA_FLOAT_WINDOW_ENABLE
302 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(false, tokenId, false);
303 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(true, tokenId, false);
304 #endif
305 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
306
307 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, permission));
308 }
309
310 /*
311 * @tc.name: FindRecordsToUpdateAndExecutedTest004
312 * @tc.desc: FindRecordsToUpdateAndExecuted function test with invaild tokenId or permissionName or callback.
313 * @tc.type: FUNC
314 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
315 */
316 HWTEST_F(PermissionRecordManagerTest, FindRecordsToUpdateAndExecutedTest004, TestSize.Level1)
317 {
318 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
319 g_InfoParms1.instIndex);
320 ASSERT_NE(INVALID_TOKENID, tokenId);
321 ActiveChangeType status = PERM_ACTIVE_IN_BACKGROUND;
322 std::string permission = "ohos.permission.CAMERA";
323 PermissionRecordManager::GetInstance().AddRecordToStartList(tokenId, PID, permission, status);
324 #ifdef CAMERA_FLOAT_WINDOW_ENABLE
325 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(false, tokenId, false);
326 PermissionRecordManager::GetInstance().NotifyCameraWindowChange(true, tokenId, false);
327 #endif
328 PermissionRecordManager::GetInstance().ExecuteAndUpdateRecord(tokenId, PID, status);
329
330 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, permission));
331 }
332
333 /*
334 * @tc.name: ExecuteCameraCallbackAsyncTest001
335 * @tc.desc: Verify the ExecuteCameraCallbackAsync abnormal branch function test with.
336 * @tc.type: FUNC
337 * @tc.require: issueI5RWX5 issueI5RWX3 issueI5RWXA
338 */
339 HWTEST_F(PermissionRecordManagerTest, ExecuteCameraCallbackAsyncTest001, TestSize.Level1)
340 {
341 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
342 g_InfoParms1.instIndex);
343 ASSERT_NE(INVALID_TOKENID, tokenId);
344
345 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb1>();
346 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
347 ASSERT_NE(nullptr, callbackPtr);
348 ASSERT_NE(nullptr, callbackWrap);
349 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId, PID);
350
351 PermissionRecordManager::GetInstance().ExecuteCameraCallbackAsync(tokenId, PID);
352 }
353
354 class PermActiveStatusChangeCallbackTest : public PermActiveStatusChangeCallbackStub {
355 public:
356 PermActiveStatusChangeCallbackTest() = default;
357 virtual ~PermActiveStatusChangeCallbackTest() = default;
358
359 void ActiveStatusChangeCallback(ActiveChangeResponse& result) override;
360 };
361
ActiveStatusChangeCallback(ActiveChangeResponse & result)362 void PermActiveStatusChangeCallbackTest::ActiveStatusChangeCallback(ActiveChangeResponse& result)
363 {
364 }
365
366 class PermissionRecordManagerCoverTestCb3 : public PermActiveStatusCustomizedCbk {
367 public:
PermissionRecordManagerCoverTestCb3(const std::vector<std::string> & permList)368 explicit PermissionRecordManagerCoverTestCb3(const std::vector<std::string> &permList)
369 : PermActiveStatusCustomizedCbk(permList)
370 {
371 GTEST_LOG_(INFO) << "PermissionRecordManagerCoverTestCb3 create";
372 }
373
~PermissionRecordManagerCoverTestCb3()374 ~PermissionRecordManagerCoverTestCb3()
375 {}
376
ActiveStatusChangeCallback(ActiveChangeResponse & result)377 virtual void ActiveStatusChangeCallback(ActiveChangeResponse& result)
378 {
379 type_ = result.type;
380 }
381
382 ActiveChangeType type_ = PERM_INACTIVE;
383 };
384 /*
385 * @tc.name: OnRemoteDied001
386 * @tc.desc: PermActiveStatusCallbackDeathRecipient::OnRemoteDied function test
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(PermissionRecordManagerTest, OnRemoteDied001, TestSize.Level1)
391 {
392 auto recipient = std::make_shared<PermActiveStatusCallbackDeathRecipient>();
393 ASSERT_NE(nullptr, recipient);
394
395 recipient->OnRemoteDied(nullptr); // remote is nullptr
396
397 // backup
398 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
399 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
400
401 std::vector<std::string> permList;
402 sptr<IRemoteObject> callback;
403 permList.emplace_back("ohos.permission.CAMERA");
404 wptr<IRemoteObject> remote = new (std::nothrow) PermActiveStatusChangeCallbackTest();
405 callback = remote.promote();
406 ActiveStatusCallbackManager::GetInstance().AddCallback(GetSelfTokenID(), permList, callback);
407 ASSERT_EQ(static_cast<uint32_t>(1), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
408 recipient->OnRemoteDied(remote); // remote is not nullptr
409 ASSERT_EQ(static_cast<uint32_t>(0), ActiveStatusCallbackManager::GetInstance().callbackDataList_.size());
410
411 // recovery
412 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
413 }
414
415 /**
416 * @tc.name: OnAppStopped001
417 * @tc.desc: Test app state changed to APP_STATE_TERMINATED.
418 * @tc.type: FUNC
419 * @tc.require:
420 */
421 HWTEST_F(PermissionRecordManagerTest, OnAppStopped001, TestSize.Level1)
422 {
423 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
424 g_InfoParms1.instIndex);
425 ASSERT_NE(INVALID_TOKENID, tokenId);
426
427 PrivacyAppStateObserver observer;
428 std::vector<std::string> permList = {"ohos.permission.CAMERA"};
429
430 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb3>(permList);
431 callbackPtr->type_ = PERM_ACTIVE_IN_FOREGROUND;
432
433 ASSERT_EQ(RET_SUCCESS, PrivacyKit::RegisterPermActiveStatusCallback(callbackPtr));
434 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StartUsingPermission(tokenId, "ohos.permission.CAMERA"));
435 AppStateData appStateData;
436 appStateData.state = static_cast<int32_t>(ApplicationState::APP_STATE_TERMINATED);
437 appStateData.accessTokenId = tokenId;
438 observer.OnAppStopped(appStateData);
439
440 usleep(500000); // 500000us = 0.5s
441 ASSERT_EQ(PERM_ACTIVE_IN_BACKGROUND, callbackPtr->type_);
442
443 ASSERT_EQ(RET_SUCCESS, PrivacyKit::StopUsingPermission(tokenId, "ohos.permission.CAMERA"));
444 }
445
446 /*
447 * @tc.name: RemoveCallback001
448 * @tc.desc: ActiveStatusCallbackManager::RemoveCallback function test
449 * @tc.type: FUNC
450 * @tc.require:
451 */
452 HWTEST_F(PermissionRecordManagerTest, RemoveCallback001, TestSize.Level1)
453 {
454 std::vector<std::string> permList;
455 sptr<IRemoteObject> callback;
456
457 // callback is null
458 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID, ActiveStatusCallbackManager::GetInstance().RemoveCallback(nullptr));
459
460 // backup
461 std::vector<CallbackData> callbackDataList = ActiveStatusCallbackManager::GetInstance().callbackDataList_;
462 sptr<IRemoteObject::DeathRecipient> callbackDeathRecipient =
463 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_;
464 ActiveStatusCallbackManager::GetInstance().callbackDataList_.clear();
465 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = nullptr;
466
467 sptr<PermActiveStatusChangeCallbackTest> callback1 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
468 ASSERT_NE(nullptr, callback1);
469 sptr<PermActiveStatusChangeCallbackTest> callback2 = new (std::nothrow) PermActiveStatusChangeCallbackTest();
470 ASSERT_NE(nullptr, callback2);
471 permList.emplace_back("ohos.permission.CAMERA");
472 callback = callback1->AsObject();
473 CallbackData data;
474 data.permList_ = permList;
475 data.callbackObject_ = callback;
476 ActiveStatusCallbackManager::GetInstance().callbackDataList_.emplace_back(data);
477 // callback != callbackObject_
478 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback2->AsObject()));
479
480 // callback == callbackObject_ + callbackDeathRecipient_ is null
481 ASSERT_EQ(RET_SUCCESS, ActiveStatusCallbackManager::GetInstance().RemoveCallback(callback));
482
483 // recovery
484 ActiveStatusCallbackManager::GetInstance().callbackDataList_ = callbackDataList;
485 ActiveStatusCallbackManager::GetInstance().callbackDeathRecipient_ = callbackDeathRecipient;
486 }
487
488 /*
489 * @tc.name: UpdateRecords001
490 * @tc.desc: PermissionRecordManager::UpdateRecords function test
491 * @tc.type: FUNC
492 * @tc.require:
493 */
494 HWTEST_F(PermissionRecordManagerTest, UpdateRecords001, TestSize.Level1)
495 {
496 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
497 g_InfoParms1.instIndex);
498 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
499
500 PermissionUsageFlag flag = FLAG_PERMISSION_USAGE_SUMMARY;
501 PermissionUsedRecord inBundleRecord;
502 PermissionUsedRecord outBundleRecord;
503
504 inBundleRecord.lastAccessTime = 1000;
505 outBundleRecord.lastAccessTime = 900;
506 // inBundleRecord.lastAccessTime > outBundleRecord.lastAccessTime && flag == 0
507 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
508
509 UsedRecordDetail detail;
510 detail.accessDuration = 10;
511 detail.status = PERM_ACTIVE_IN_FOREGROUND;
512 detail.timestamp = 10000;
513 flag = FLAG_PERMISSION_USAGE_DETAIL;
514 inBundleRecord.lastRejectTime = 1000;
515 inBundleRecord.accessRecords.emplace_back(detail);
516 inBundleRecord.rejectRecords.emplace_back(detail);
517 // flag != 0 && inBundleRecord.lastRejectTime > 0 && outBundleRecord.accessRecords.size() < 10
518 // && inBundleRecord.lastRejectTime > 0 && outBundleRecord.rejectRecords.size() < 10
519 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
520
521 std::vector<UsedRecordDetail> accessRecords(11, detail);
522 outBundleRecord.accessRecords = accessRecords;
523 outBundleRecord.rejectRecords = accessRecords;
524 // flag != 0 && inBundleRecord.lastRejectTime > 0 && outBundleRecord.accessRecords.size() >= 10
525 // && inBundleRecord.lastRejectTime > 0 && outBundleRecord.rejectRecords.size() >= 10
526 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
527
528 inBundleRecord.lastAccessTime = 0;
529 inBundleRecord.lastRejectTime = 0;
530 // flag != 0 && inBundleRecord.lastRejectTime <= 0 && outBundleRecord.accessRecords.size() >= 10
531 // && inBundleRecord.lastRejectTime <= 0 && outBundleRecord.rejectRecords.size() >= 10
532 PermissionRecordManager::GetInstance().MergeSamePermission(flag, inBundleRecord, outBundleRecord);
533 }
534
535 /*
536 * @tc.name: RemoveRecordFromStartList001
537 * @tc.desc: PermissionRecordManager::RemoveRecordFromStartList function test
538 * @tc.type: FUNC
539 * @tc.require:
540 */
541 HWTEST_F(PermissionRecordManagerTest, RemoveRecordFromStartList001, TestSize.Level1)
542 {
543 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
544 g_InfoParms1.instIndex);
545 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
546
547 std::string permission = "ohos.permission.READ_MEDIA";
548 ASSERT_EQ(Constant::SUCCESS,
549 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
550 // it->opcode == record.opcode && it->tokenId == record.tokenId
551 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, "ohos.permission.READ_MEDIA");
552
553 ASSERT_EQ(Constant::SUCCESS,
554 PermissionRecordManager::GetInstance().StartUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
555 // it->opcode == record.opcode && it->tokenId != record.tokenId
556 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(RANDOM_TOKENID, PID, "ohos.permission.READ_MEDIA");
557
558 // it->opcode != record.opcode && it->tokenId != record.tokenId
559 PermissionRecordManager::GetInstance().RemoveRecordFromStartList(tokenId, PID, "ohos.permission.MICROPHONE");
560
561 ASSERT_EQ(Constant::SUCCESS,
562 PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.READ_MEDIA"));
563 }
564
565 /*
566 * @tc.name: PermissionListFilter001
567 * @tc.desc: PermissionRecordManager::PermissionListFilter function test
568 * @tc.type: FUNC
569 * @tc.require:
570 */
571 HWTEST_F(PermissionRecordManagerTest, PermissionListFilter001, TestSize.Level1)
572 {
573 std::vector<std::string> listSrc;
574 std::vector<std::string> listRes;
575
576 listSrc.emplace_back("com.ohos.TEST");
577 // GetDefPermission != Constant::SUCCESS && listRes is empty && listSrc is not empty
578 ASSERT_EQ(PrivacyError::ERR_PARAM_INVALID,
579 PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
580
581 listRes.emplace_back("com.ohos.TEST");
582 // listRes is not empty
583 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
584
585 listSrc.clear();
586 listRes.clear();
587 // listRes is empty && listSrc is empty
588 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().PermissionListFilter(listSrc, listRes));
589 }
590
591 /*
592 * @tc.name: Unregister001
593 * @tc.desc: PermissionRecordManager::Unregister function test
594 * @tc.type: FUNC
595 * @tc.require:
596 */
597 HWTEST_F(PermissionRecordManagerTest, Unregister001, TestSize.Level1)
598 {
599 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
600 g_InfoParms1.instIndex);
601 ASSERT_NE(static_cast<AccessTokenID>(0), tokenId);
602
603 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
604 tokenId, PID, "ohos.permission.READ_MEDIA"));
605
606 PermissionRecordManager::GetInstance().Unregister();
607 PermissionRecordManager::GetInstance().Unregister();
608
609 ASSERT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().StopUsingPermission(
610 tokenId, PID, "ohos.permission.READ_MEDIA"));
611 }
612
613 /*
614 * @tc.name: TranslationIntoPermissionRecord001
615 * @tc.desc: PermissionRecord::TranslationIntoPermissionRecord function test
616 * @tc.type: FUNC
617 * @tc.require:
618 */
619 HWTEST_F(PermissionRecordManagerTest, TranslationIntoPermissionRecord001, TestSize.Level1)
620 {
621 GenericValues values;
622 values.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(10086));
623 values.Put(PrivacyFiledConst::FIELD_OP_CODE, 0);
624 values.Put(PrivacyFiledConst::FIELD_STATUS, 0);
625 values.Put(PrivacyFiledConst::FIELD_TIMESTAMP, static_cast<int64_t>(20210109));
626 values.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, static_cast<int64_t>(1));
627 values.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 10);
628 values.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 100);
629 values.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
630 PermissionRecord record;
631 PermissionRecord::TranslationIntoPermissionRecord(values, record);
632 ASSERT_EQ(static_cast<int32_t>(10086), record.tokenId);
633 ASSERT_EQ(10, record.accessCount);
634 ASSERT_EQ(100, record.rejectCount);
635 ASSERT_EQ(static_cast<int64_t>(20210109), record.timestamp);
636 ASSERT_EQ(static_cast<int64_t>(1), record.accessDuration);
637 ASSERT_EQ(LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED, record.lockScreenStatus);
638 }
639
AddRecord(int32_t num,std::vector<GenericValues> & values)640 void AddRecord(int32_t num, std::vector<GenericValues>& values)
641 {
642 for (int32_t i = 0; i < num; i++) {
643 GenericValues value;
644 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, i);
645 value.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_LOCATION);
646 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND);
647 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, i);
648 value.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, i);
649 value.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
650 value.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
651 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
652 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
653 values.emplace_back(value);
654 }
655
656 ASSERT_EQ(static_cast<size_t>(num), values.size());
657 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
658 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
659 sleep(1); // wait record store in database
660 }
661
662 /**
663 * @tc.name: GetRecords002
664 * @tc.desc: test query record return max count 500.
665 * @tc.type: FUNC
666 * @tc.require: issueI5P4IU
667 */
668 HWTEST_F(PermissionRecordManagerTest, GetRecords002, TestSize.Level1)
669 {
670 std::vector<GenericValues> values;
671 int32_t num = MAX_DETAIL_NUM + 1;
672 AddRecord(num, values);
673
674 PermissionUsedRequest request;
675 request.isRemote = false;
676 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_DETAIL;
677
678 std::set<int32_t> opCodeList;
679 GenericValues andConditionValues;
680 std::vector<GenericValues> findRecordsValues;
681 PermissionUsedRecordDb::GetInstance().FindByConditions(PermissionUsedRecordDb::DataType::PERMISSION_RECORD,
682 opCodeList, andConditionValues, findRecordsValues, MAX_DETAIL_NUM);
683 EXPECT_EQ(static_cast<size_t>(MAX_DETAIL_NUM), findRecordsValues.size());
684
685 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
686 for (const auto& value : values) {
687 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value));
688 }
689 }
690
GeneratePermissionRecord(AccessTokenID tokenID)691 static void GeneratePermissionRecord(AccessTokenID tokenID)
692 {
693 int64_t timestamp = AccessToken::TimeUtil::GetCurrentTimestamp();
694
695 std::vector<GenericValues> values;
696 GenericValues value;
697 value.Put(PrivacyFiledConst::FIELD_TOKEN_ID, static_cast<int32_t>(tokenID));
698 value.Put(PrivacyFiledConst::FIELD_OP_CODE, Constant::OP_LOCATION);
699 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_BACKGROUND);
700 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - THREE_SECOND);
701 value.Put(PrivacyFiledConst::FIELD_ACCESS_DURATION, 1);
702 value.Put(PrivacyFiledConst::FIELD_ACCESS_COUNT, 1);
703 value.Put(PrivacyFiledConst::FIELD_REJECT_COUNT, 0);
704 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
705 value.Put(PrivacyFiledConst::FIELD_USED_TYPE, static_cast<int>(PermissionUsedType::NORMAL_TYPE));
706 values.emplace_back(value); // background + unlock + normal
707
708 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
709 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - TWO_SECOND);
710 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
711 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
712 values.emplace_back(value); // background + lock + normal
713
714 value.Remove(PrivacyFiledConst::FIELD_STATUS);
715 value.Put(PrivacyFiledConst::FIELD_STATUS, ActiveChangeType::PERM_ACTIVE_IN_FOREGROUND);
716 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
717 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp - ONE_SECOND);
718 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
719 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_UNLOCKED);
720 values.emplace_back(value); // foreground + unlock + normal
721
722 value.Remove(PrivacyFiledConst::FIELD_TIMESTAMP);
723 value.Put(PrivacyFiledConst::FIELD_TIMESTAMP, timestamp);
724 value.Remove(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS);
725 value.Put(PrivacyFiledConst::FIELD_LOCKSCREEN_STATUS, LockScreenStatusChangeType::PERM_ACTIVE_IN_LOCKED);
726 values.emplace_back(value); // foreground + lock + normal
727
728 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
729 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Add(type, values));
730 sleep(1); // wait record store in database
731 }
732
733 /**
734 * @tc.name: GetRecords003
735 * @tc.desc: test query record flag 2 | 3 | 4 | 5
736 * @tc.type: FUNC
737 * @tc.require:
738 */
739 HWTEST_F(PermissionRecordManagerTest, GetRecords003, TestSize.Level1)
740 {
741 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
742 g_InfoParms1.instIndex);
743 ASSERT_NE(static_cast<AccessTokenID>(0), tokenID);
744
745 GeneratePermissionRecord(tokenID);
746 PermissionRecordManager::GetInstance().SetDefaultConfigValue();
747
748 PermissionUsedRequest request;
749 request.tokenId = tokenID;
750 request.isRemote = false;
751 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
752
753 PermissionUsedResult result1;
754 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result1));
755 EXPECT_EQ(static_cast<size_t>(1), result1.bundleRecords.size());
756 EXPECT_EQ(static_cast<uint32_t>(tokenID), result1.bundleRecords[0].tokenId);
757 EXPECT_EQ(static_cast<size_t>(1), result1.bundleRecords[0].permissionRecords.size());
758 EXPECT_EQ(2, result1.bundleRecords[0].permissionRecords[0].accessCount);
759
760 PermissionUsedResult result2;
761 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_UNLOCKED;
762 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result2));
763 EXPECT_EQ(static_cast<size_t>(1), result2.bundleRecords.size());
764 EXPECT_EQ(static_cast<uint32_t>(tokenID), result2.bundleRecords[0].tokenId);
765 EXPECT_EQ(static_cast<size_t>(1), result2.bundleRecords[0].permissionRecords.size());
766 EXPECT_EQ(2, result2.bundleRecords[0].permissionRecords[0].accessCount);
767
768 PermissionUsedResult result3;
769 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_FOREGROUND;
770 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result3));
771 EXPECT_EQ(static_cast<size_t>(1), result3.bundleRecords.size());
772 EXPECT_EQ(static_cast<uint32_t>(tokenID), result3.bundleRecords[0].tokenId);
773 EXPECT_EQ(static_cast<size_t>(1), result3.bundleRecords[0].permissionRecords.size());
774 EXPECT_EQ(2, result3.bundleRecords[0].permissionRecords[0].accessCount);
775
776 PermissionUsedResult result4;
777 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_APP_BACKGROUND;
778 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result4));
779 EXPECT_EQ(static_cast<size_t>(1), result4.bundleRecords.size());
780 EXPECT_EQ(static_cast<uint32_t>(tokenID), result4.bundleRecords[0].tokenId);
781 EXPECT_EQ(static_cast<size_t>(1), result4.bundleRecords[0].permissionRecords.size());
782 EXPECT_EQ(2, result4.bundleRecords[0].permissionRecords[0].accessCount);
783 }
784
785 /**
786 * @tc.name: GetRecords004
787 * @tc.desc: test query record from local dd failed
788 * @tc.type: FUNC
789 * @tc.require:
790 */
791 HWTEST_F(PermissionRecordManagerTest, GetRecords004, TestSize.Level1)
792 {
793 AccessTokenID tokenID = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
794 g_InfoParms1.instIndex);
795 ASSERT_NE(static_cast<AccessTokenID>(0), tokenID);
796
797 GeneratePermissionRecord(tokenID);
798 PermissionRecordManager::GetInstance().SetDefaultConfigValue();
799
800 PermissionUsedRequest request;
801 request.tokenId = tokenID;
802 request.isRemote = false;
803 request.beginTimeMillis = -1;
804
805 PermissionUsedResult result;
806 EXPECT_EQ(ERR_PARAM_INVALID, PermissionRecordManager::GetInstance().GetPermissionUsedRecords(request, result));
807 }
808
809 /**
810 * @tc.name: GetRecordsFromLocalDBTest001
811 * @tc.desc: test GetRecordsFromLocalDB: token = 0
812 * @tc.type: FUNC
813 * @tc.require:
814 */
815 HWTEST_F(PermissionRecordManagerTest, GetRecordsFromLocalDBTest001, TestSize.Level1)
816 {
817 PermissionUsedRequest request;
818 request.tokenId = 0;
819 request.isRemote = false;
820 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
821 PermissionUsedResult result;
822 EXPECT_TRUE(PermissionRecordManager::GetInstance().GetRecordsFromLocalDB(request, result));
823 }
824
825 /**
826 * @tc.name: GetRecordsFromLocalDBTest002
827 * @tc.desc: test GetRecordsFromLocalDB: beginTimeMillis = -1
828 * @tc.type: FUNC
829 * @tc.require:
830 */
831 HWTEST_F(PermissionRecordManagerTest, GetRecordsFromLocalDBTest002, TestSize.Level1)
832 {
833 PermissionUsedRequest request;
834 request.tokenId = g_selfTokenId;
835 request.isRemote = false;
836 request.flag = PermissionUsageFlag::FLAG_PERMISSION_USAGE_SUMMARY_IN_SCREEN_LOCKED;
837 request.beginTimeMillis = -1; // -1 is a invalid input
838 PermissionUsedResult result;
839 EXPECT_EQ(false, PermissionRecordManager::GetInstance().GetRecordsFromLocalDB(request, result));
840 }
841
842 /*
843 * @tc.name: AddOrUpdateUsedTypeIfNeeded001
844 * @tc.desc: PermissionRecordManager::AddOrUpdateUsedTypeIfNeeded function test
845 * @tc.type: FUNC
846 * @tc.require:
847 */
848 HWTEST_F(PermissionRecordManagerTest, AddOrUpdateUsedTypeIfNeeded001, TestSize.Level1)
849 {
850 int32_t tokenId = RANDOM_TOKENID;
851 int32_t opCode = static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL);
852 PermissionUsedType visitType = PermissionUsedType::NORMAL_TYPE;
853 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_USED_TYPE;
854 GenericValues conditionValue;
855 conditionValue.Put(PrivacyFiledConst::FIELD_TOKEN_ID, RANDOM_TOKENID);
856 conditionValue.Put(PrivacyFiledConst::FIELD_PERMISSION_CODE, opCode);
857
858 // query result empty, add input type
859 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(tokenId, opCode, visitType));
860 std::vector<GenericValues> results;
861 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
862 ASSERT_EQ(false, results.empty());
863 for (const auto& result : results) {
864 if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
865 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
866 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
867 ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
868 break;
869 }
870 }
871 results.clear();
872
873 // uesd type exsit and same to input type, return
874 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(tokenId, opCode, visitType));
875 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
876 for (const auto& result : results) {
877 if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
878 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
879 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
880 ASSERT_EQ(PERMISSION_USED_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
881 break;
882 }
883 }
884 results.clear();
885
886 visitType = PermissionUsedType::PICKER_TYPE;
887 // used type exsit and diff from input type, update the type
888 ASSERT_EQ(true, PermissionRecordManager::GetInstance().AddOrUpdateUsedTypeIfNeeded(tokenId, opCode, visitType));
889 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Query(type, conditionValue, results));
890 for (const auto& result : results) {
891 if (RANDOM_TOKENID == result.GetInt(PrivacyFiledConst::FIELD_TOKEN_ID)) {
892 ASSERT_EQ(static_cast<int32_t>(Constant::OpCode::OP_ANSWER_CALL),
893 result.GetInt(PrivacyFiledConst::FIELD_PERMISSION_CODE));
894 ASSERT_EQ(PERMISSION_USED_TYPE_WITH_PICKER_TYPE_VALUE, result.GetInt(PrivacyFiledConst::FIELD_USED_TYPE));
895 break;
896 }
897 }
898
899 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, conditionValue));
900 }
901
902 /**
903 * @tc.name: DeletePermissionRecord001
904 * @tc.desc: delete permission record when records excessive.
905 * @tc.type: FUNC
906 * @tc.require:
907 */
908 HWTEST_F(PermissionRecordManagerTest, DeletePermissionRecord001, TestSize.Level1)
909 {
910 int32_t recordSize = PermissionRecordManager::GetInstance().recordSizeMaximum_;
911 PermissionRecordManager::GetInstance().recordSizeMaximum_ = MAX_DETAIL_NUM;
912 std::vector<GenericValues> values;
913 int32_t num = MAX_DETAIL_NUM + 1;
914 AddRecord(num, values);
915
916 EXPECT_EQ(Constant::SUCCESS, PermissionRecordManager::GetInstance().DeletePermissionRecord(1));
917 PermissionUsedRecordDb::DataType type = PermissionUsedRecordDb::PERMISSION_RECORD;
918 EXPECT_NE(num, PermissionUsedRecordDb::GetInstance().Count(type));
919 for (const auto& value : values) {
920 EXPECT_EQ(0, PermissionUsedRecordDb::GetInstance().Remove(type, value));
921 }
922 PermissionRecordManager::GetInstance().recordSizeMaximum_ = recordSize;
923 }
924
925 /*
926 * @tc.name: RemoveRecordFromStartListTest001
927 * @tc.desc: remove record from start list test
928 * @tc.type: FUNC
929 * @tc.require:
930 */
931 HWTEST_F(PermissionRecordManagerTest, RemoveRecordFromStartListTest001, TestSize.Level1)
932 {
933 std::vector<ContinusPermissionRecord> startRecordList = PermissionRecordManager::GetInstance().startRecordList_;
934 PermissionRecordManager::GetInstance().startRecordList_.clear();
935 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
936 g_InfoParms1.instIndex);
937 ASSERT_NE(INVALID_TOKENID, tokenId);
938
939 EXPECT_EQ(0, SetSelfTokenID(tokenId));
940
941 ActiveChangeType status = PERM_ACTIVE_IN_FOREGROUND;
942 PermissionRecordManager::GetInstance().AddRecordToStartList(tokenId, PID, "ohos.permission.CAMERA", status);
943 PermissionRecordManager::GetInstance().AddRecordToStartList(0, PID, "ohos.permission.MICROPHONE", status);
944 PermissionRecordManager::GetInstance().RemoveRecordFromStartListByToken(tokenId);
945 ASSERT_EQ(1, PermissionRecordManager::GetInstance().startRecordList_.size());
946 PermissionRecordManager::GetInstance().startRecordList_ = startRecordList;
947 }
948
949 /*
950 * @tc.name: StartUsingPermissionTest001
951 * @tc.desc: start using camera permission when camera global switch is close
952 * @tc.type: FUNC
953 * @tc.require: issueI5RWXF
954 */
955 HWTEST_F(PermissionRecordManagerTest, StartUsingPermissionTest001, TestSize.Level1)
956 {
957 EXPECT_EQ(0, SetSelfTokenID(g_nativeToken));
958
959 bool isMuteCamera = CameraManagerPrivacyClient::GetInstance().IsCameraMuted();
960 CameraManagerPrivacyClient::GetInstance().MuteCameraPersist(PolicyType::PRIVACY, true); // true means close
961
962 auto callbackPtr = std::make_shared<PermissionRecordManagerCoverTestCb1>();
963 auto callbackWrap = new (std::nothrow) StateChangeCallback(callbackPtr);
964 ASSERT_NE(nullptr, callbackPtr);
965 ASSERT_NE(nullptr, callbackWrap);
966 AccessTokenID tokenId = AccessTokenKit::GetHapTokenID(g_InfoParms1.userID, g_InfoParms1.bundleName,
967 g_InfoParms1.instIndex);
968 ASSERT_NE(INVALID_TOKENID, tokenId);
969 ASSERT_EQ(RET_SUCCESS, PermissionRecordManager::GetInstance().StartUsingPermission(
970 tokenId, PID, "ohos.permission.CAMERA", callbackWrap->AsObject()));
971 sleep(3); // wait for dialog disappear
972 ASSERT_EQ(0, PermissionRecordManager::GetInstance().StopUsingPermission(tokenId, PID, "ohos.permission.CAMERA"));
973 CameraManagerPrivacyClient::GetInstance().MuteCameraPersist(PolicyType::PRIVACY, isMuteCamera);
974 }
975
976 /*
977 * @tc.name: CreatePermissionUsedTypeTable001
978 * @tc.desc: PermissionUsedRecordDb::CreatePermissionUsedTypeTable function test
979 * @tc.type: FUNC
980 * @tc.require:
981 */
982 HWTEST_F(PermissionRecordManagerTest, CreatePermissionUsedTypeTable001, TestSize.Level1)
983 {
984 ASSERT_EQ(0, PermissionUsedRecordDb::GetInstance().CreatePermissionUsedTypeTable());
985
986 std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
987 dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
988 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
989
990 ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().CreatePermissionUsedTypeTable());
991 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
992 }
993
994 /*
995 * @tc.name: InsertPermissionUsedTypeColumn001
996 * @tc.desc: PermissionUsedRecordDb::InsertPermissionUsedTypeColumn function test
997 * @tc.type: FUNC
998 * @tc.require:
999 */
1000 HWTEST_F(PermissionRecordManagerTest, InsertPermissionUsedTypeColumn001, TestSize.Level1)
1001 {
1002 ASSERT_EQ(Constant::SUCCESS, PermissionUsedRecordDb::GetInstance().InsertPermissionUsedTypeColumn());
1003
1004 std::map<PermissionUsedRecordDb::DataType, SqliteTable> dataTypeToSqlTable;
1005 dataTypeToSqlTable = PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_; // backup
1006 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_.clear();
1007
1008 ASSERT_EQ(Constant::FAILURE, PermissionUsedRecordDb::GetInstance().InsertPermissionUsedTypeColumn());
1009 PermissionUsedRecordDb::GetInstance().dataTypeToSqlTable_ = dataTypeToSqlTable; // recovery
1010 }
1011 } // namespace AccessToken
1012 } // namespace Security
1013 } // namespace OHOS
1014