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