1 /*
2 * Copyright (c) 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 "accesstoken_kit.h"
19 #include "nativetoken_kit.h"
20 #include "token_setproc.h"
21 #include "cast_session_manager.h"
22 #include "avcast_controller_item.h"
23 #include "avsession_errors.h"
24 #include "avsession_log.h"
25 #include "hw_cast_provider.h"
26 #include "hw_cast_stream_player.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::CastEngine::CastEngineClient;
30 using namespace OHOS::CastEngine;
31
32 namespace OHOS {
33 namespace AVSession {
34 class HwCastStreamPlayerTest : public testing::TestWithParam<int> {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 std::shared_ptr<HwCastProviderSession> hwCastProviderSession = nullptr;
41 std::shared_ptr<HwCastStreamPlayer> hwCastStreamPlayer = nullptr;
42 };
43
44 class TestCastSessionManagerListener : public ICastSessionManagerListener {
45 public:
OnDeviceFound(const std::vector<CastRemoteDevice> & deviceList)46 void OnDeviceFound(const std::vector<CastRemoteDevice> &deviceList) override
47 {
48 static_cast<void>(deviceList);
49 }
OnSessionCreated(const std::shared_ptr<ICastSession> & castSession)50 void OnSessionCreated(const std::shared_ptr<ICastSession> &castSession) override
51 {
52 static_cast<void>(castSession);
53 }
OnServiceDied()54 void OnServiceDied() override {}
OnDeviceOffline(const std::string & deviceId)55 void OnDeviceOffline(const std::string &deviceId) override
56 {
57 static_cast<void>(deviceId);
58 }
59 };
60
61 class StreamPlayerIMock : public OHOS::CastEngine::IStreamPlayer {
62 public:
GetPosition(int32_t & currentPosition)63 int GetPosition(int32_t& currentPosition) override { return 0; }
Seek(int32_t position)64 int Seek(int32_t position) override { return 0; }
SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed)65 int SetSpeed(const OHOS::CastEngine::PlaybackSpeed speed) override { return 0; }
FastForward(const int32_t delta)66 int FastForward(const int32_t delta) override { return 0; }
FastRewind(const int32_t delta)67 int FastRewind(const int32_t delta) override { return 0; }
SetVolume(const int32_t volume)68 int SetVolume(const int32_t volume) override { return 0; }
SetMute(bool mute)69 int SetMute(bool mute) override { return 0; }
ProvideKeyResponse(const std::string & mediaId,const std::vector<uint8_t> & response)70 int ProvideKeyResponse(const std::string &mediaId, const std::vector<uint8_t> &response) override { return 0; }
SetLoopMode(const OHOS::CastEngine::LoopMode loopMode)71 int SetLoopMode(const OHOS::CastEngine::LoopMode loopMode) override { return 0; }
RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener)72 int RegisterListener(std::shared_ptr<OHOS::CastEngine::IStreamPlayerListener> listener) override { return 0; }
UnregisterListener()73 int UnregisterListener() override { return 0; }
SetSurface(const std::string & surfaceInfo)74 int SetSurface(const std::string &surfaceInfo) override { return 0; }
Load(const OHOS::CastEngine::MediaInfo & media)75 int Load(const OHOS::CastEngine::MediaInfo &media) override { return 0; }
Play()76 int Play() override { return 0; }
Play(const OHOS::CastEngine::MediaInfo & media)77 int Play(const OHOS::CastEngine::MediaInfo &media) override { return 0; }
Play(int index)78 int Play(int index) override { return 0; }
Pause()79 int Pause() override { return 0; }
Stop()80 int Stop() override { return 0; }
Next()81 int Next() override { return 0; }
Previous()82 int Previous() override { return 0; }
GetPlayerStatus(OHOS::CastEngine::PlayerStates & status)83 int GetPlayerStatus(OHOS::CastEngine::PlayerStates &status) override { return 0; }
GetDuration(int & duration)84 int GetDuration(int &duration) override { return 0; }
GetVolume(int32_t & volume,int32_t & maxVolume)85 int GetVolume(int32_t &volume, int32_t &maxVolume) override { return 0; }
GetMute(bool & mute)86 int GetMute(bool &mute) override { return 0; }
GetLoopMode(OHOS::CastEngine::LoopMode & loopMode)87 int GetLoopMode(OHOS::CastEngine::LoopMode &loopMode) override { return 0; }
GetMediaCapabilities(std::string & jsonCapabilities)88 int GetMediaCapabilities(std::string &jsonCapabilities) override { return 0; }
GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed & speed)89 int GetPlaySpeed(OHOS::CastEngine::PlaybackSpeed &speed) override { return 0; }
GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder & hold)90 int GetMediaInfoHolder(OHOS::CastEngine::MediaInfoHolder &hold) override { return 0; }
SetAvailableCapability(const OHOS::CastEngine::StreamCapability & streamCapability)91 int SetAvailableCapability(const OHOS::CastEngine::StreamCapability &streamCapability) override { return 0; }
GetAvailableCapability(OHOS::CastEngine::StreamCapability & streamCapability)92 int GetAvailableCapability(OHOS::CastEngine::StreamCapability &streamCapability) override { return 0; }
Release()93 int Release() override { return 0; }
94 };
95
CreateSession()96 std::shared_ptr<ICastSession> CreateSession()
97 {
98 std::shared_ptr<ICastSession> session;
99 auto listener = std::make_shared<TestCastSessionManagerListener>();
100 CastSessionManager::GetInstance().RegisterListener(listener);
101 CastSessionProperty property = {CastEngine::ProtocolType::CAST_PLUS_STREAM, CastEngine::EndType::CAST_SOURCE};
102 CastSessionManager::GetInstance().CreateCastSession(property, session);
103 return session;
104 }
105
CreateAVMediaDescription()106 std::shared_ptr<AVMediaDescription> CreateAVMediaDescription()
107 {
108 std::shared_ptr<AVMediaDescription> description = std::make_shared<AVMediaDescription>();
109 description->Reset();
110 description->SetMediaId("123");
111 description->SetTitle("Title");
112 description->SetSubtitle("SubTitle");
113 description->SetDescription("This is music description");
114 description->SetIcon(nullptr);
115 description->SetIconUri("xxxxx");
116 description->SetExtras(nullptr);
117 return description;
118 }
119
SetUpTestCase()120 void HwCastStreamPlayerTest::SetUpTestCase()
121 {}
122
TearDownTestCase()123 void HwCastStreamPlayerTest::TearDownTestCase()
124 {}
125
SetUp()126 void HwCastStreamPlayerTest::SetUp()
127 {
128 constexpr int castPermissionNum = 2;
129 const char *perms[castPermissionNum] = {
130 "ohos.permission.ACCESS_CAST_ENGINE_MIRROR",
131 "ohos.permission.ACCESS_CAST_ENGINE_STREAM",
132 };
133 NativeTokenInfoParams infoInstance = {
134 .dcapsNum = 0, // Indicates the capsbility list of the sa.
135 .permsNum = castPermissionNum,
136 .aclsNum = 0, // acls is the list of rights that can be escalated.
137 .dcaps = nullptr,
138 .perms = perms,
139 .acls = nullptr,
140 .processName = "hw_cast_stream_player_test",
141 .aplStr = "system_basic",
142 };
143 uint64_t tokenId = GetAccessTokenId(&infoInstance);
144 SetSelfTokenID(tokenId);
145 Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
146 std::shared_ptr<ICastSession> castSession = CreateSession();
147 hwCastProviderSession = std::make_shared<HwCastProviderSession>(castSession);
148 if (hwCastProviderSession) {
149 hwCastProviderSession->Init();
150 }
151 std::shared_ptr<IStreamPlayer> streamPlayer = hwCastProviderSession->CreateStreamPlayer();
152 hwCastStreamPlayer = std::make_shared<HwCastStreamPlayer>(streamPlayer);
153 if (hwCastStreamPlayer) {
154 hwCastStreamPlayer->Init();
155 hwCastStreamPlayer->streamPlayer_ = std::make_shared<StreamPlayerIMock>();
156 }
157 }
158
TearDown()159 void HwCastStreamPlayerTest::TearDown()
160 {
161 if (hwCastProviderSession) {
162 hwCastProviderSession->Release();
163 }
164 if (hwCastStreamPlayer) {
165 hwCastStreamPlayer->Release();
166 }
167 }
168
169 INSTANTIATE_TEST_CASE_P(SendControlCommand, HwCastStreamPlayerTest, testing::Values(
170 AVCastControlCommand::CAST_CONTROL_CMD_INVALID,
171 AVCastControlCommand::CAST_CONTROL_CMD_PLAY,
172 AVCastControlCommand::CAST_CONTROL_CMD_PAUSE,
173 AVCastControlCommand::CAST_CONTROL_CMD_STOP,
174 AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT,
175 AVCastControlCommand::CAST_CONTROL_CMD_PLAY_PREVIOUS,
176 AVCastControlCommand::CAST_CONTROL_CMD_FAST_FORWARD,
177 AVCastControlCommand::CAST_CONTROL_CMD_REWIND,
178 AVCastControlCommand::CAST_CONTROL_CMD_SEEK,
179 AVCastControlCommand::CAST_CONTROL_CMD_SET_VOLUME,
180 AVCastControlCommand::CAST_CONTROL_CMD_SET_SPEED,
181 AVCastControlCommand::CAST_CONTROL_CMD_SET_LOOP_MODE,
182 AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_FAVORITE,
183 AVCastControlCommand::CAST_CONTROL_CMD_TOGGLE_MUTE,
184 AVCastControlCommand::CAST_CONTROL_CMD_MAX
185 ));
186
187 static const int32_t DURATION_TIME = 40000;
GetAVMetaData()188 static OHOS::AVSession::AVMetaData GetAVMetaData()
189 {
190 OHOS::AVSession::AVMetaData g_metaData;
191 g_metaData.Reset();
192 g_metaData.SetAssetId("123");
193 g_metaData.SetTitle("Black Humor");
194 g_metaData.SetArtist("zhoujielun");
195 g_metaData.SetAuthor("zhoujielun");
196 g_metaData.SetAlbum("Jay");
197 g_metaData.SetWriter("zhoujielun");
198 g_metaData.SetComposer("zhoujielun");
199 g_metaData.SetDuration(DURATION_TIME);
200 g_metaData.SetMediaImageUri("xxxxx");
201 g_metaData.SetSubTitle("fac");
202 g_metaData.SetDescription("for friends");
203 g_metaData.SetLyric("xxxxx");
204 return g_metaData;
205 }
206
207 /**
208 * @tc.name: SendControlCommand001
209 * @tc.desc: SendControlCommand all test
210 * @tc.type: FUNC
211 * @tc.require: NA
212 */
213 HWTEST_P(HwCastStreamPlayerTest, SendControlCommand001, TestSize.Level1)
214 {
215 SLOGI("SendControlCommand001 begin!");
216 AVCastControlCommand command;
217 int32_t cmd = GetParam();
218 if (cmd == AVCastControlCommand::CAST_CONTROL_CMD_INVALID || cmd == AVCastControlCommand::CAST_CONTROL_CMD_MAX) {
219 ASSERT_EQ(command.SetCommand(cmd), ERR_INVALID_PARAM);
220 } else {
221 ASSERT_EQ(command.SetCommand(cmd), AVSESSION_SUCCESS);
222 }
223 hwCastStreamPlayer->SendControlCommand(command);
224 SLOGI("SendControlCommand001 end!");
225 }
226
227 /**
228 * @tc.name: Start001
229 * @tc.desc: start no media id and fd src
230 * @tc.type: FUNC
231 * @tc.require: NA
232 */
233 HWTEST_F(HwCastStreamPlayerTest, Start001, TestSize.Level1)
234 {
235 SLOGI("Start001 begin!");
236 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
237 description->SetMediaUri("");
238 AVQueueItem avQueueItem;
239 avQueueItem.SetDescription(description);
240 auto ret = hwCastStreamPlayer->Start(avQueueItem);
241 ASSERT_EQ(ret, AVSESSION_SUCCESS);
242 SLOGI("Start001 end!");
243 }
244
245 /**
246 * @tc.name: Start002
247 * @tc.desc: start with fd src
248 * @tc.type: FUNC
249 * @tc.require: NA
250 */
251 HWTEST_F(HwCastStreamPlayerTest, Start002, TestSize.Level1)
252 {
253 SLOGI("Start002 begin!");
254 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
255 description->SetMediaUri("");
256 // do not use fd of descriptor which cause crash
257 AVQueueItem avQueueItem;
258 avQueueItem.SetDescription(description);
259 auto ret = hwCastStreamPlayer->Start(avQueueItem);
260 ASSERT_EQ(ret, AVSESSION_SUCCESS);
261 SLOGI("Start002 end!");
262 }
263
264 /**
265 * @tc.name: Start003
266 * @tc.desc: start same media
267 * @tc.type: FUNC
268 * @tc.require: NA
269 */
270 HWTEST_F(HwCastStreamPlayerTest, Start003, TestSize.Level1)
271 {
272 SLOGI("Start003 begin!");
273 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
274 description->SetMediaUri("Media url");
275 AVQueueItem avQueueItem;
276 avQueueItem.SetDescription(description);
277 auto ret = hwCastStreamPlayer->Start(avQueueItem);
278 ASSERT_EQ(ret, AVSESSION_SUCCESS);
279 hwCastStreamPlayer->Start(avQueueItem);
280 SLOGI("Start003 end!");
281 }
282
283 /**
284 * @tc.name: Prepare001
285 * @tc.desc: prepare no media id and fd src
286 * @tc.type: FUNC
287 * @tc.require: NA
288 */
289 HWTEST_F(HwCastStreamPlayerTest, Prepare001, TestSize.Level1)
290 {
291 SLOGI("Prepare001 begin!");
292 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
293 description->SetMediaUri("");
294 AVQueueItem avQueueItem;
295 avQueueItem.SetDescription(description);
296 auto ret = hwCastStreamPlayer->Start(avQueueItem);
297 ASSERT_EQ(ret, AVSESSION_SUCCESS);
298 ret = hwCastStreamPlayer->Prepare(avQueueItem);
299 ASSERT_EQ(ret, AVSESSION_SUCCESS);
300 SLOGI("Prepare001 end!");
301 }
302
303 /**
304 * @tc.name: Prepare002
305 * @tc.desc: prepare with fd src
306 * @tc.type: FUNC
307 * @tc.require: NA
308 */
309 HWTEST_F(HwCastStreamPlayerTest, Prepare002, TestSize.Level1)
310 {
311 SLOGI("Prepare002 begin!");
312 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
313 description->SetMediaUri("");
314 // do not use fd of descriptor which cause crash
315 AVQueueItem avQueueItem;
316 avQueueItem.SetDescription(description);
317 auto ret = hwCastStreamPlayer->Start(avQueueItem);
318 ASSERT_EQ(ret, AVSESSION_SUCCESS);
319 ret = hwCastStreamPlayer->Prepare(avQueueItem);
320 ASSERT_EQ(ret, AVSESSION_SUCCESS);
321 SLOGI("Prepare002 end!");
322 }
323
324 /**
325 * @tc.name: GetDuration001
326 * @tc.desc: GetDuration
327 * @tc.type: FUNC
328 * @tc.require: NA
329 */
330 HWTEST_F(HwCastStreamPlayerTest, GetDuration001, TestSize.Level1)
331 {
332 SLOGI("GetDuration001 begin!");
333 int32_t duration = 40000;
334 ASSERT_EQ(hwCastStreamPlayer->GetDuration(duration), AVSESSION_SUCCESS);
335 SLOGI("GetDuration001 end!");
336 }
337
338 /**
339 * @tc.name: GetCastAVPlaybackState001
340 * @tc.desc: GetCastAVPlaybackState
341 * @tc.type: FUNC
342 * @tc.require: NA
343 */
344 HWTEST_F(HwCastStreamPlayerTest, GetCastAVPlaybackState001, TestSize.Level1)
345 {
346 SLOGI("GetCastAVPlaybackState001 begin!");
347 AVPlaybackState state;
348 ASSERT_EQ(hwCastStreamPlayer->GetCastAVPlaybackState(state), AVSESSION_SUCCESS);
349 SLOGI("GetCastAVPlaybackState001 end!");
350 }
351
352 /**
353 * @tc.name: SetDisplaySurface001
354 * @tc.desc: SetDisplaySurface
355 * @tc.type: FUNC
356 * @tc.require: NA
357 */
358 HWTEST_F(HwCastStreamPlayerTest, SetDisplaySurface001, TestSize.Level1)
359 {
360 SLOGI("SetDisplaySurface001 begin!");
361 std::string surfaceId = "surfaceId";
362 ASSERT_EQ(hwCastStreamPlayer->SetDisplaySurface(surfaceId), AVSESSION_SUCCESS);
363 SLOGI("SetDisplaySurface001 end!");
364 }
365
366 /**
367 * @tc.name: ProcessMediaKeyResponse001
368 * @tc.desc: ProcessMediaKeyResponse
369 * @tc.type: FUNC
370 * @tc.require: NA
371 */
372 HWTEST_F(HwCastStreamPlayerTest, ProcessMediaKeyResponse001, TestSize.Level1)
373 {
374 SLOGI("ProcessMediaKeyResponse001 begin!");
375 std::string assetId = "assetId";
376 std::vector<uint8_t> response;
377 ASSERT_EQ(hwCastStreamPlayer->ProcessMediaKeyResponse(assetId, response), AVSESSION_SUCCESS);
378 SLOGI("ProcessMediaKeyResponse001 end!");
379 }
380
381 /**
382 * @tc.name: RegisterControllerListener001
383 * @tc.desc: RegisterControllerListener invalid listener
384 * @tc.type: FUNC
385 * @tc.require: NA
386 */
387 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener001, TestSize.Level1)
388 {
389 SLOGI("RegisterControllerListener001 begin!");
390 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(nullptr), AVSESSION_ERROR);
391 SLOGI("RegisterControllerListener001 end!");
392 }
393
394 /**
395 * @tc.name: RegisterControllerListener002
396 * @tc.desc: RegisterControllerListener repeat
397 * @tc.type: FUNC
398 * @tc.require: NA
399 */
400 HWTEST_F(HwCastStreamPlayerTest, RegisterControllerListener002, TestSize.Level1)
401 {
402 SLOGI("RegisterControllerListener002 begin!");
403 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
404 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
405 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_ERROR);
406 SLOGI("RegisterControllerListener002 end!");
407 }
408
409 /**
410 * @tc.name: UnRegisterControllerListener001
411 * @tc.desc: UnRegisterControllerListener invalid listener
412 * @tc.type: FUNC
413 * @tc.require: NA
414 */
415 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener001, TestSize.Level1)
416 {
417 SLOGI("UnRegisterControllerListener001 begin!");
418 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(nullptr), AVSESSION_ERROR);
419 SLOGI("UnRegisterControllerListener001 end!");
420 }
421
422 /**
423 * @tc.name: UnRegisterControllerListener002
424 * @tc.desc: UnRegisterControllerListener success
425 * @tc.type: FUNC
426 * @tc.require: NA
427 */
428 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener002, TestSize.Level1)
429 {
430 SLOGI("UnRegisterControllerListener002 begin!");
431 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
432 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
433 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
434 SLOGI("UnRegisterControllerListener002 end!");
435 }
436
437 /**
438 * @tc.name: UnRegisterControllerListener003
439 * @tc.desc: UnRegisterControllerListener failed
440 * @tc.type: FUNC
441 * @tc.require: NA
442 */
443 HWTEST_F(HwCastStreamPlayerTest, UnRegisterControllerListener003, TestSize.Level1)
444 {
445 SLOGI("UnRegisterControllerListener003 begin!");
446 std::shared_ptr<AVCastControllerItem> avCastControllerItem1 = std::make_shared<AVCastControllerItem>();
447 std::shared_ptr<AVCastControllerItem> avCastControllerItem2 = std::make_shared<AVCastControllerItem>();
448 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem1), AVSESSION_SUCCESS);
449 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem2), AVSESSION_ERROR);
450 SLOGI("UnRegisterControllerListener003 end!");
451 }
452
453 /**
454 * @tc.name: OnStateChanged001
455 * @tc.desc: OnStateChanged
456 * @tc.type: FUNC
457 * @tc.require: NA
458 */
459 HWTEST_F(HwCastStreamPlayerTest, OnStateChanged001, TestSize.Level1)
460 {
461 SLOGI("OnStateChanged001 begin!");
462 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
463 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
464 hwCastStreamPlayer->OnStateChanged(CastEngine::PlayerStates::PLAYER_INITIALIZED, true);
465 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
466 SLOGI("OnStateChanged001 end!");
467 }
468
469 /**
470 * @tc.name: OnPositionChanged001
471 * @tc.desc: OnPositionChanged invalid
472 * @tc.type: FUNC
473 * @tc.require: NA
474 */
475 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged001, TestSize.Level1)
476 {
477 SLOGI("OnPositionChanged001 begin!");
478 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
479 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
480 hwCastStreamPlayer->OnPositionChanged(-1, -1, -1);
481 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
482 SLOGI("OnPositionChanged001 end!");
483 }
484
485 /**
486 * @tc.name: OnPositionChanged002
487 * @tc.desc: OnPositionChanged
488 * @tc.type: FUNC
489 * @tc.require: NA
490 */
491 HWTEST_F(HwCastStreamPlayerTest, OnPositionChanged002, TestSize.Level1)
492 {
493 SLOGI("OnPositionChanged002 begin!");
494 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
495 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
496 hwCastStreamPlayer->OnPositionChanged(0, 0, 10);
497 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
498 SLOGI("OnPositionChanged002 end!");
499 }
500
501 /**
502 * @tc.name: OnMediaItemChanged001
503 * @tc.desc: OnMediaItemChanged
504 * @tc.type: FUNC
505 * @tc.require: NA
506 */
507 HWTEST_F(HwCastStreamPlayerTest, OnMediaItemChanged001, TestSize.Level1)
508 {
509 SLOGI("OnMediaItemChanged001 begin!");
510 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
511 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
512 CastEngine::MediaInfo mediaInfo;
513 hwCastStreamPlayer->OnMediaItemChanged(mediaInfo);
514 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
515 SLOGI("OnMediaItemChanged001 end!");
516 }
517
518 /**
519 * @tc.name: OnNextRequest001
520 * @tc.desc: OnNextRequest
521 * @tc.type: FUNC
522 * @tc.require: NA
523 */
524 HWTEST_F(HwCastStreamPlayerTest, OnNextRequest001, TestSize.Level1)
525 {
526 SLOGI("OnNextRequest001 begin!");
527 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
528 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
529 hwCastStreamPlayer->OnNextRequest();
530 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
531 SLOGI("OnNextRequest001 end!");
532 }
533
534 /**
535 * @tc.name: OnPreviousRequest001
536 * @tc.desc: OnPreviousRequest
537 * @tc.type: FUNC
538 * @tc.require: NA
539 */
540 HWTEST_F(HwCastStreamPlayerTest, OnPreviousRequest001, TestSize.Level1)
541 {
542 SLOGI("OnPreviousRequest001 begin!");
543 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
544 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
545 hwCastStreamPlayer->OnPreviousRequest();
546 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
547 SLOGI("OnPreviousRequest001 end!");
548 }
549
550 /**
551 * @tc.name: OnVolumeChanged001
552 * @tc.desc: OnVolumeChanged
553 * @tc.type: FUNC
554 * @tc.require: NA
555 */
556 HWTEST_F(HwCastStreamPlayerTest, OnVolumeChanged001, TestSize.Level1)
557 {
558 SLOGI("OnVolumeChanged001 begin!");
559 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
560 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
561 hwCastStreamPlayer->OnVolumeChanged(5, 15);
562 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
563 SLOGI("OnVolumeChanged001 end!");
564 }
565
566 /**
567 * @tc.name: OnLoopModeChanged001
568 * @tc.desc: OnLoopModeChanged
569 * @tc.type: FUNC
570 * @tc.require: NA
571 */
572 HWTEST_F(HwCastStreamPlayerTest, OnLoopModeChanged001, TestSize.Level1)
573 {
574 SLOGI("OnLoopModeChanged001 begin!");
575 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
576 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
577 hwCastStreamPlayer->OnLoopModeChanged(CastEngine::LoopMode::LOOP_MODE_SINGLE);
578 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
579 SLOGI("OnLoopModeChanged001 end!");
580 }
581
582 /**
583 * @tc.name: OnPlaySpeedChanged001
584 * @tc.desc: OnPlaySpeedChanged
585 * @tc.type: FUNC
586 * @tc.require: NA
587 */
588 HWTEST_F(HwCastStreamPlayerTest, OnPlaySpeedChanged001, TestSize.Level1)
589 {
590 SLOGI("OnPlaySpeedChanged001 begin!");
591 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
592 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
593 hwCastStreamPlayer->OnPlaySpeedChanged(CastEngine::PlaybackSpeed::SPEED_FORWARD_2_00_X);
594 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
595 SLOGI("OnPlaySpeedChanged001 end!");
596 }
597
598 /**
599 * @tc.name: OnPlayerError001
600 * @tc.desc: OnPlayerError
601 * @tc.type: FUNC
602 * @tc.require: NA
603 */
604 HWTEST_F(HwCastStreamPlayerTest, OnPlayerError001, TestSize.Level1)
605 {
606 SLOGI("OnPlayerError001 begin!");
607 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
608 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
609 hwCastStreamPlayer->OnPlayerError(10003, "PLAYER_ERROR");
610 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
611 SLOGI("OnPlayerError001 end!");
612 }
613
614 /**
615 * @tc.name: OnSeekDone001
616 * @tc.desc: OnSeekDone
617 * @tc.type: FUNC
618 * @tc.require: NA
619 */
620 HWTEST_F(HwCastStreamPlayerTest, OnSeekDone001, TestSize.Level1)
621 {
622 SLOGI("OnSeekDone001 begin!");
623 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
624 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
625 int32_t seekNumber = 0;
626 hwCastStreamPlayer->OnSeekDone(seekNumber);
627 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
628 SLOGI("OnSeekDone001 end!");
629 }
630
631 /**
632 * @tc.name: OnVideoSizeChanged001
633 * @tc.desc: OnVideoSizeChanged
634 * @tc.type: FUNC
635 * @tc.require: NA
636 */
637 HWTEST_F(HwCastStreamPlayerTest, OnVideoSizeChanged001, TestSize.Level1)
638 {
639 SLOGI("OnVideoSizeChanged001 begin!");
640 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
641 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
642 hwCastStreamPlayer->OnVideoSizeChanged(0, 0);
643 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
644 SLOGI("OnVideoSizeChanged001 end!");
645 }
646
647 /**
648 * @tc.name: OnEndOfStream001
649 * @tc.desc: OnEndOfStream
650 * @tc.type: FUNC
651 * @tc.require: NA
652 */
653 HWTEST_F(HwCastStreamPlayerTest, OnEndOfStream001, TestSize.Level1)
654 {
655 SLOGI("OnEndOfStream001 begin!");
656 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
657 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
658 hwCastStreamPlayer->OnEndOfStream(0);
659 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
660 SLOGI("OnEndOfStream001 end!");
661 }
662
663 /**
664 * @tc.name: OnPlayRequest001
665 * @tc.desc: OnPlayRequest
666 * @tc.type: FUNC
667 * @tc.require: NA
668 */
669 HWTEST_F(HwCastStreamPlayerTest, OnPlayRequest001, TestSize.Level1)
670 {
671 SLOGI("OnPlayRequest001 begin!");
672 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
673 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
674 CastEngine::MediaInfo mediaInfo;
675 hwCastStreamPlayer->OnPlayRequest(mediaInfo);
676 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
677 SLOGI("OnPlayRequest001 end!");
678 }
679
680 /**
681 * @tc.name: OnKeyRequest001
682 * @tc.desc: OnKeyRequest
683 * @tc.type: FUNC
684 * @tc.require: NA
685 */
686 HWTEST_F(HwCastStreamPlayerTest, OnKeyRequest001, TestSize.Level1)
687 {
688 SLOGI("OnKeyRequest001 begin!");
689 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
690 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
691 std::string assetId = "assetId";
692 std::vector<uint8_t> keyRequestData;
693 hwCastStreamPlayer->OnKeyRequest(assetId, keyRequestData);
694 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
695 SLOGI("OnKeyRequest001 end!");
696 }
697
698 /**
699 * @tc.name: SetValidAbility001
700 * @tc.desc: SetValidAbility to cast
701 * @tc.type: FUNC
702 * @tc.require: NA
703 */
704 HWTEST_F(HwCastStreamPlayerTest, SetValidAbility001, TestSize.Level1)
705 {
706 SLOGI("SetValidAbility001 begin!");
707 std::vector<int32_t> validAbilityList;
708 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY);
709 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PAUSE);
710 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_STOP);
711 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT);
712 ASSERT_EQ(hwCastStreamPlayer->SetValidAbility(validAbilityList), AVSESSION_SUCCESS);
713 SLOGI("SetValidAbility001 end!");
714 }
715
716 /**
717 * @tc.name: GetValidAbility001
718 * @tc.desc: GetValidAbility from cast
719 * @tc.type: FUNC
720 * @tc.require: NA
721 */
722 HWTEST_F(HwCastStreamPlayerTest, GetValidAbility001, TestSize.Level1)
723 {
724 SLOGI("GetValidAbility001 begin!");
725 std::vector<int32_t> validAbilityList;
726 ASSERT_EQ(hwCastStreamPlayer->GetValidAbility(validAbilityList), AVSESSION_SUCCESS);
727 SLOGI("GetValidAbility001 end!");
728 }
729
730
731 /**
732 * @tc.name: OnAvailableCapabilityChanged001
733 * @tc.desc: OnAvailableCapabilityChanged
734 * @tc.type: FUNC
735 * @tc.require: NA
736 */
737 HWTEST_F(HwCastStreamPlayerTest, OnAvailableCapabilityChanged001, TestSize.Level1)
738 {
739 SLOGI("OnAvailableCapabilityChanged001 begin!");
740 std::shared_ptr<AVCastControllerItem> avCastControllerItem = std::make_shared<AVCastControllerItem>();
741 ASSERT_EQ(hwCastStreamPlayer->RegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
742 CastEngine::StreamCapability streamCapability;
743 streamCapability.isPlaySupported = true;
744 streamCapability.isPauseSupported = true;
745 streamCapability.isStopSupported = true;
746 streamCapability.isNextSupported = true;
747 streamCapability.isPreviousSupported = true;
748 streamCapability.isSeekSupported = true;
749 hwCastStreamPlayer->OnAvailableCapabilityChanged(streamCapability);
750 ASSERT_EQ(hwCastStreamPlayer->UnRegisterControllerListener(avCastControllerItem), AVSESSION_SUCCESS);
751 SLOGI("OnAvailableCapabilityChanged001 end!");
752 }
753
754 /**
755 * @tc.name: CheckCastTime001
756 * @tc.desc: CheckCastTime
757 * @tc.type: FUNC
758 * @tc.require: NA
759 */
760 HWTEST_F(HwCastStreamPlayerTest, CheckCastTime001, TestSize.Level1)
761 {
762 SLOGI("CheckCastTime001 begin!");
763 int32_t castTime = 1001;
764 int32_t ret = hwCastStreamPlayer->CheckCastTime(castTime);
765 EXPECT_EQ(ret, castTime);
766 SLOGI("CheckCastTime001 end!");
767 }
768
769 /**
770 * @tc.name: RepeatPrepare001
771 * @tc.desc: test RepeatPrepare
772 * @tc.type: FUNC
773 * @tc.require: NA
774 */
775 HWTEST_F(HwCastStreamPlayerTest, RepeatPrepare001, TestSize.Level1)
776 {
777 SLOGI("RepeatPrepare001 begin!");
778 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
779 std::vector<uint8_t> imgBuffer = {1, 0, 0, 0, 1};
780 mediaPixelMap->SetInnerImgBuffer(imgBuffer);
781 std::shared_ptr<AVMediaDescription> description = CreateAVMediaDescription();
782 AVQueueItem avQueueItem;
783 avQueueItem.SetDescription(description);
784 hwCastStreamPlayer->RefreshCurrentAVQueueItem(avQueueItem);
785 description->SetIconUri("URI_CACHE");
786 description->SetIcon(mediaPixelMap);
787 auto ret = hwCastStreamPlayer->RepeatPrepare(description);
788 EXPECT_EQ(ret, true);
789 SLOGI("RepeatPrepare001 end!");
790 }
791
792 /**
793 * @tc.name: SetValidAbility002
794 * @tc.desc: test SetValidAbility
795 * @tc.type: FUNC
796 * @tc.require: NA
797 */
798 HWTEST_F(HwCastStreamPlayerTest, SetValidAbility002, TestSize.Level1)
799 {
800 SLOGI("SetValidAbility002 begin!");
801 std::vector<int32_t> validAbilityList;
802 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY);
803 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PAUSE);
804 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_STOP);
805 validAbilityList.push_back(AVCastControlCommand::CAST_CONTROL_CMD_PLAY_NEXT);
806 hwCastStreamPlayer->streamPlayer_ = nullptr;
807 auto ret = hwCastStreamPlayer->SetValidAbility(validAbilityList);
808 EXPECT_EQ(ret, AVSESSION_ERROR);
809 SLOGI("SetValidAbility002 end!");
810 }
811
812 /**
813 * @tc.name: OnAlbumCoverChanged001
814 * @tc.desc: test OnAlbumCoverChanged
815 * @tc.type: FUNC
816 * @tc.require: NA
817 */
818 HWTEST_F(HwCastStreamPlayerTest, OnAlbumCoverChanged001, TestSize.Level1)
819 {
820 SLOGI("OnAlbumCoverChanged001 begin!");
821 OHOS::AVSession::AVMetaData metaData = GetAVMetaData();
822 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = metaData.GetMediaImage();
823 std::shared_ptr<Media::PixelMap> pixelMap = AVSessionPixelMapAdapter::ConvertFromInner(mediaPixelMap);
824 hwCastStreamPlayer->OnAlbumCoverChanged(pixelMap);
825 SLOGI("OnAlbumCoverChanged001 end!");
826 }
827 } // namespace AVSession
828 } // namespace OHOS
829