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(int64_t time) override;
183 void OnRewind(int64_t time) override;
184 void OnSeek(int64_t time) override;
185 void OnSetSpeed(double speed) override;
186 void OnSetLoopMode(int32_t loopMode) override;
187 void OnSetTargetLoopMode(int32_t targetLoopMode) override;
188 void OnToggleFavorite(const std::string& mediaId) override;
189 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
190 void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override;
191 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override;
192 void OnSkipToQueueItem(int32_t itemId) override;
OnAVCallAnswer()193 void OnAVCallAnswer() override {};
OnAVCallHangUp()194 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()195 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)196 void OnPlayFromAssetId(int64_t assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)197 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
198
199 ~AVSessionCastAudioCallbackImpl() override;
200 };
201
OnPlay()202 void AVSessionCastAudioCallbackImpl::OnPlay()
203 {
204 g_onCall = AVSESSION_SUCCESS;
205 SLOGE("OnPlay %{public}d", g_onCall);
206 }
207
OnPause()208 void AVSessionCastAudioCallbackImpl::OnPause()
209 {
210 g_onCall = AVSESSION_SUCCESS;
211 SLOGE("OnPause %{public}d", g_onCall);
212 }
213
OnStop()214 void AVSessionCastAudioCallbackImpl::OnStop()
215 {
216 g_onCall = AVSESSION_SUCCESS;
217 SLOGE("OnStop %{public}d", g_onCall);
218 }
219
OnPlayNext()220 void AVSessionCastAudioCallbackImpl::OnPlayNext()
221 {
222 g_onCall = AVSESSION_SUCCESS;
223 SLOGE("OnPlayNext %{public}d", g_onCall);
224 }
225
OnPlayPrevious()226 void AVSessionCastAudioCallbackImpl::OnPlayPrevious()
227 {
228 g_onCall = AVSESSION_SUCCESS;
229 SLOGE("OnPlayPrevious %{public}d", g_onCall);
230 }
231
OnFastForward(int64_t time)232 void AVSessionCastAudioCallbackImpl::OnFastForward(int64_t time)
233 {
234 g_onCall = AVSESSION_SUCCESS;
235 SLOGE("OnFastForward %{public}d", g_onCall);
236 }
237
OnRewind(int64_t time)238 void AVSessionCastAudioCallbackImpl::OnRewind(int64_t time)
239 {
240 g_onCall = AVSESSION_SUCCESS;
241 SLOGE("OnRewind %{public}d", g_onCall);
242 }
243
OnSeek(int64_t time)244 void AVSessionCastAudioCallbackImpl::OnSeek(int64_t time)
245 {
246 SLOGE("OnSeek %{public}" PRId64, time);
247 g_onCall = AVSESSION_SUCCESS;
248 }
249
OnSetSpeed(double speed)250 void AVSessionCastAudioCallbackImpl::OnSetSpeed(double speed)
251 {
252 SLOGE("OnSetSpeed %{public}f", speed);
253 g_onCall = AVSESSION_SUCCESS;
254 SLOGE("OnSetSpeed %{public}d", g_onCall);
255 }
256
OnSetLoopMode(int32_t loopMode)257 void AVSessionCastAudioCallbackImpl::OnSetLoopMode(int32_t loopMode)
258 {
259 SLOGE("OnSetLoopMode %{public}d", loopMode);
260 g_onCall = AVSESSION_SUCCESS;
261 SLOGE("OnSetLoopMode %{public}d", g_onCall);
262 }
263
OnSetTargetLoopMode(int32_t targetLoopMode)264 void AVSessionCastAudioCallbackImpl::OnSetTargetLoopMode(int32_t targetLoopMode)
265 {
266 SLOGE("OnSetTargetLoopMode %{public}d", targetLoopMode);
267 g_onCall = AVSESSION_SUCCESS;
268 SLOGE("OnSetTargetLoopMode %{public}d", g_onCall);
269 }
270
OnToggleFavorite(const std::string & mediaId)271 void AVSessionCastAudioCallbackImpl::OnToggleFavorite(const std::string& mediaId)
272 {
273 SLOGE("OnToggleFavorite %{public}s", mediaId.c_str());
274 g_onCall = AVSESSION_SUCCESS;
275 SLOGE("OnToggleFavorite %{public}d", g_onCall);
276 }
277
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)278 void AVSessionCastAudioCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
279 {
280 SLOGE("OnMediaKeyEvent");
281 g_onCall = AVSESSION_SUCCESS;
282 }
283
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & info)284 void AVSessionCastAudioCallbackImpl::OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& info)
285 {
286 SLOGE("OnOutputDeviceChange");
287 g_onCall = AVSESSION_SUCCESS;
288 }
289
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)290 void AVSessionCastAudioCallbackImpl::OnCommonCommand(const std::string& commonCommand,
291 const OHOS::AAFwk::WantParams& commandArgs)
292 {
293 SLOGI("OnCommonCommand");
294 g_onCall = AVSESSION_SUCCESS;
295 }
296
OnSkipToQueueItem(int32_t itemId)297 void AVSessionCastAudioCallbackImpl::OnSkipToQueueItem(int32_t itemId)
298 {
299 SLOGE("OnSkipToQueueItem %{public}d", itemId);
300 g_onCall = AVSESSION_SUCCESS;
301 SLOGE("OnSetSpeed %{public}d", g_onCall);
302 }
303
~AVSessionCastAudioCallbackImpl()304 AVSessionCastAudioCallbackImpl::~AVSessionCastAudioCallbackImpl()
305 {
306 }
307
308 /**
309 * @tc.name: CastAudio001
310 * @tc.desc: Cast current audio to the remote device
311 * @tc.type: FUNC
312 * @tc.require: AR000H55F4
313 */
314 HWTEST_F(AVSessionRemoteTest, CastAudio001, TestSize.Level1)
315 {
316 SLOGE("CastAudio001 Begin");
317 SessionToken sessionToken;
318 sessionToken.sessionId = avsession_->GetSessionId();
319 sessionToken.pid = 111;
320 sessionToken.uid = 2222;
321 int ret = AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
322 SLOGI("CastAudio001 with ret %{public}d", static_cast<int>(ret));
323 EXPECT_EQ((ret == AVSESSION_SUCCESS || ret == ERR_IPC_SEND_REQUEST), true);
324 SLOGE("CastAudio001 End");
325 }
326
327 /**
328 * @tc.name: CastAudio002
329 * @tc.desc: Invalid params for sessionToken
330 * @tc.type: FUNC
331 * @tc.require: AR000H55F4
332 */
333 HWTEST_F(AVSessionRemoteTest, CastAudio002, TestSize.Level1)
334 {
335 SLOGE("CastAudio002 Begin");
336 SessionToken sessionToken;
337 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_IPC_SEND_REQUEST);
338 SLOGE("CastAudio002 End");
339 }
340
341 /**
342 * @tc.name: CastAudio003
343 * @tc.desc: Invalid params for sessionToken
344 * @tc.type: FUNC
345 * @tc.require: AR000H55F4
346 */
347 HWTEST_F(AVSessionRemoteTest, CastAudio003, TestSize.Level1)
348 {
349 SLOGE("CastAudio003 Begin");
350 SessionToken sessionToken;
351 sessionToken.sessionId = "123456789";
352 sessionToken.pid = 111;
353 sessionToken.uid = 2222;
354 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors), ERR_IPC_SEND_REQUEST);
355 SLOGE("CastAudio003 End");
356 }
357
358 /**
359 * @tc.name: CastAudio004
360 * @tc.desc: Invalid params for descriptors
361 * @tc.type: FUNC
362 * @tc.require: AR000H55F4
363 */
364 HWTEST_F(AVSessionRemoteTest, CastAudio004, TestSize.Level1)
365 {
366 SLOGE("CastAudio004 Begin");
367 SessionToken sessionToken;
368 sessionToken.sessionId = avsession_->GetSessionId();
369 sessionToken.pid = 111;
370 sessionToken.uid = 2222;
371 std::vector<AudioDeviceDescriptor> descriptors;
372 EXPECT_EQ(AVSessionManager::GetInstance().CastAudio(sessionToken, descriptors), ERR_INVALID_PARAM);
373 SLOGE("CastAudio004 End");
374 }
375
376 /**
377 * @tc.name: CastAudioForAll001
378 * @tc.desc: Cast current all audios to the remote device
379 * @tc.type: FUNC
380 * @tc.require: AR000H55F4
381 */
382 HWTEST_F(AVSessionRemoteTest, CastAudioForAll001, TestSize.Level1)
383 {
384 SLOGE("CastAudioForAll001 Begin");
385 int ret = AVSessionManager::GetInstance().CastAudioForAll(g_descriptors);
386 SLOGI("CastAudioForAll001 with ret %{public}d", static_cast<int>(ret));
387 EXPECT_EQ((ret == AVSESSION_SUCCESS || ret == ERR_IPC_SEND_REQUEST), true);
388 SLOGE("CastAudioForAll001 End");
389 }
390
391 /**
392 * @tc.name: CastAudioForAll002
393 * @tc.desc: Invalid params for descriptors
394 * @tc.type: FUNC
395 * @tc.require: AR000H55F4
396 */
397 HWTEST_F(AVSessionRemoteTest, CastAudioForAll002, TestSize.Level1)
398 {
399 SLOGE("CastAudioForAll002 Begin");
400 std::vector<AudioDeviceDescriptor> descriptors;
401 EXPECT_EQ(AVSessionManager::GetInstance().CastAudioForAll(descriptors), ERR_INVALID_PARAM);
402 SLOGE("CastAudioForAll002 End");
403 }
404
405 /**
406 * @tc.name: SetAVMetaData001
407 * @tc.desc: Set av meta data to remote devices
408 * @tc.type: FUNC
409 * @tc.require: AR000H55F4
410 */
411 HWTEST_F(AVSessionRemoteTest, SetAVMetaData001, TestSize.Level1)
412 {
413 SLOGE("SetAVMetaData001 Begin");
414 SessionToken sessionToken;
415 sessionToken.sessionId = avsession_->GetSessionId();
416 sessionToken.pid = 111;
417 sessionToken.uid = 2222;
418 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
419 AVMetaData metaData;
420 metaData.Reset();
421 metaData.SetAssetId("123");
422 metaData.SetTitle("Black Humor");
423 metaData.SetArtist("zhoujielun");
424 metaData.SetAuthor("zhoujielun");
425 metaData.SetAlbum("Jay");
426 metaData.SetWriter("zhoujielun");
427 metaData.SetComposer("zhoujielun");
428 metaData.SetDuration(40000);
429 metaData.SetMediaImageUri("xxxxx");
430 metaData.SetSubTitle("fac");
431 metaData.SetDescription("for friends");
432 metaData.SetLyric("xxxxx");
433 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
434 SLOGE("SetAVMetaData001 End");
435 }
436
437
438 /**
439 * @tc.name: SetAVPlaybackState001
440 * @tc.desc: Set av playback state to remote devices
441 * @tc.type: FUNC
442 * @tc.require: AR000H55F4
443 */
444 HWTEST_F(AVSessionRemoteTest, SetAVPlaybackState001, TestSize.Level1)
445 {
446 SLOGE("SetAVPlaybackState001 Begin");
447 SessionToken sessionToken;
448 sessionToken.sessionId = avsession_->GetSessionId();
449 sessionToken.pid = 111;
450 sessionToken.uid = 2222;
451 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
452 AVMetaData metaData;
453 metaData.Reset();
454 metaData.SetAssetId("playback");
455 metaData.SetDuration(2000000);
456 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
457 AVPlaybackState playbackState;
458 playbackState.SetState(1);
459 playbackState.SetSpeed(1);
460 playbackState.SetPosition({80000, 0});
461 playbackState.SetBufferedTime(700000);
462 playbackState.SetLoopMode(1);
463 playbackState.SetFavorite(true);
464 EXPECT_EQ(avsession_->SetAVPlaybackState(playbackState), AVSESSION_SUCCESS);
465 SLOGE("SetAVPlaybackState001 End");
466 }
467
468 /**
469 * @tc.name: SendControlCommand001
470 * @tc.desc: Send control command by remote controller to local device
471 * @tc.type: FUNC
472 * @tc.require: AR000H55F5
473 */
474 HWTEST_F(AVSessionRemoteTest, SendControlCommand001, TestSize.Level1)
475 {
476 SLOGE("SendControlCommand001 Begin");
477 std::shared_ptr<AVSessionController> controller;
478 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
479 ASSERT_EQ(ret, AVSESSION_SUCCESS);
480 ASSERT_NE(controller, nullptr);
481 sleep(1);
482 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
483 SessionToken sessionToken;
484 sessionToken.sessionId = avsession_->GetSessionId();
485 sessionToken.pid = 111;
486 sessionToken.uid = 2222;
487 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
488 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCastAudioCallbackImpl>();
489 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
490 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
491 AVControlCommand cmd;
492 EXPECT_EQ(cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
493 EXPECT_EQ(controller->SendControlCommand(cmd), AVSESSION_SUCCESS);
494 if (controller != nullptr) {
495 ret = controller->Destroy();
496 EXPECT_EQ(ret, AVSESSION_SUCCESS);
497 controller = nullptr;
498 EXPECT_EQ(controller, nullptr);
499 }
500 SLOGE("SendControlCommand001 End");
501 }
502
503 /**
504 * @tc.name: GetController001
505 * @tc.desc: Get controller by session
506 * @tc.type: FUNC
507 * @tc.require: AR000H55F4
508 */
509 HWTEST_F(AVSessionRemoteTest, GetController001, TestSize.Level1)
510 {
511 SLOGE("GetController001 Begin");
512 SessionToken sessionToken;
513 sessionToken.sessionId = avsession_->GetSessionId();
514 sessionToken.pid = 111;
515 sessionToken.uid = 2222;
516 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
517
518 auto controller = avsession_->GetController();
519 ASSERT_NE(controller, nullptr);
520 SLOGE("GetController001 End");
521 }
522
523 /**
524 * @tc.name: GetController002
525 * @tc.desc: The controller fetched twice through session is same
526 * @tc.type: FUNC
527 * @tc.require: AR000H55F4
528 */
529 HWTEST_F(AVSessionRemoteTest, GetController002, TestSize.Level1)
530 {
531 SLOGE("GetController002 Begin");
532 SessionToken sessionToken;
533 sessionToken.sessionId = avsession_->GetSessionId();
534 sessionToken.pid = 111;
535 sessionToken.uid = 2222;
536 AVSessionManager::GetInstance().CastAudio(sessionToken, g_descriptors);
537
538 auto controller = avsession_->GetController();
539 auto controller1 = avsession_->GetController();
540 ASSERT_NE(controller, nullptr);
541 ASSERT_NE(controller1, nullptr);
542 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
543 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
544 SLOGE("GetController002 End");
545 }
546
547 /**
548 * @tc.name: GetOutputDevice001
549 * @tc.desc: Get output device information by session
550 * @tc.type: FUNC
551 * @tc.require: AR000H55F4
552 */
553 HWTEST_F(AVSessionRemoteTest, GetOutputDevice001, TestSize.Level1)
554 {
555 SLOGE("GetOutputDevice001 Begin");
556 AVSessionDescriptor descriptor;
557 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
558 EXPECT_EQ(ret, AVSESSION_SUCCESS);
559 SLOGE("avsession get deviceIds_ size %{public}d",
560 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
561 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
562 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
563 SLOGE("avsession get deviceNames_ size %{public}d",
564 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
565 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
566 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
567 SLOGE("GetOutputDevice001 End");
568 }
569
570 /**
571 * @tc.name: GetOutputDevice002
572 * @tc.desc: Invalid params for sessionId
573 * @tc.type: FUNC
574 * @tc.require: AR000H55F4
575 */
576 HWTEST_F(AVSessionRemoteTest, GetOutputDevice002, TestSize.Level1)
577 {
578 SLOGE("GetOutputDevice002 Begin");
579 AVSessionDescriptor descriptor;
580 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("123456789", descriptor),
581 AVSESSION_ERROR);
582 SLOGE("GetOutputDevice002 End");
583 }
584
585 /**
586 * @tc.name: GetOutputDevice003
587 * @tc.desc: Invalid params for sessionId
588 * @tc.type: FUNC
589 * @tc.require: AR000H55FQ
590 */
591 HWTEST_F(AVSessionRemoteTest, GetOutputDevice003, TestSize.Level1)
592 {
593 SLOGE("GetOutputDevice003 Begin");
594 AVSessionDescriptor descriptor;
595 EXPECT_EQ(AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId("", descriptor), ERR_INVALID_PARAM);
596 SLOGE("GetOutputDevice003 End");
597 }
598
599 /**
600 * @tc.name: GetOutputDevice004
601 * @tc.desc: Get output device information by controller
602 * @tc.type: FUNC
603 * @tc.require: AR000H55F4
604 */
605 HWTEST_F(AVSessionRemoteTest, GetOutputDevice004, TestSize.Level1)
606 {
607 SLOGE("GetOutputDevice004 Begin");
608 std::shared_ptr<AVSessionController> controller = nullptr;
609 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
610 EXPECT_EQ(ret, AVSESSION_SUCCESS);
611 ASSERT_NE(controller, nullptr);
612
613 AVSessionDescriptor descriptor;
614 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor);
615 EXPECT_EQ(ret, AVSESSION_SUCCESS);
616 SLOGE("controller get deviceIds_ size %{public}d",
617 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
618 SLOGE("controller get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
619 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
620 SLOGE("controller get deviceNames_ size %{public}d",
621 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
622 SLOGE("controller get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
623 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
624 if (controller != nullptr) {
625 ret = controller->Destroy();
626 EXPECT_EQ(ret, AVSESSION_SUCCESS);
627 controller = nullptr;
628 EXPECT_EQ(controller, nullptr);
629 }
630 SLOGE("GetOutputDevice004 End");
631 }
632
633 /**
634 * @tc.name: GetOutputDevice005
635 * @tc.desc: Get same output device information by controller and session
636 * @tc.type: FUNC
637 * @tc.require: AR000H55F4
638 */
639 HWTEST_F(AVSessionRemoteTest, GetOutputDevice005, TestSize.Level1)
640 {
641 SLOGE("GetOutputDevice005 Begin");
642 AVSessionDescriptor descriptor1;
643 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(),
644 descriptor1);
645 EXPECT_EQ(ret, AVSESSION_SUCCESS);
646 ASSERT_NE(descriptor1.outputDeviceInfo_.deviceInfos_.size(), 0);
647
648 std::shared_ptr<AVSessionController> controller = nullptr;
649 ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller);
650 EXPECT_EQ(ret, AVSESSION_SUCCESS);
651 ASSERT_NE(controller, nullptr);
652
653 AVSessionDescriptor descriptor2;
654 ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(controller->GetSessionId(), descriptor2);
655 EXPECT_EQ(ret, AVSESSION_SUCCESS);
656 ASSERT_NE(descriptor2.outputDeviceInfo_.deviceInfos_.size(), 0);
657
658 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_.size(), descriptor2.outputDeviceInfo_.deviceInfos_.size());
659 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_[0].deviceId_,
660 descriptor2.outputDeviceInfo_.deviceInfos_[0].deviceId_);
661 EXPECT_EQ(descriptor1.outputDeviceInfo_.deviceInfos_[0].deviceName_,
662 descriptor2.outputDeviceInfo_.deviceInfos_[0].deviceName_);
663 if (controller != nullptr) {
664 ret = controller->Destroy();
665 EXPECT_EQ(ret, AVSESSION_SUCCESS);
666 controller = nullptr;
667 }
668 SLOGE("GetOutputDevice005 End");
669 }
670
671 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
672 /**
673 * @tc.name: StartCastDiscovery001
674 * @tc.desc: start cast discovery for default cast type "local"
675 * @tc.type: FUNC
676 * @tc.require: NA
677 */
678 HWTEST_F(AVSessionRemoteTest, StartCastDiscovery001, TestSize.Level1)
679 {
680 SLOGI("StartCastDiscovery001 begin");
681 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(ProtocolType::TYPE_LOCAL, {});
682 EXPECT_EQ(ret, AVSESSION_SUCCESS);
683 SLOGI("StartCastDiscovery001 end");
684 }
685
686 /**
687 * @tc.name: StartCastDiscovery002
688 * @tc.desc: start cast discovery for invalid cast type
689 * @tc.type: FUNC
690 * @tc.require: NA
691 */
692 HWTEST_F(AVSessionRemoteTest, StartCastDiscovery002, TestSize.Level1)
693 {
694 SLOGI("StartCastDiscovery002 begin");
695 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(-1, {});
696 EXPECT_EQ(ret, AVSESSION_SUCCESS);
697 SLOGI("StartCastDiscovery002 end");
698 }
699
700 /**
701 * @tc.name: StopCastDiscovery001
702 * @tc.desc: stop cast discovery success
703 * @tc.type: FUNC
704 * @tc.require: NA
705 */
706 HWTEST_F(AVSessionRemoteTest, StopCastDiscovery001, TestSize.Level1)
707 {
708 SLOGI("StopCastDiscovery001 begin");
709 auto ret = AVSessionManager::GetInstance().StartCastDiscovery(ProtocolType::TYPE_LOCAL, {});
710 EXPECT_EQ(ret, AVSESSION_SUCCESS);
711 ret = AVSessionManager::GetInstance().StopCastDiscovery();
712 EXPECT_EQ(ret, AVSESSION_SUCCESS);
713 SLOGI("StopCastDiscovery001 end");
714 }
715
716 /**
717 * @tc.name: SetDiscoverable001
718 * @tc.desc: setDiscoverable true
719 * @tc.type: FUNC
720 * @tc.require: NA
721 */
722 HWTEST_F(AVSessionRemoteTest, SetDiscoverable001, TestSize.Level1)
723 {
724 SLOGI("SetDiscoverable001 begin");
725 auto ret = AVSessionManager::GetInstance().SetDiscoverable(true);
726 EXPECT_EQ(ret, AVSESSION_SUCCESS);
727 SLOGI("SetDiscoverable001 end");
728 }
729
730 /**
731 * @tc.name: StartCast001
732 * @tc.desc: StartCast success
733 * @tc.type: FUNC
734 * @tc.require: NA
735 */
736 HWTEST_F(AVSessionRemoteTest, StartCast001, TestSize.Level1)
737 {
738 SLOGI("StartCast001 begin");
739 SessionToken sessionToken;
740 sessionToken.sessionId = avsession_->GetSessionId();
741 sessionToken.pid = 111;
742 sessionToken.uid = 2222;
743 OutputDeviceInfo outputDeviceInfo;
744
745 AVSessionDescriptor descriptor;
746 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
747 EXPECT_EQ(ret, AVSESSION_SUCCESS);
748 SLOGE("avsession get deviceIds_ size %{public}d",
749 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
750 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
751 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
752 SLOGE("avsession get deviceNames_ size %{public}d",
753 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
754 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
755 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
756
757 ret = AVSessionManager::GetInstance().StartCast(sessionToken, descriptor.outputDeviceInfo_);
758 EXPECT_NE(ret, AVSESSION_SUCCESS);
759 SLOGI("StartCast001 end");
760 }
761
762 /**
763 * @tc.name: StartCast002
764 * @tc.desc: StartCast invalid params
765 * @tc.type: FUNC
766 * @tc.require: NA
767 */
768 HWTEST_F(AVSessionRemoteTest, StartCast002, TestSize.Level1)
769 {
770 SLOGI("StartCast002 begin");
771 SessionToken sessionToken;
772 OutputDeviceInfo outputDeviceInfo;
773 auto ret = AVSessionManager::GetInstance().StartCast(sessionToken, outputDeviceInfo);
774 EXPECT_NE(ret, AVSESSION_SUCCESS);
775 SLOGI("StartCast002 end");
776 }
777
778 /**
779 * @tc.name: StopCast001
780 * @tc.desc: StopCast success
781 * @tc.type: FUNC
782 * @tc.require: NA
783 */
784 HWTEST_F(AVSessionRemoteTest, StopCast001, TestSize.Level1)
785 {
786 SLOGI("StopCast001 begin");
787 SessionToken sessionToken;
788 sessionToken.sessionId = avsession_->GetSessionId();
789 sessionToken.pid = 111;
790 sessionToken.uid = 2222;
791 OutputDeviceInfo outputDeviceInfo;
792
793 AVSessionDescriptor descriptor;
794 auto ret = AVSessionManager::GetInstance().GetSessionDescriptorsBySessionId(avsession_->GetSessionId(), descriptor);
795 EXPECT_EQ(ret, AVSESSION_SUCCESS);
796 SLOGE("avsession get deviceIds_ size %{public}d",
797 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
798 SLOGE("avsession get deviceId0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceId_.c_str());
799 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
800 SLOGE("avsession get deviceNames_ size %{public}d",
801 static_cast<int32_t>(descriptor.outputDeviceInfo_.deviceInfos_.size()));
802 SLOGE("avsession get deviceName0 %{public}s", descriptor.outputDeviceInfo_.deviceInfos_[0].deviceName_.c_str());
803 ASSERT_NE(descriptor.outputDeviceInfo_.deviceInfos_.size(), 0);
804 ret = AVSessionManager::GetInstance().StartCast(sessionToken, descriptor.outputDeviceInfo_);
805 ret = AVSessionManager::GetInstance().StopCast(sessionToken);
806 EXPECT_EQ(ret, AVSESSION_SUCCESS);
807 SLOGI("StopCast001 end");
808 }
809 #endif
810 } // namespace AVSession
811 } // namespace OHOS
812