1 /*
2 * Copyright (c) 2022-2025 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 "avsession_callback_client.h"
22 #include "system_ability_definition.h"
23 #include "softbus_bus_center.h"
24 #include "avsession_log.h"
25 #include "device_manager.h"
26 #include "dm_device_info.h"
27 #include "device_manager_callback.h"
28 #include "audio_system_manager.h"
29 #include "accesstoken_kit.h"
30 #include "nativetoken_kit.h"
31 #include "token_setproc.h"
32
33 using namespace testing::ext;
34 using namespace OHOS::AudioStandard;
35 using namespace OHOS::Security::AccessToken;
36
37 namespace OHOS {
38 namespace AVSession {
39 const int32_t DECICE_ID = 2;
40
41 static HapInfoParams g_info = {
42 .userID = 100,
43 .bundleName = "ohos.permission_test.demo",
44 .instIndex = 0,
45 .appIDDesc = "ohos.permission_test.demo",
46 .isSystemApp = true
47 };
48
49 static HapPolicyParams g_policy = {
50 .apl = APL_NORMAL,
51 .domain = "test.domain",
52 .permList = {
53 {
54 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
55 .bundleName = "ohos.permission_test.demo",
56 .grantMode = 1,
57 .availableLevel = APL_NORMAL,
58 .label = "label",
59 .labelId = 1,
60 .description = "test",
61 .descriptionId = 1
62 }
63 },
64 .permStateList = {
65 {
66 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
67 .isGeneral = true,
68 .resDeviceID = { "local" },
69 .grantStatus = { PermissionState::PERMISSION_GRANTED },
70 .grantFlags = { 1 }
71 }
72 }
73 };
74 static uint64_t g_selfTokenId = 0;
75 static int32_t g_onCall = AVSESSION_ERROR;
76 static char g_testSessionTag[] = "test";
77 static char g_testBundleName[] = "test.ohos.avsession";
78 static char g_testAbilityName[] = "test.ability";
79 static std::vector<AudioDeviceDescriptor> g_descriptors;
80
81 class InitCallback : public OHOS::DistributedHardware::DmInitCallback {
82 public:
~InitCallback()83 ~InitCallback() override
84 {
85 }
OnRemoteDied()86 void OnRemoteDied() override
87 {
88 }
89 };
90
91 class AVSessionRemoteTest : public testing::Test {
92 public:
93 static constexpr char TEST_PACKAGE_NAME[] = "av_session";
94 static constexpr int NODE_NUMBER = 4;
95 static void SetUpTestCase();
96 static void TearDownTestCase();
97 void SetUp() override;
98 void TearDown() override;
99 std::shared_ptr<AVSession> avsession_ = nullptr;
100 };
101
102
MockGetTrustedDeviceList(std::vector<OHOS::DistributedHardware::DmDeviceInfo> & deviceList)103 void MockGetTrustedDeviceList(std::vector<OHOS::DistributedHardware::DmDeviceInfo> &deviceList)
104 {
105 OHOS::DistributedHardware::DmDeviceInfo localeDevice;
106 memset_s(&localeDevice, sizeof(localeDevice), 0, sizeof(localeDevice));
107 strcpy_s(localeDevice.deviceId, sizeof(localeDevice.deviceId) - 1, "<localeDeviceId>");
108 strcpy_s(localeDevice.deviceName, sizeof(localeDevice.deviceName) - 1, "<localeDeviceName>");
109
110 OHOS::DistributedHardware::DmDeviceInfo remoteDevice;
111 memset_s(&remoteDevice, sizeof(remoteDevice), 0, sizeof(remoteDevice));
112 strcpy_s(remoteDevice.deviceId, sizeof(remoteDevice.deviceId) - 1, "<remoteDeviceId>");
113 strcpy_s(remoteDevice.deviceName, sizeof(remoteDevice.deviceName) - 1, "<remoteDeviceName>");
114
115 deviceList.clear();
116 deviceList.push_back(localeDevice);
117 deviceList.push_back(remoteDevice);
118 }
119
SetUpTestCase()120 void AVSessionRemoteTest::SetUpTestCase()
121 {
122 g_selfTokenId = GetSelfTokenID();
123 AccessTokenKit::AllocHapToken(g_info, g_policy);
124 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
125 SetSelfTokenID(tokenID.tokenIDEx);
126
127 NodeBasicInfo *nodeInfo[NODE_NUMBER];
128 int32_t infoNum = NODE_NUMBER;
129 GetAllNodeDeviceInfo(TEST_PACKAGE_NAME, nodeInfo, &infoNum);
130 std::vector<OHOS::DistributedHardware::DmDeviceInfo> deviceList;
131 auto callback = std::make_shared<InitCallback>();
132 int ret = OHOS::DistributedHardware::DeviceManager::GetInstance().InitDeviceManager("av_session", callback);
133 SLOGI("InitDeviceManager ret is %{public}d", ret);
134 ret = OHOS::DistributedHardware::DeviceManager::GetInstance().GetTrustedDeviceList("av_session", "", deviceList);
135 SLOGI("GetTrustedDeviceList ret is %{public}d", ret);
136 SLOGI("GetTrustedDeviceList size is %{public}d", static_cast<int32_t>(deviceList.size()));
137 ASSERT_NE(infoNum, 0);
138 AudioDeviceDescriptor descriptor;
139 if (deviceList.size() == 0) {
140 MockGetTrustedDeviceList(deviceList);
141 }
142 for (int32_t i = 0; i < deviceList.size(); i++) {
143 descriptor.networkId_ = deviceList[i].networkId;
144 descriptor.deviceId_ = DECICE_ID;
145 g_descriptors.push_back(descriptor);
146 SLOGI("g_sinkDevices is %{public}s", deviceList[i].networkId);
147 }
148 }
149
TearDownTestCase()150 void AVSessionRemoteTest::TearDownTestCase()
151 {
152 SetSelfTokenID(g_selfTokenId);
153 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
154 AccessTokenKit::DeleteToken(tokenId);
155 }
156
SetUp()157 void AVSessionRemoteTest::SetUp()
158 {
159 OHOS::AppExecFwk::ElementName elementName;
160 elementName.SetBundleName(g_testBundleName);
161 elementName.SetAbilityName(g_testAbilityName);
162 avsession_ =
163 AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, elementName);
164 ASSERT_NE(avsession_, nullptr);
165 }
166
TearDown()167 void AVSessionRemoteTest::TearDown()
168 {
169 [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
170 if (avsession_ != nullptr) {
171 ret = avsession_->Destroy();
172 avsession_ = nullptr;
173 }
174 }
175
176 class AVSessionCastAudioCallbackImpl : public AVSessionCallback {
177 public:
178 void OnPlay() override;
179 void OnPause() override;
180 void OnStop() override;
181 void OnPlayNext() override;
182 void OnPlayPrevious() override;
183 void OnFastForward(int64_t time) override;
184 void OnRewind(int64_t time) override;
185 void OnSeek(int64_t time) override;
186 void OnSetSpeed(double speed) override;
187 void OnSetLoopMode(int32_t loopMode) override;
188 void OnSetTargetLoopMode(int32_t targetLoopMode) override;
189 void OnToggleFavorite(const std::string& mediaId) override;
190 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
191 void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override;
192 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override;
193 void OnSkipToQueueItem(int32_t itemId) override;
OnAVCallAnswer()194 void OnAVCallAnswer() override {};
OnAVCallHangUp()195 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()196 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)197 void OnPlayFromAssetId(int64_t assetId) override {};
OnPlayWithAssetId(const std::string & assetId)198 void OnPlayWithAssetId(const std::string& assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)199 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
200
201 ~AVSessionCastAudioCallbackImpl() override;
202 };
203
OnPlay()204 void AVSessionCastAudioCallbackImpl::OnPlay()
205 {
206 g_onCall = AVSESSION_SUCCESS;
207 SLOGE("OnPlay %{public}d", g_onCall);
208 }
209
OnPause()210 void AVSessionCastAudioCallbackImpl::OnPause()
211 {
212 g_onCall = AVSESSION_SUCCESS;
213 SLOGE("OnPause %{public}d", g_onCall);
214 }
215
OnStop()216 void AVSessionCastAudioCallbackImpl::OnStop()
217 {
218 g_onCall = AVSESSION_SUCCESS;
219 SLOGE("OnStop %{public}d", g_onCall);
220 }
221
OnPlayNext()222 void AVSessionCastAudioCallbackImpl::OnPlayNext()
223 {
224 g_onCall = AVSESSION_SUCCESS;
225 SLOGE("OnPlayNext %{public}d", g_onCall);
226 }
227
OnPlayPrevious()228 void AVSessionCastAudioCallbackImpl::OnPlayPrevious()
229 {
230 g_onCall = AVSESSION_SUCCESS;
231 SLOGE("OnPlayPrevious %{public}d", g_onCall);
232 }
233
OnFastForward(int64_t time)234 void AVSessionCastAudioCallbackImpl::OnFastForward(int64_t time)
235 {
236 g_onCall = AVSESSION_SUCCESS;
237 SLOGE("OnFastForward %{public}d", g_onCall);
238 }
239
OnRewind(int64_t time)240 void AVSessionCastAudioCallbackImpl::OnRewind(int64_t time)
241 {
242 g_onCall = AVSESSION_SUCCESS;
243 SLOGE("OnRewind %{public}d", g_onCall);
244 }
245
OnSeek(int64_t time)246 void AVSessionCastAudioCallbackImpl::OnSeek(int64_t time)
247 {
248 SLOGE("OnSeek %{public}" PRId64, time);
249 g_onCall = AVSESSION_SUCCESS;
250 }
251
OnSetSpeed(double speed)252 void AVSessionCastAudioCallbackImpl::OnSetSpeed(double speed)
253 {
254 SLOGE("OnSetSpeed %{public}f", speed);
255 g_onCall = AVSESSION_SUCCESS;
256 SLOGE("OnSetSpeed %{public}d", g_onCall);
257 }
258
OnSetLoopMode(int32_t loopMode)259 void AVSessionCastAudioCallbackImpl::OnSetLoopMode(int32_t loopMode)
260 {
261 SLOGE("OnSetLoopMode %{public}d", loopMode);
262 g_onCall = AVSESSION_SUCCESS;
263 SLOGE("OnSetLoopMode %{public}d", g_onCall);
264 }
265
OnSetTargetLoopMode(int32_t targetLoopMode)266 void AVSessionCastAudioCallbackImpl::OnSetTargetLoopMode(int32_t targetLoopMode)
267 {
268 SLOGE("OnSetTargetLoopMode %{public}d", targetLoopMode);
269 g_onCall = AVSESSION_SUCCESS;
270 SLOGE("OnSetTargetLoopMode %{public}d", g_onCall);
271 }
272
OnToggleFavorite(const std::string & mediaId)273 void AVSessionCastAudioCallbackImpl::OnToggleFavorite(const std::string& mediaId)
274 {
275 SLOGE("OnToggleFavorite %{public}s", mediaId.c_str());
276 g_onCall = AVSESSION_SUCCESS;
277 SLOGE("OnToggleFavorite %{public}d", g_onCall);
278 }
279
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)280 void AVSessionCastAudioCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
281 {
282 SLOGE("OnMediaKeyEvent");
283 g_onCall = AVSESSION_SUCCESS;
284 }
285
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & info)286 void AVSessionCastAudioCallbackImpl::OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& info)
287 {
288 SLOGE("OnOutputDeviceChange");
289 g_onCall = AVSESSION_SUCCESS;
290 }
291
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)292 void AVSessionCastAudioCallbackImpl::OnCommonCommand(const std::string& commonCommand,
293 const OHOS::AAFwk::WantParams& commandArgs)
294 {
295 SLOGI("OnCommonCommand");
296 g_onCall = AVSESSION_SUCCESS;
297 }
298
OnSkipToQueueItem(int32_t itemId)299 void AVSessionCastAudioCallbackImpl::OnSkipToQueueItem(int32_t itemId)
300 {
301 SLOGE("OnSkipToQueueItem %{public}d", itemId);
302 g_onCall = AVSESSION_SUCCESS;
303 SLOGE("OnSetSpeed %{public}d", g_onCall);
304 }
305
~AVSessionCastAudioCallbackImpl()306 AVSessionCastAudioCallbackImpl::~AVSessionCastAudioCallbackImpl()
307 {
308 }
309
310 /**
311 * @tc.name: CastAudio001
312 * @tc.desc: Cast current audio to the remote device
313 * @tc.type: FUNC
314 * @tc.require: AR000H55F4
315 */
316 HWTEST_F(AVSessionRemoteTest, CastAudio001, TestSize.Level1)
317 {
318 SLOGE("CastAudio001 Begin");
319 SessionToken sessionToken;
320 sessionToken.sessionId = avsession_->GetSessionId();
321 sessionToken.pid = 111;
322 sessionToken.uid = 2222;
323 int ret = AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
324 SLOGI("CastAudio001 with ret %{public}d", static_cast<int>(ret));
325 EXPECT_EQ((ret == AVSESSION_SUCCESS || ret == ERR_IPC_SEND_REQUEST), true);
326 SLOGE("CastAudio001 End");
327 }
328
329 /**
330 * @tc.name: CastAudio002
331 * @tc.desc: Invalid params for sessionToken
332 * @tc.type: FUNC
333 * @tc.require: AR000H55F4
334 */
335 HWTEST_F(AVSessionRemoteTest, CastAudio002, TestSize.Level1)
336 {
337 SLOGE("CastAudio002 Begin");
338 SessionToken sessionToken;
339 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_IPC_SEND_REQUEST);
340 SLOGE("CastAudio002 End");
341 }
342
343 /**
344 * @tc.name: CastAudio003
345 * @tc.desc: Invalid params for sessionToken
346 * @tc.type: FUNC
347 * @tc.require: AR000H55F4
348 */
349 HWTEST_F(AVSessionRemoteTest, CastAudio003, TestSize.Level1)
350 {
351 SLOGE("CastAudio003 Begin");
352 SessionToken sessionToken;
353 sessionToken.sessionId = "123456789";
354 sessionToken.pid = 111;
355 sessionToken.uid = 2222;
356 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_IPC_SEND_REQUEST);
357 SLOGE("CastAudio003 End");
358 }
359
360 /**
361 * @tc.name: CastAudio004
362 * @tc.desc: Invalid params for descriptors
363 * @tc.type: FUNC
364 * @tc.require: AR000H55F4
365 */
366 HWTEST_F(AVSessionRemoteTest, CastAudio004, TestSize.Level1)
367 {
368 SLOGE("CastAudio004 Begin");
369 SessionToken sessionToken;
370 sessionToken.sessionId = avsession_->GetSessionId();
371 sessionToken.pid = 111;
372 sessionToken.uid = 2222;
373 std::vector<AudioDeviceDescriptor> descriptors;
374 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, descriptors), ERR_INVALID_PARAM);
375 SLOGE("CastAudio004 End");
376 }
377
378 /**
379 * @tc.name: CastAudioForAll001
380 * @tc.desc: Cast current all audios to the remote device
381 * @tc.type: FUNC
382 * @tc.require: AR000H55F4
383 */
384 HWTEST_F(AVSessionRemoteTest, CastAudioForAll001, TestSize.Level1)
385 {
386 SLOGE("CastAudioForAll001 Begin");
387 int ret = AVSessionManager::GetInstance().CastAudioForAll(g_descriptors);
388 SLOGI("CastAudioForAll001 with ret %{public}d", static_cast<int>(ret));
389 EXPECT_EQ((ret == AVSESSION_SUCCESS || ret == ERR_IPC_SEND_REQUEST), true);
390 SLOGE("CastAudioForAll001 End");
391 }
392
393 /**
394 * @tc.name: CastAudioForAll002
395 * @tc.desc: Invalid params for descriptors
396 * @tc.type: FUNC
397 * @tc.require: AR000H55F4
398 */
399 HWTEST_F(AVSessionRemoteTest, CastAudioForAll002, TestSize.Level1)
400 {
401 SLOGE("CastAudioForAll002 Begin");
402 std::vector<AudioDeviceDescriptor> descriptors;
403 EXPECT_EQ(AVSessionManager::GetInstance().CastAudioForAll(descriptors), ERR_INVALID_PARAM);
404 SLOGE("CastAudioForAll002 End");
405 }
406
407 /**
408 * @tc.name: SetAVMetaData001
409 * @tc.desc: Set av meta data to remote devices
410 * @tc.type: FUNC
411 * @tc.require: AR000H55F4
412 */
413 HWTEST_F(AVSessionRemoteTest, SetAVMetaData001, TestSize.Level1)
414 {
415 SLOGE("SetAVMetaData001 Begin");
416 SessionToken sessionToken;
417 sessionToken.sessionId = avsession_->GetSessionId();
418 sessionToken.pid = 111;
419 sessionToken.uid = 2222;
420 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
421 AVMetaData metaData;
422 metaData.Reset();
423 metaData.SetAssetId("123");
424 metaData.SetTitle("Black Humor");
425 metaData.SetArtist("zhoujielun");
426 metaData.SetAuthor("zhoujielun");
427 metaData.SetAlbum("Jay");
428 metaData.SetWriter("zhoujielun");
429 metaData.SetComposer("zhoujielun");
430 metaData.SetDuration(40000);
431 metaData.SetMediaImageUri("xxxxx");
432 metaData.SetSubTitle("fac");
433 metaData.SetDescription("for friends");
434 metaData.SetLyric("xxxxx");
435 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
436 SLOGE("SetAVMetaData001 End");
437 }
438
439
440 /**
441 * @tc.name: SetAVPlaybackState001
442 * @tc.desc: Set av playback state to remote devices
443 * @tc.type: FUNC
444 * @tc.require: AR000H55F4
445 */
446 HWTEST_F(AVSessionRemoteTest, SetAVPlaybackState001, TestSize.Level1)
447 {
448 SLOGE("SetAVPlaybackState001 Begin");
449 SessionToken sessionToken;
450 sessionToken.sessionId = avsession_->GetSessionId();
451 sessionToken.pid = 111;
452 sessionToken.uid = 2222;
453 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
454 AVMetaData metaData;
455 metaData.Reset();
456 metaData.SetAssetId("playback");
457 metaData.SetDuration(2000000);
458 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
459 AVPlaybackState playbackState;
460 playbackState.SetState(1);
461 playbackState.SetSpeed(1);
462 playbackState.SetPosition({80000, 0});
463 playbackState.SetBufferedTime(700000);
464 playbackState.SetLoopMode(1);
465 playbackState.SetFavorite(true);
466 EXPECT_EQ(avsession_->SetAVPlaybackState(playbackState), AVSESSION_SUCCESS);
467 SLOGE("SetAVPlaybackState001 End");
468 }
469
470 /**
471 * @tc.name: SendControlCommand001
472 * @tc.desc: Send control command by remote controller to local device
473 * @tc.type: FUNC
474 * @tc.require: AR000H55F5
475 */
476 HWTEST_F(AVSessionRemoteTest, SendControlCommand001, TestSize.Level1)
477 {
478 SLOGE("SendControlCommand001 Begin");
479 std::shared_ptr<AVSessionController> controller;
480 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
481 ASSERT_EQ(ret, AVSESSION_SUCCESS);
482 ASSERT_NE(controller, nullptr);
483 sleep(1);
484 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
485 SessionToken sessionToken;
486 sessionToken.sessionId = avsession_->GetSessionId();
487 sessionToken.pid = 111;
488 sessionToken.uid = 2222;
489 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
490 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCastAudioCallbackImpl>();
491 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
492 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
493 AVControlCommand cmd;
494 EXPECT_EQ(cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
495 EXPECT_EQ(controller->SendControlCommand(cmd), AVSESSION_SUCCESS);
496 if (controller != nullptr) {
497 ret = controller->Destroy();
498 EXPECT_EQ(ret, AVSESSION_SUCCESS);
499 controller = nullptr;
500 EXPECT_EQ(controller, nullptr);
501 }
502 SLOGE("SendControlCommand001 End");
503 }
504
505 /**
506 * @tc.name: GetController001
507 * @tc.desc: Get controller by session
508 * @tc.type: FUNC
509 * @tc.require: AR000H55F4
510 */
511 HWTEST_F(AVSessionRemoteTest, GetController001, TestSize.Level1)
512 {
513 SLOGE("GetController001 Begin");
514 SessionToken sessionToken;
515 sessionToken.sessionId = avsession_->GetSessionId();
516 sessionToken.pid = 111;
517 sessionToken.uid = 2222;
518 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
519
520 auto controller = avsession_->GetController();
521 ASSERT_NE(controller, nullptr);
522 SLOGE("GetController001 End");
523 }
524
525 /**
526 * @tc.name: GetController002
527 * @tc.desc: The controller fetched twice through session is same
528 * @tc.type: FUNC
529 * @tc.require: AR000H55F4
530 */
531 HWTEST_F(AVSessionRemoteTest, GetController002, TestSize.Level1)
532 {
533 SLOGE("GetController002 Begin");
534 SessionToken sessionToken;
535 sessionToken.sessionId = avsession_->GetSessionId();
536 sessionToken.pid = 111;
537 sessionToken.uid = 2222;
538 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
539
540 auto controller = avsession_->GetController();
541 auto controller1 = avsession_->GetController();
542 ASSERT_NE(controller, nullptr);
543 ASSERT_NE(controller1, nullptr);
544 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
545 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
546 SLOGE("GetController002 End");
547 }
548
549 /**
550 * @tc.name: GetOutputDevice001
551 * @tc.desc: Get output device information by session
552 * @tc.type: FUNC
553 * @tc.require: AR000H55F4
554 */
555 HWTEST_F(AVSessionRemoteTest, GetOutputDevice001, TestSize.Level1)
556 {
557 SLOGE("GetOutputDevice001 Begin");
558 AVSessionDescriptor descriptor;
559 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
560 EXPECT_EQ(ret, AVSESSION_SUCCESS);
561 SLOGE("avsession get deviceIds_ size %{public}d",
562 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
563 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
564 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
565 SLOGE("avsession get deviceNames_ size %{public}d",
566 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
567 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
568 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
569 SLOGE("GetOutputDevice001 End");
570 }
571
572 /**
573 * @tc.name: GetOutputDevice002
574 * @tc.desc: Invalid params for sessionId
575 * @tc.type: FUNC
576 * @tc.require: AR000H55F4
577 */
578 HWTEST_F(AVSessionRemoteTest, GetOutputDevice002, TestSize.Level1)
579 {
580 SLOGE("GetOutputDevice002 Begin");
581 AVSessionDescriptor descriptor;
582 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("123456789", descriptor),
583 AVSESSION_ERROR);
584 SLOGE("GetOutputDevice002 End");
585 }
586
587 /**
588 * @tc.name: GetOutputDevice003
589 * @tc.desc: Invalid params for sessionId
590 * @tc.type: FUNC
591 * @tc.require: AR000H55FQ
592 */
593 HWTEST_F(AVSessionRemoteTest, GetOutputDevice003, TestSize.Level1)
594 {
595 SLOGE("GetOutputDevice003 Begin");
596 AVSessionDescriptor descriptor;
597 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("", descriptor), ERR_INVALID_PARAM);
598 SLOGE("GetOutputDevice003 End");
599 }
600
601 /**
602 * @tc.name: GetOutputDevice004
603 * @tc.desc: Get output device information by controller
604 * @tc.type: FUNC
605 * @tc.require: AR000H55F4
606 */
607 HWTEST_F(AVSessionRemoteTest, GetOutputDevice004, TestSize.Level1)
608 {
609 SLOGE("GetOutputDevice004 Begin");
610 std::shared_ptr<AVSessionController> controller = nullptr;
611 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
612 EXPECT_EQ(ret, AVSESSION_SUCCESS);
613 ASSERT_NE(controller, nullptr);
614
615 AVSessionDescriptor descriptor;
616 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor);
617 EXPECT_EQ(ret, AVSESSION_SUCCESS);
618 SLOGE("controller get deviceIds_ size %{public}d",
619 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
620 SLOGE("controller get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
621 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
622 SLOGE("controller get deviceNames_ size %{public}d",
623 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
624 SLOGE("controller get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
625 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
626 if (controller != nullptr) {
627 ret = controller->Destroy();
628 EXPECT_EQ(ret, AVSESSION_SUCCESS);
629 controller = nullptr;
630 EXPECT_EQ(controller, nullptr);
631 }
632 SLOGE("GetOutputDevice004 End");
633 }
634
635 /**
636 * @tc.name: GetOutputDevice005
637 * @tc.desc: Get same output device information by controller and session
638 * @tc.type: FUNC
639 * @tc.require: AR000H55F4
640 */
641 HWTEST_F(AVSessionRemoteTest, GetOutputDevice005, TestSize.Level1)
642 {
643 SLOGE("GetOutputDevice005 Begin");
644 AVSessionDescriptor descriptor1;
645 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(),
646 descriptor1);
647 EXPECT_EQ(ret, AVSESSION_SUCCESS);
648 ASSERT_NE(descriptor1.outputDeviceInfo_.deviceInfos_.size(), 0);
649
650 std::shared_ptr<AVSessionController> controller = nullptr;
651 ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
652 EXPECT_EQ(ret, AVSESSION_SUCCESS);
653 ASSERT_NE(controller, nullptr);
654
655 AVSessionDescriptor descriptor2;
656 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor2);
657 EXPECT_EQ(ret, AVSESSION_SUCCESS);
658 ASSERT_NE(descriptor2.outputDeviceInfo_.deviceInfos_.size(), 0);
659
660 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_.size(), descriptor2.outputDeviceInfo_.deviceInfos_.size());
661 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_[0].deviceId_,
662 descriptor2.outputDeviceInfo_.deviceInfos_[0].deviceId_);
663 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_[0].deviceName_,
664 descriptor2.outputDeviceInfo_.deviceInfos_[0].deviceName_);
665 if (controller != nullptr) {
666 ret = controller->Destroy();
667 EXPECT_EQ(ret, AVSESSION_SUCCESS);
668 controller = nullptr;
669 }
670 SLOGE("GetOutputDevice005 End");
671 }
672
673 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
674 /**
675 * @tc.name: StartCastDiscovery001
676 * @tc.desc: start cast discovery for default cast type "local"
677 * @tc.type: FUNC
678 * @tc.require: NA
679 */
680 HWTEST_F(AVSessionRemoteTest, StartCastDiscovery001, TestSize.Level1)
681 {
682 SLOGI("StartCastDiscovery001 begin");
683 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(ProtocolType::TYPE_LOCAL, {});
684 EXPECT_EQ(ret, AVSESSION_SUCCESS);
685 SLOGI("StartCastDiscovery001 end");
686 }
687
688 /**
689 * @tc.name: StartCastDiscovery002
690 * @tc.desc: start cast discovery for invalid cast type
691 * @tc.type: FUNC
692 * @tc.require: NA
693 */
694 HWTEST_F(AVSessionRemoteTest, StartCastDiscovery002, TestSize.Level1)
695 {
696 SLOGI("StartCastDiscovery002 begin");
697 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(-1, {});
698 EXPECT_EQ(ret, AVSESSION_SUCCESS);
699 SLOGI("StartCastDiscovery002 end");
700 }
701
702 /**
703 * @tc.name: StopCastDiscovery001
704 * @tc.desc: stop cast discovery success
705 * @tc.type: FUNC
706 * @tc.require: NA
707 */
708 HWTEST_F(AVSessionRemoteTest, StopCastDiscovery001, TestSize.Level1)
709 {
710 SLOGI("StopCastDiscovery001 begin");
711 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(ProtocolType::TYPE_LOCAL, {});
712 EXPECT_EQ(ret, AVSESSION_SUCCESS);
713 ret = AVSessionManager::GetInstance().StopCastDiscovery();
714 EXPECT_EQ(ret, AVSESSION_SUCCESS);
715 SLOGI("StopCastDiscovery001 end");
716 }
717
718 /**
719 * @tc.name: SetDiscoverable001
720 * @tc.desc: setDiscoverable true
721 * @tc.type: FUNC
722 * @tc.require: NA
723 */
724 HWTEST_F(AVSessionRemoteTest, SetDiscoverable001, TestSize.Level1)
725 {
726 SLOGI("SetDiscoverable001 begin");
727 auto ret = AVSessionManager::GetInstance().SetDiscoverable(true);
728 EXPECT_EQ(ret, AVSESSION_SUCCESS);
729 SLOGI("SetDiscoverable001 end");
730 }
731
732 /**
733 * @tc.name: StartCast001
734 * @tc.desc: StartCast success
735 * @tc.type: FUNC
736 * @tc.require: NA
737 */
738 HWTEST_F(AVSessionRemoteTest, StartCast001, TestSize.Level1)
739 {
740 SLOGI("StartCast001 begin");
741 SessionToken sessionToken;
742 sessionToken.sessionId = avsession_->GetSessionId();
743 sessionToken.pid = 111;
744 sessionToken.uid = 2222;
745 OutputDeviceInfo outputDeviceInfo;
746
747 AVSessionDescriptor descriptor;
748 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
749 EXPECT_EQ(ret, AVSESSION_SUCCESS);
750 SLOGE("avsession get deviceIds_ size %{public}d",
751 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
752 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
753 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
754 SLOGE("avsession get deviceNames_ size %{public}d",
755 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
756 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
757 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
758
759 ret = AVSessionManager::GetInstance().StartCast(sessionToken, descriptor.outputDeviceInfo_);
760 EXPECT_NE(ret, AVSESSION_SUCCESS);
761 SLOGI("StartCast001 end");
762 }
763
764 /**
765 * @tc.name: StartCast002
766 * @tc.desc: StartCast invalid params
767 * @tc.type: FUNC
768 * @tc.require: NA
769 */
770 HWTEST_F(AVSessionRemoteTest, StartCast002, TestSize.Level1)
771 {
772 SLOGI("StartCast002 begin");
773 SessionToken sessionToken;
774 OutputDeviceInfo outputDeviceInfo;
775 auto ret = AVSessionManager::GetInstance().StartCast(sessionToken, outputDeviceInfo);
776 EXPECT_NE(ret, AVSESSION_SUCCESS);
777 SLOGI("StartCast002 end");
778 }
779
780 /**
781 * @tc.name: StopCast001
782 * @tc.desc: StopCast success
783 * @tc.type: FUNC
784 * @tc.require: NA
785 */
786 HWTEST_F(AVSessionRemoteTest, StopCast001, TestSize.Level1)
787 {
788 SLOGI("StopCast001 begin");
789 SessionToken sessionToken;
790 sessionToken.sessionId = avsession_->GetSessionId();
791 sessionToken.pid = 111;
792 sessionToken.uid = 2222;
793 OutputDeviceInfo outputDeviceInfo;
794
795 AVSessionDescriptor descriptor;
796 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
797 EXPECT_EQ(ret, AVSESSION_SUCCESS);
798 SLOGE("avsession get deviceIds_ size %{public}d",
799 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
800 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
801 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
802 SLOGE("avsession get deviceNames_ size %{public}d",
803 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
804 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
805 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
806 ret = AVSessionManager::GetInstance().StartCast(sessionToken, descriptor.outputDeviceInfo_);
807 ret = AVSessionManager::GetInstance().StopCast(sessionToken);
808 EXPECT_EQ(ret, AVSESSION_SUCCESS);
809 SLOGI("StopCast001 end");
810 }
811 #endif
812 } // namespace AVSession
813 } // namespace OHOS
814