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