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 "avsession_manager.h"
19 #include "avsession_info.h"
20 #include "avsession_log.h"
21 #include "avsession_errors.h"
22
23 #include "accesstoken_kit.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::AVSession;
29 using namespace OHOS::Security::AccessToken;
30
31 static HapInfoParams g_infoA = {
32 .userID = 100,
33 .bundleName = "ohos.permission_test.demoA",
34 .instIndex = 0,
35 .appIDDesc = "ohos.permission_test.demoA"
36 };
37
38 static HapPolicyParams g_policyA = {
39 .apl = APL_NORMAL,
40 .domain = "test.domainA"
41 };
42
43 static HapInfoParams g_infoB = {
44 .userID = 100,
45 .bundleName = "ohos.permission_test.demoB",
46 .instIndex = 0,
47 .appIDDesc = "ohos.permission_test.demoB"
48 };
49
50 static HapPolicyParams g_policyB = {
51 .apl = APL_NORMAL,
52 .domain = "test.domainB",
53 .permList = {
54 {
55 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
56 .bundleName = "ohos.permission_test.demoB",
57 .grantMode = 1,
58 .availableLevel = APL_NORMAL,
59 .label = "label",
60 .labelId = 1,
61 .description = "test",
62 .descriptionId = 1
63 }
64 },
65 .permStateList = {
66 {
67 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
68 .isGeneral = true,
69 .resDeviceID = { "local" },
70 .grantStatus = { PermissionState::PERMISSION_GRANTED },
71 .grantFlags = { 1 }
72 }
73 }
74 };
75
76 class AVSessionPermissionTest : public testing::Test {
77 public:
78 static void SetUpTestCase();
79 static void TearDownTestCase();
80 void SetUp() override;
81 void TearDown() override;
82
83 uint64_t selfTokenId_ = 0;
84 void AddPermission(const HapInfoParams& info, const HapPolicyParams& policy);
85 void DeletePermission(const HapInfoParams& info);
86 };
87
SetUpTestCase()88 void AVSessionPermissionTest::SetUpTestCase()
89 {}
90
TearDownTestCase()91 void AVSessionPermissionTest::TearDownTestCase()
92 {}
93
SetUp()94 void AVSessionPermissionTest::SetUp()
95 {}
96
TearDown()97 void AVSessionPermissionTest::TearDown()
98 {}
99
AddPermission(const HapInfoParams & info,const HapPolicyParams & policy)100 void AVSessionPermissionTest::AddPermission(const HapInfoParams& info, const HapPolicyParams& policy)
101 {
102 selfTokenId_ = GetSelfTokenID();
103 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(info, policy);
104 SetSelfTokenID(tokenIdEx.tokenIdExStruct.tokenID);
105 SLOGI("selfTokenId_:%{public}" PRId64, selfTokenId_);
106 SLOGI("GetSelfTokenID:%{public}" PRId64, GetSelfTokenID());
107 }
108
DeletePermission(const HapInfoParams & info)109 void AVSessionPermissionTest::DeletePermission(const HapInfoParams& info)
110 {
111 SetSelfTokenID(selfTokenId_);
112 auto tokenId = AccessTokenKit::GetHapTokenID(info.userID, info.bundleName, info.instIndex);
113 AccessTokenKit::DeleteToken(tokenId);
114 }
115
116 class TestSessionListener : public SessionListener {
117 public:
OnSessionCreate(const AVSessionDescriptor & descriptor)118 void OnSessionCreate(const AVSessionDescriptor& descriptor) override
119 {
120 SLOGI("sessionId=%{public}s created", descriptor.sessionId_.c_str());
121 }
122
OnSessionRelease(const AVSessionDescriptor & descriptor)123 void OnSessionRelease(const AVSessionDescriptor& descriptor) override
124 {
125 SLOGI("sessionId=%{public}s released", descriptor.sessionId_.c_str());
126 }
127
OnTopSessionChange(const AVSessionDescriptor & descriptor)128 void OnTopSessionChange(const AVSessionDescriptor& descriptor) override
129 {
130 SLOGI("sessionId=%{public}s be top session", descriptor.sessionId_.c_str());
131 }
132 };
133
134 /**
135 * @tc.name: GetAllSessionDescriptorsWithNoPerm001
136 * @tc.desc: Get all session descriptors with no permission
137 * @tc.type: FUNC
138 * @tc.require: AR000H31JQ
139 */
140 HWTEST_F(AVSessionPermissionTest, GetAllSessionDescriptorsWithNoPerm001, TestSize.Level1)
141 {
142 AddPermission(g_infoA, g_policyA);
143 OHOS::AppExecFwk::ElementName elementName;
144 elementName.SetBundleName("test.ohos.avsession");
145 elementName.SetAbilityName("test.ability");
146 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
147 ASSERT_NE(session, nullptr);
148
149 std::vector<AVSessionDescriptor> descriptors;
150 auto ret = AVSessionManager::GetInstance().GetAllSessionDescriptors(descriptors);
151 EXPECT_EQ(ret, ERR_NO_PERMISSION);
152 if (session != nullptr) {
153 session->Destroy();
154 }
155 DeletePermission(g_infoA);
156 }
157
158 /**
159 * @tc.name: GetActivatedSessionDescriptorsWithNoPerm001
160 * @tc.desc: Get all activated session descriptors with no permission
161 * @tc.type: FUNC
162 * @tc.require: AR000H31JR
163 */
164 HWTEST_F(AVSessionPermissionTest, GetActivatedSessionDescriptorsWithNoPerm001, TestSize.Level1)
165 {
166 AddPermission(g_infoA, g_policyA);
167 OHOS::AppExecFwk::ElementName elementName;
168 elementName.SetBundleName("test.ohos.avsession");
169 elementName.SetAbilityName("test.ability");
170 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
171 ASSERT_NE(session, nullptr);
172 session->Activate();
173
174 std::vector<AVSessionDescriptor> descriptors;
175 auto ret = AVSessionManager::GetInstance().GetActivatedSessionDescriptors(descriptors);
176 EXPECT_EQ(ret, ERR_NO_PERMISSION);
177
178 if (session != nullptr) {
179 session->Destroy();
180 }
181 DeletePermission(g_infoA);
182 }
183
184 /**
185 * @tc.name: GetSessionDescriptorsBySessionIdWithNoPerm001
186 * @tc.desc: Get session descriptors by sessionId with no permission
187 * @tc.type: FUNC
188 * @tc.require: AR000H31JR
189 */
190 HWTEST_F(AVSessionPermissionTest, GetSessionDescriptorsBySessionIdWithNoPerm001, TestSize.Level1)
191 {
192 AddPermission(g_infoA, g_policyA);
193 OHOS::AppExecFwk::ElementName elementName;
194 elementName.SetBundleName("test.ohos.avsession");
195 elementName.SetAbilityName("test.ability");
196 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
197 ASSERT_NE(session, nullptr);
198 session->Activate();
199 auto sessionId = session->GetSessionId();
200 AVSessionDescriptor descriptor {};
201 int32_t ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(sessionId, descriptor);
202 EXPECT_EQ(ret, AVSESSION_SUCCESS);
203 EXPECT_EQ(descriptor.sessionTag_, "test");
204 EXPECT_EQ(descriptor.sessionType_, AVSession::SESSION_TYPE_AUDIO);
205 EXPECT_EQ(descriptor.elementName_.GetBundleName(), "test.ohos.avsession");
206 EXPECT_EQ(descriptor.elementName_.GetAbilityName(), "test.ability");
207 EXPECT_EQ(descriptor.isActive_, true);
208 if (session != nullptr) {
209 session->Destroy();
210 }
211 DeletePermission(g_infoA);
212 }
213
214 /**
215 * @tc.name: CreateControllerWithNoPerm001
216 * @tc.desc: create session controller with no permission
217 * @tc.type: FUNC
218 * @tc.require: AR000H31JR
219 */
220 HWTEST_F(AVSessionPermissionTest, CreateControllerWithNoPerm001, TestSize.Level1)
221 {
222 AddPermission(g_infoA, g_policyA);
223 OHOS::AppExecFwk::ElementName elementName;
224 elementName.SetBundleName("test.ohos.avsession");
225 elementName.SetAbilityName("test.ability");
226 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
227 ASSERT_NE(session, nullptr);
228
229 std::shared_ptr<AVSessionController> controller;
230 auto ret = AVSessionManager::GetInstance().CreateController(session->GetSessionId(), controller);
231 EXPECT_EQ(ret, ERR_NO_PERMISSION);
232 if (session != nullptr) {
233 session->Destroy();
234 }
235 DeletePermission(g_infoA);
236 }
237
238 /**
239 * @tc.name: RegisterSessionListenerWithNoPerm001
240 * @tc.desc: register listener with no permission
241 * @tc.type: FUNC
242 * @tc.require: AR000H31JQ
243 */
244 HWTEST_F(AVSessionPermissionTest, RegisterSessionListenerWithNoPerm001, TestSize.Level1)
245 {
246 AddPermission(g_infoA, g_policyA);
247 std::shared_ptr<TestSessionListener> listener = std::make_shared<TestSessionListener>();
248 auto result = AVSessionManager::GetInstance().RegisterSessionListener(listener);
249 EXPECT_EQ(result, ERR_NO_PERMISSION);
250 DeletePermission(g_infoA);
251 }
252
253 /**
254 * @tc.name: SendSystemMediaKeyEventWithNoPerm001
255 * @tc.desc: valid keyEvent with no permission
256 * @tc.type: FUNC
257 * @tc.require: AR000H31JR
258 */
259 HWTEST_F(AVSessionPermissionTest, SendSystemMediaKeyEventWithNoPerm001, TestSize.Level1)
260 {
261 AddPermission(g_infoA, g_policyA);
262 auto keyEvent = OHOS::MMI::KeyEvent::Create();
263 ASSERT_NE(keyEvent, nullptr);
264 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
265 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
266 keyEvent->SetActionTime(1000);
267 auto keyItem = OHOS::MMI::KeyEvent::KeyItem();
268 keyItem.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
269 keyItem.SetDownTime(1000);
270 keyItem.SetPressed(true);
271 keyEvent->AddKeyItem(keyItem);
272
273 auto result = AVSessionManager::GetInstance().SendSystemAVKeyEvent(*keyEvent);
274 EXPECT_EQ(result, ERR_NO_PERMISSION);
275 DeletePermission(g_infoA);
276 }
277
278 /**
279 * @tc.name: SendSystemControlCommandWithNoPerm001
280 * @tc.desc: valid command with no permission
281 * @tc.type: FUNC
282 * @tc.require: AR000H31JR
283 */
284 HWTEST_F(AVSessionPermissionTest, SendSystemControlCommandWithNoPerm001, TestSize.Level1)
285 {
286 AddPermission(g_infoA, g_policyA);
287 AVControlCommand command;
288 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
289 auto result = AVSessionManager::GetInstance().SendSystemControlCommand(command);
290 EXPECT_EQ(result, ERR_NO_PERMISSION);
291 DeletePermission(g_infoA);
292 }
293
294 /**
295 * @tc.name: GetAllSessionDescriptorsWithPerm001
296 * @tc.desc: Get all session descriptors with permission
297 * @tc.type: FUNC
298 * @tc.require: AR000H31JQ
299 */
300 HWTEST_F(AVSessionPermissionTest, GetAllSessionDescriptorsWithPerm001, TestSize.Level1)
301 {
302 AddPermission(g_infoB, g_policyB);
303 OHOS::AppExecFwk::ElementName elementName;
304 elementName.SetBundleName("test.ohos.avsession");
305 elementName.SetAbilityName("test.ability");
306 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
307 ASSERT_NE(session, nullptr);
308
309 std::vector<AVSessionDescriptor> descriptors;
310 auto ret = AVSessionManager::GetInstance().GetAllSessionDescriptors(descriptors);
311 EXPECT_EQ(ret, AVSESSION_SUCCESS);
312 EXPECT_EQ(descriptors.size(), 1);
313 if (session != nullptr) {
314 session->Destroy();
315 }
316 DeletePermission(g_infoB);
317 }
318
319 /**
320 * @tc.name: GetActivatedSessionDescriptorsWithPerm001
321 * @tc.desc: Get all activated session descriptors with permission
322 * @tc.type: FUNC
323 * @tc.require: AR000H31JR
324 */
325 HWTEST_F(AVSessionPermissionTest, GetActivatedSessionDescriptorsWithPerm001, TestSize.Level1)
326 {
327 AddPermission(g_infoB, g_policyB);
328 OHOS::AppExecFwk::ElementName elementName;
329 elementName.SetBundleName("test.ohos.avsession");
330 elementName.SetAbilityName("test.ability");
331 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
332 ASSERT_NE(session, nullptr);
333 session->Activate();
334
335 std::vector<AVSessionDescriptor> descriptors;
336 auto ret = AVSessionManager::GetInstance().GetActivatedSessionDescriptors(descriptors);
337 EXPECT_EQ(ret, AVSESSION_SUCCESS);
338 EXPECT_EQ(descriptors.size(), 1);
339
340 if (session != nullptr) {
341 session->Destroy();
342 }
343 DeletePermission(g_infoB);
344 }
345
346 /**
347 * @tc.name: CreateControllerWithPerm001
348 * @tc.desc: create session controller with permission
349 * @tc.type: FUNC
350 * @tc.require: AR000H31JR
351 */
352 HWTEST_F(AVSessionPermissionTest, CreateControllerWithPerm001, TestSize.Level1)
353 {
354 AddPermission(g_infoB, g_policyB);
355 OHOS::AppExecFwk::ElementName elementName;
356 elementName.SetBundleName("test.ohos.avsession");
357 elementName.SetAbilityName("test.ability");
358 auto session = AVSessionManager::GetInstance().CreateSession("test", AVSession::SESSION_TYPE_AUDIO, elementName);
359 ASSERT_NE(session, nullptr);
360
361 std::shared_ptr<AVSessionController> controller;
362 auto ret = AVSessionManager::GetInstance().CreateController(session->GetSessionId(), controller);
363 EXPECT_EQ(ret, AVSESSION_SUCCESS);
364 EXPECT_NE(controller, nullptr);
365 if (session != nullptr) {
366 session->Destroy();
367 }
368 DeletePermission(g_infoB);
369 }
370
371 /**
372 * @tc.name: RegisterSessionListenerWithPerm001
373 * @tc.desc: register listener with permission
374 * @tc.type: FUNC
375 * @tc.require: AR000H31JQ
376 */
377 HWTEST_F(AVSessionPermissionTest, RegisterSessionListenerWithPerm001, TestSize.Level1)
378 {
379 AddPermission(g_infoB, g_policyB);
380 std::shared_ptr<TestSessionListener> listener = std::make_shared<TestSessionListener>();
381 auto result = AVSessionManager::GetInstance().RegisterSessionListener(listener);
382 EXPECT_EQ(result, AVSESSION_SUCCESS);
383 DeletePermission(g_infoB);
384 }
385
386 /**
387 * @tc.name: SendSystemMediaKeyEventWithPerm001
388 * @tc.desc: valid keyEvent with permission
389 * @tc.type: FUNC
390 * @tc.require: AR000H31JR
391 */
392 HWTEST_F(AVSessionPermissionTest, SendSystemMediaKeyEventWithPerm001, TestSize.Level1)
393 {
394 AddPermission(g_infoB, g_policyB);
395 auto keyEvent = OHOS::MMI::KeyEvent::Create();
396 ASSERT_NE(keyEvent, nullptr);
397 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
398 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
399 keyEvent->SetActionTime(1000);
400 auto keyItem = OHOS::MMI::KeyEvent::KeyItem();
401 keyItem.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
402 keyItem.SetDownTime(1000);
403 keyItem.SetPressed(true);
404 keyEvent->AddKeyItem(keyItem);
405
406 auto result = AVSessionManager::GetInstance().SendSystemAVKeyEvent(*keyEvent);
407 EXPECT_EQ(result, AVSESSION_SUCCESS);
408 DeletePermission(g_infoB);
409 }
410
411 /**
412 * @tc.name: SendSystemControlCommandWithPerm001
413 * @tc.desc: valid command with permission
414 * @tc.type: FUNC
415 * @tc.require: AR000H31JR
416 */
417 HWTEST_F(AVSessionPermissionTest, SendSystemControlCommandWithPerm001, TestSize.Level1)
418 {
419 AddPermission(g_infoB, g_policyB);
420 AVControlCommand command;
421 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
422 auto result = AVSessionManager::GetInstance().SendSystemControlCommand(command);
423 EXPECT_EQ(result, AVSESSION_SUCCESS);
424 DeletePermission(g_infoB);
425 }