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_errors.h"
21 #include "system_ability_definition.h"
22 #include "softbus_bus_center.h"
23 #include "avsession_log.h"
24 #include "device_manager.h"
25 #include "dm_device_info.h"
26 #include "device_manager_callback.h"
27 #include "audio_system_manager.h"
28 #include "accesstoken_kit.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31
32
33 using namespace testing::ext;
34 using namespace OHOS::AVSession;
35 using namespace OHOS::AudioStandard;
36 using namespace OHOS::Security::AccessToken;
37
38 const int32_t DECICE_ID = 2;
39
40 static HapInfoParams g_info = {
41 .userID = 100,
42 .bundleName = "ohos.permission_test.demo",
43 .instIndex = 0,
44 .appIDDesc = "ohos.permission_test.demo"
45 };
46
47 static HapPolicyParams g_policy = {
48 .apl = APL_NORMAL,
49 .domain = "test.domain",
50 .permList = {
51 {
52 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
53 .bundleName = "ohos.permission_test.demo",
54 .grantMode = 1,
55 .availableLevel = APL_NORMAL,
56 .label = "label",
57 .labelId = 1,
58 .description = "test",
59 .descriptionId = 1
60 }
61 },
62 .permStateList = {
63 {
64 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
65 .isGeneral = true,
66 .resDeviceID = { "local" },
67 .grantStatus = { PermissionState::PERMISSION_GRANTED },
68 .grantFlags = { 1 }
69 }
70 }
71 };
72 static uint64_t g_selfTokenId = 0;
73 static int32_t g_onCall = AVSESSION_ERROR;
74 static char g_testSessionTag[] = "test";
75 static char g_testBundleName[] = "test.ohos.avsession";
76 static char g_testAbilityName[] = "test.ability";
77 static std::vector<AudioDeviceDescriptor> g_descriptors;
78
79 class InitCallback : public OHOS::DistributedHardware::DmInitCallback {
80 public:
~InitCallback()81 ~InitCallback() override
82 {
83 }
OnRemoteDied()84 void OnRemoteDied() override
85 {
86 }
87 };
88
89 class AVSessionRemoteTest : public testing::Test {
90 public:
91 static constexpr char testPkgName[] = "av_session";
92 static constexpr int nodeNumber = 4;
93 static void SetUpTestCase();
94 static void TearDownTestCase();
95 void SetUp() override;
96 void TearDown() override;
97 std::shared_ptr<AVSession> avsession_ = nullptr;
98 };
99
SetUpTestCase()100 void AVSessionRemoteTest::SetUpTestCase()
101 {
102 g_selfTokenId = GetSelfTokenID();
103 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_info, g_policy);
104 SetSelfTokenID(tokenIdEx.tokenIdExStruct.tokenID);
105
106 NodeBasicInfo *nodeInfo[nodeNumber];
107 int32_t infoNum = nodeNumber;
108 GetAllNodeDeviceInfo(testPkgName, nodeInfo, &infoNum);
109 std::vector<OHOS::DistributedHardware::DmDeviceInfo> deviceList;
110 auto callback = std::make_shared<InitCallback>();
111 int ret = OHOS::DistributedHardware::DeviceManager::GetInstance().InitDeviceManager("av_session", callback);
112 SLOGI("InitDeviceManager ret is %{public}d", ret);
113 ret = OHOS::DistributedHardware::DeviceManager::GetInstance().GetTrustedDeviceList("av_session", "", deviceList);
114 SLOGI("GetTrustedDeviceList ret is %{public}d", ret);
115 SLOGI("GetTrustedDeviceList size is %{public}d", static_cast<int32_t>(deviceList.size()));
116 ASSERT_NE(infoNum, 0);
117 AudioDeviceDescriptor descriptor;
118 for (int32_t i = 0; i < deviceList.size(); i++) {
119 descriptor.networkId_ = deviceList[i].networkId;
120 descriptor.deviceId_ = DECICE_ID;
121 g_descriptors.push_back(descriptor);
122 SLOGI("g_sinkDevices is %{public}s", deviceList[i].networkId);
123 }
124 }
125
TearDownTestCase()126 void AVSessionRemoteTest::TearDownTestCase()
127 {
128 SetSelfTokenID(g_selfTokenId);
129 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
130 AccessTokenKit::DeleteToken(tokenId);
131 }
132
SetUp()133 void AVSessionRemoteTest::SetUp()
134 {
135 OHOS::AppExecFwk::ElementName elementName;
136 elementName.SetBundleName(g_testBundleName);
137 elementName.SetAbilityName(g_testAbilityName);
138 avsession_ =
139 AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, elementName);
140 ASSERT_NE(avsession_, nullptr);
141 }
142
TearDown()143 void AVSessionRemoteTest::TearDown()
144 {
145 int32_t ret = AVSESSION_ERROR;
146 if (avsession_ != nullptr) {
147 ret = avsession_->Destroy();
148 avsession_ = nullptr;
149 }
150 }
151
152 class AVSessionCastAudioCallbackImpl : public AVSessionCallback {
153 public:
154 void OnPlay() override;
155 void OnPause() override;
156 void OnStop() override;
157 void OnPlayNext() override;
158 void OnPlayPrevious() override;
159 void OnFastForward() override;
160 void OnRewind() override;
161 void OnSeek(int64_t time) override;
162 void OnSetSpeed(double speed) override;
163 void OnSetLoopMode(int32_t loopMode) override;
164 void OnToggleFavorite(const std::string& mediald) override;
165 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
166 void OnOutputDeviceChange(const OutputDeviceInfo& outputDeviceInfo) override;
167
168 ~AVSessionCastAudioCallbackImpl() override;
169 };
170
OnPlay()171 void AVSessionCastAudioCallbackImpl::OnPlay()
172 {
173 g_onCall = AVSESSION_SUCCESS;
174 SLOGE("OnPlay %{public}d", g_onCall);
175 }
OnPause()176 void AVSessionCastAudioCallbackImpl::OnPause()
177 {
178 g_onCall = AVSESSION_SUCCESS;
179 SLOGE("OnPause %{public}d", g_onCall);
180 }
OnStop()181 void AVSessionCastAudioCallbackImpl::OnStop()
182 {
183 g_onCall = AVSESSION_SUCCESS;
184 SLOGE("OnStop %{public}d", g_onCall);
185 }
OnPlayNext()186 void AVSessionCastAudioCallbackImpl::OnPlayNext()
187 {
188 g_onCall = AVSESSION_SUCCESS;
189 SLOGE("OnPlayNext %{public}d", g_onCall);
190 }
OnPlayPrevious()191 void AVSessionCastAudioCallbackImpl::OnPlayPrevious()
192 {
193 g_onCall = AVSESSION_SUCCESS;
194 SLOGE("OnPlayPrevious %{public}d", g_onCall);
195 }
OnFastForward()196 void AVSessionCastAudioCallbackImpl::OnFastForward()
197 {
198 g_onCall = AVSESSION_SUCCESS;
199 SLOGE("OnFastForward %{public}d", g_onCall);
200 }
OnRewind()201 void AVSessionCastAudioCallbackImpl::OnRewind()
202 {
203 g_onCall = AVSESSION_SUCCESS;
204 SLOGE("OnRewind %{public}d", g_onCall);
205 }
OnSeek(int64_t time)206 void AVSessionCastAudioCallbackImpl::OnSeek(int64_t time)
207 {
208 SLOGE("OnSeek %{public}" PRId64, time);
209 g_onCall = AVSESSION_SUCCESS;
210 }
OnSetSpeed(double speed)211 void AVSessionCastAudioCallbackImpl::OnSetSpeed(double speed)
212 {
213 SLOGE("OnSetSpeed %{public}f", speed);
214 g_onCall = AVSESSION_SUCCESS;
215 SLOGE("OnSetSpeed %{public}d", g_onCall);
216 }
OnSetLoopMode(int32_t loopMode)217 void AVSessionCastAudioCallbackImpl::OnSetLoopMode(int32_t loopMode)
218 {
219 SLOGE("OnSetLoopMode %{public}d", loopMode);
220 g_onCall = AVSESSION_SUCCESS;
221 SLOGE("OnSetLoopMode %{public}d", g_onCall);
222 }
OnToggleFavorite(const std::string & mediald)223 void AVSessionCastAudioCallbackImpl::OnToggleFavorite(const std::string& mediald)
224 {
225 SLOGE("OnToggleFavorite %{public}s", mediald.c_str());
226 g_onCall = AVSESSION_SUCCESS;
227 SLOGE("OnToggleFavorite %{public}d", g_onCall);
228 }
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)229 void AVSessionCastAudioCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
230 {
231 SLOGE("OnMediaKeyEvent");
232 g_onCall = AVSESSION_SUCCESS;
233 }
OnOutputDeviceChange(const OutputDeviceInfo & info)234 void AVSessionCastAudioCallbackImpl::OnOutputDeviceChange(const OutputDeviceInfo& info)
235 {
236 SLOGE("OnOutputDeviceChange");
237 g_onCall = AVSESSION_SUCCESS;
238 }
~AVSessionCastAudioCallbackImpl()239 AVSessionCastAudioCallbackImpl::~AVSessionCastAudioCallbackImpl()
240 {
241 }
242
243 /**
244 * @tc.name: CastAudio001
245 * @tc.desc: Cast current audio to the remote device
246 * @tc.type: FUNC
247 * @tc.require: AR000H55F4
248 */
249 HWTEST_F(AVSessionRemoteTest, CastAudio001, TestSize.Level1)
250 {
251 SLOGE("CastAudio001 Begin");
252 SessionToken sessionToken;
253 sessionToken.sessionId = avsession_->GetSessionId();
254 sessionToken.pid = 111;
255 sessionToken.uid = 2222;
256 EXPECT_NE(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), AVSESSION_SUCCESS);
257 SLOGE("CastAudio001 End");
258 }
259
260 /**
261 * @tc.name: CastAudio002
262 * @tc.desc: Invalid params for sessionToken
263 * @tc.type: FUNC
264 * @tc.require: AR000H55F4
265 */
266 HWTEST_F(AVSessionRemoteTest, CastAudio002, TestSize.Level1)
267 {
268 SLOGE("CastAudio002 Begin");
269 SessionToken sessionToken;
270 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_INVALID_PARAM);
271 SLOGE("CastAudio002 End");
272 }
273
274 /**
275 * @tc.name: CastAudio003
276 * @tc.desc: Invalid params for sessionToken
277 * @tc.type: FUNC
278 * @tc.require: AR000H55F4
279 */
280 HWTEST_F(AVSessionRemoteTest, CastAudio003, TestSize.Level1)
281 {
282 SLOGE("CastAudio003 Begin");
283 SessionToken sessionToken;
284 sessionToken.sessionId = "123456789";
285 sessionToken.pid = 111;
286 sessionToken.uid = 2222;
287 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_INVALID_PARAM);
288 SLOGE("CastAudio003 End");
289 }
290
291 /**
292 * @tc.name: CastAudio004
293 * @tc.desc: Invalid params for descriptors
294 * @tc.type: FUNC
295 * @tc.require: AR000H55F4
296 */
297 HWTEST_F(AVSessionRemoteTest, CastAudio004, TestSize.Level1)
298 {
299 SLOGE("CastAudio004 Begin");
300 SessionToken sessionToken;
301 sessionToken.sessionId = avsession_->GetSessionId();
302 sessionToken.pid = 111;
303 sessionToken.uid = 2222;
304 std::vector<AudioDeviceDescriptor> descriptors;
305 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, descriptors), ERR_INVALID_PARAM);
306 SLOGE("CastAudio004 End");
307 }
308
309 /**
310 * @tc.name: CastAudioForAll001
311 * @tc.desc: Cast current all audios to the remote device
312 * @tc.type: FUNC
313 * @tc.require: AR000H55F4
314 */
315 HWTEST_F(AVSessionRemoteTest, CastAudioForAll001, TestSize.Level1)
316 {
317 SLOGE("CastAudioForAll001 Begin");
318 EXPECT_NE(AVSessionManager::GetInstance().CastAudioForAll(g_descriptors), AVSESSION_SUCCESS);
319 SLOGE("CastAudioForAll001 End");
320 }
321
322 /**
323 * @tc.name: CastAudioForAll002
324 * @tc.desc: Invalid params for descriptors
325 * @tc.type: FUNC
326 * @tc.require: AR000H55F4
327 */
328 HWTEST_F(AVSessionRemoteTest, CastAudioForAll002, TestSize.Level1)
329 {
330 SLOGE("CastAudioForAll002 Begin");
331 std::vector<AudioDeviceDescriptor> descriptors;
332 EXPECT_EQ(AVSessionManager::GetInstance().CastAudioForAll(descriptors), ERR_INVALID_PARAM);
333 SLOGE("CastAudioForAll002 End");
334 }
335
336 /**
337 * @tc.name: SetAVMetaData001
338 * @tc.desc: Set av meta data to remote devices
339 * @tc.type: FUNC
340 * @tc.require: AR000H55F4
341 */
342 HWTEST_F(AVSessionRemoteTest, SetAVMetaData001, TestSize.Level1)
343 {
344 SLOGE("SetAVMetaData001 Begin");
345 SessionToken sessionToken;
346 sessionToken.sessionId = avsession_->GetSessionId();
347 sessionToken.pid = 111;
348 sessionToken.uid = 2222;
349 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
350 AVMetaData metaData;
351 metaData.Reset();
352 metaData.SetAssetId("123");
353 metaData.SetTitle("Black Humor");
354 metaData.SetArtist("zhoujielun");
355 metaData.SetAuthor("zhoujielun");
356 metaData.SetAlbum("Jay");
357 metaData.SetWriter("zhoujielun");
358 metaData.SetComposer("zhoujielun");
359 metaData.SetDuration(40000);
360 metaData.SetMediaImageUri("xxxxx");
361 metaData.SetSubTitle("fac");
362 metaData.SetDescription("for friends");
363 metaData.SetLyric("xxxxx");
364 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
365 SLOGE("SetAVMetaData001 End");
366 }
367
368
369 /**
370 * @tc.name: SetAVPlaybackState001
371 * @tc.desc: Set av playback state to remote devices
372 * @tc.type: FUNC
373 * @tc.require: AR000H55F4
374 */
375 HWTEST_F(AVSessionRemoteTest, SetAVPlaybackState001, TestSize.Level1)
376 {
377 SLOGE("SetAVPlaybackState001 Begin");
378 SessionToken sessionToken;
379 sessionToken.sessionId = avsession_->GetSessionId();
380 sessionToken.pid = 111;
381 sessionToken.uid = 2222;
382 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
383 AVMetaData metaData;
384 metaData.Reset();
385 metaData.SetAssetId("playback");
386 metaData.SetDuration(2000000);
387 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
388 AVPlaybackState playbackState;
389 playbackState.SetState(1);
390 playbackState.SetSpeed(1);
391 playbackState.SetPosition({80000, 0});
392 playbackState.SetBufferedTime(700000);
393 playbackState.SetLoopMode(1);
394 playbackState.SetFavorite(true);
395 EXPECT_EQ(avsession_->SetAVPlaybackState(playbackState), AVSESSION_SUCCESS);
396 SLOGE("SetAVPlaybackState001 End");
397 }
398
399 /**
400 * @tc.name: SendControlCommand001
401 * @tc.desc: Send control command by remote controller to local device
402 * @tc.type: FUNC
403 * @tc.require: AR000H55F5
404 */
405 HWTEST_F(AVSessionRemoteTest, SendControlCommand001, TestSize.Level1)
406 {
407 SLOGE("SendControlCommand001 Begin");
408 std::shared_ptr<AVSessionController> controller;
409 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
410 ASSERT_EQ(ret, AVSESSION_SUCCESS);
411 ASSERT_NE(controller, nullptr);
412 sleep(1);
413 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
414 SessionToken sessionToken;
415 sessionToken.sessionId = avsession_->GetSessionId();
416 sessionToken.pid = 111;
417 sessionToken.uid = 2222;
418 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
419 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCastAudioCallbackImpl>();
420 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
421 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
422 AVControlCommand cmd;
423 EXPECT_EQ(cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
424 EXPECT_EQ(controller->SendControlCommand(cmd), AVSESSION_SUCCESS);
425 if (controller != nullptr) {
426 ret = controller->Destroy();
427 EXPECT_EQ(ret, AVSESSION_SUCCESS);
428 controller = nullptr;
429 EXPECT_EQ(controller, nullptr);
430 }
431 SLOGE("SendControlCommand001 End");
432 }
433
434 /**
435 * @tc.name: GetController001
436 * @tc.desc: Get controller by session
437 * @tc.type: FUNC
438 * @tc.require: AR000H55F4
439 */
440 HWTEST_F(AVSessionRemoteTest, GetController001, TestSize.Level1)
441 {
442 SLOGE("GetController001 Begin");
443 SessionToken sessionToken;
444 sessionToken.sessionId = avsession_->GetSessionId();
445 sessionToken.pid = 111;
446 sessionToken.uid = 2222;
447 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
448
449 auto controller = avsession_->GetController();
450 ASSERT_NE(controller, nullptr);
451 SLOGE("GetController001 End");
452 }
453
454 /**
455 * @tc.name: GetController002
456 * @tc.desc: The controller fetched twice through session is same
457 * @tc.type: FUNC
458 * @tc.require: AR000H55F4
459 */
460 HWTEST_F(AVSessionRemoteTest, GetController002, TestSize.Level1)
461 {
462 SLOGE("GetController002 Begin");
463 SessionToken sessionToken;
464 sessionToken.sessionId = avsession_->GetSessionId();
465 sessionToken.pid = 111;
466 sessionToken.uid = 2222;
467 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
468
469 auto controller = avsession_->GetController();
470 auto controller1 = avsession_->GetController();
471 ASSERT_NE(controller, nullptr);
472 ASSERT_NE(controller1, nullptr);
473 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
474 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
475 SLOGE("GetController002 End");
476 }
477
478 /**
479 * @tc.name: GetOutputDevice001
480 * @tc.desc: Get output device information by session
481 * @tc.type: FUNC
482 * @tc.require: AR000H55F4
483 */
484 HWTEST_F(AVSessionRemoteTest, GetOutputDevice001, TestSize.Level1)
485 {
486 SLOGE("GetOutputDevice001 Begin");
487 AVSessionDescriptor descriptor;
488 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
489 EXPECT_EQ(ret, AVSESSION_SUCCESS);
490 SLOGE("avsession get deviceIds_ size %{public}d",
491 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceIds_.size()));
492 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceIds_[0].c_str());
493 ASSERT_NE(descriptor.outputDeviceInfo_.deviceIds_.size(), 0);
494 SLOGE("avsession get deviceNames_ size %{public}d",
495 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceNames_.size()));
496 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceNames_[0].c_str());
497 ASSERT_NE(descriptor.outputDeviceInfo_.deviceNames_.size(), 0);
498 SLOGE("GetOutputDevice001 End");
499 }
500
501 /**
502 * @tc.name: GetOutputDevice002
503 * @tc.desc: Invalid params for sessionId
504 * @tc.type: FUNC
505 * @tc.require: AR000H55F4
506 */
507 HWTEST_F(AVSessionRemoteTest, GetOutputDevice002, TestSize.Level1)
508 {
509 SLOGE("GetOutputDevice002 Begin");
510 AVSessionDescriptor descriptor;
511 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("123456789", descriptor),
512 AVSESSION_ERROR);
513 SLOGE("GetOutputDevice002 End");
514 }
515
516 /**
517 * @tc.name: GetOutputDevice003
518 * @tc.desc: Invalid params for sessionId
519 * @tc.type: FUNC
520 * @tc.require: AR000H55FQ
521 */
522 HWTEST_F(AVSessionRemoteTest, GetOutputDevice003, TestSize.Level1)
523 {
524 SLOGE("GetOutputDevice003 Begin");
525 AVSessionDescriptor descriptor;
526 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("", descriptor), ERR_INVALID_PARAM);
527 SLOGE("GetOutputDevice003 End");
528 }
529
530 /**
531 * @tc.name: GetOutputDevice004
532 * @tc.desc: Get output device information by controller
533 * @tc.type: FUNC
534 * @tc.require: AR000H55F4
535 */
536 HWTEST_F(AVSessionRemoteTest, GetOutputDevice004, TestSize.Level1)
537 {
538 SLOGE("GetOutputDevice004 Begin");
539 std::shared_ptr<AVSessionController> controller = nullptr;
540 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
541 EXPECT_EQ(ret, AVSESSION_SUCCESS);
542 ASSERT_NE(controller, nullptr);
543
544 AVSessionDescriptor descriptor;
545 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor);
546 EXPECT_EQ(ret, AVSESSION_SUCCESS);
547 SLOGE("controller get deviceIds_ size %{public}d",
548 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceIds_.size()));
549 SLOGE("controller get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceIds_[0].c_str());
550 ASSERT_NE(descriptor.outputDeviceInfo_.deviceIds_.size(), 0);
551 SLOGE("controller get deviceNames_ size %{public}d",
552 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceNames_.size()));
553 SLOGE("controller get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceNames_[0].c_str());
554 ASSERT_NE(descriptor.outputDeviceInfo_.deviceNames_.size(), 0);
555 if (controller != nullptr) {
556 ret = controller->Destroy();
557 EXPECT_EQ(ret, AVSESSION_SUCCESS);
558 controller = nullptr;
559 EXPECT_EQ(controller, nullptr);
560 }
561 SLOGE("GetOutputDevice004 End");
562 }
563
564 /**
565 * @tc.name: GetOutputDevice005
566 * @tc.desc: Get same output device information by controller and session
567 * @tc.type: FUNC
568 * @tc.require: AR000H55F4
569 */
570 HWTEST_F(AVSessionRemoteTest, GetOutputDevice005, TestSize.Level1)
571 {
572 SLOGE("GetOutputDevice005 Begin");
573 AVSessionDescriptor descriptor1;
574 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(),
575 descriptor1);
576 EXPECT_EQ(ret, AVSESSION_SUCCESS);
577 ASSERT_NE(descriptor1.outputDeviceInfo_.deviceIds_.size(), 0);
578 ASSERT_NE(descriptor1.outputDeviceInfo_.deviceNames_.size(), 0);
579
580 std::shared_ptr<AVSessionController> controller = nullptr;
581 ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
582 EXPECT_EQ(ret, AVSESSION_SUCCESS);
583 ASSERT_NE(controller, nullptr);
584
585 AVSessionDescriptor descriptor2;
586 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor2);
587 EXPECT_EQ(ret, AVSESSION_SUCCESS);
588 ASSERT_NE(descriptor2.outputDeviceInfo_.deviceIds_.size(), 0);
589 ASSERT_NE(descriptor2.outputDeviceInfo_.deviceNames_.size(), 0);
590
591 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceIds_.size(), descriptor2.outputDeviceInfo_.deviceIds_.size());
592 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceIds_[0], descriptor2.outputDeviceInfo_.deviceIds_[0]);
593 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceNames_.size(), descriptor2.outputDeviceInfo_.deviceNames_.size());
594 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceNames_[0], descriptor2.outputDeviceInfo_.deviceNames_[0]);
595 if (controller != nullptr) {
596 ret = controller->Destroy();
597 EXPECT_EQ(ret, AVSESSION_SUCCESS);
598 controller = nullptr;
599 }
600 SLOGE("GetOutputDevice005 End");
601 }