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_errors.h"
20 #include "want_agent.h"
21 #include "avmeta_data.h"
22 #include "avplayback_state.h"
23 #include "avcall_state.h"
24 #include "avcall_meta_data.h"
25 #include "avmedia_description.h"
26 #include "avqueue_item.h"
27 #include "avsession_log.h"
28 #include "avcontrol_command.h"
29
30 #include "accesstoken_kit.h"
31 #include "bool_wrapper.h"
32 #include "nativetoken_kit.h"
33 #include "token_setproc.h"
34
35 using namespace testing::ext;
36 using namespace OHOS::Security::AccessToken;
37
38 namespace OHOS {
39 namespace AVSession {
40 static int32_t g_onCall = AVSESSION_ERROR;
41 static int32_t g_sessionId = AVSESSION_ERROR;
42 static AVMetaData g_metaData;
43 static AVCallMetaData g_avCallMetaData;
44 static AVCallState g_avCallState;
45 static AVPlaybackState g_playbackState;
46 static char g_testSessionTag[] = "test";
47 static char g_testBundleName[] = "test.ohos.avsession";
48 static char g_testAbilityName[] = "test.ability";
49 static uint64_t g_selfTokenId = 0;
50
51 static HapInfoParams g_info = {
52 .userID = 100,
53 .bundleName = "ohos.permission_test.demo",
54 .instIndex = 0,
55 .appIDDesc = "ohos.permission_test.demo",
56 .isSystemApp = true
57 };
58
59 static HapPolicyParams g_policy = {
60 .apl = APL_NORMAL,
61 .domain = "test.domain",
62 .permList = {
63 {
64 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
65 .bundleName = "ohos.permission_test.demo",
66 .grantMode = 1,
67 .availableLevel = APL_NORMAL,
68 .label = "label",
69 .labelId = 1,
70 .description = "test",
71 .descriptionId = 1
72 }
73 },
74 .permStateList = {
75 {
76 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
77 .isGeneral = true,
78 .resDeviceID = { "local" },
79 .grantStatus = { PermissionState::PERMISSION_GRANTED },
80 .grantFlags = { 1 }
81 }
82 }
83 };
84
85 class AvsessionTest : public testing::Test {
86 public:
87 static void SetUpTestCase();
88 static void TearDownTestCase();
89 void SetUp() override;
90 void TearDown() override;
91
92 std::shared_ptr<AVSession> avsession_ = nullptr;
93 std::shared_ptr<AVSessionController> controller_ = nullptr;
94
95 static constexpr int SESSION_LEN = 64;
96 };
97
SetUpTestCase()98 void AvsessionTest::SetUpTestCase()
99 {
100 g_selfTokenId = GetSelfTokenID();
101 AccessTokenKit::AllocHapToken(g_info, g_policy);
102 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
103 SetSelfTokenID(tokenID.tokenIDEx);
104 }
105
TearDownTestCase()106 void AvsessionTest::TearDownTestCase()
107 {
108 SetSelfTokenID(g_selfTokenId);
109 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
110 AccessTokenKit::DeleteToken(tokenId);
111 }
112
SetUp()113 void AvsessionTest::SetUp()
114 {
115 OHOS::AppExecFwk::ElementName elementName;
116 elementName.SetBundleName(g_testBundleName);
117 elementName.SetAbilityName(g_testAbilityName);
118 avsession_ = AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
119 elementName);
120 ASSERT_NE(avsession_, nullptr);
121 g_sessionId++;
122 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller_);
123 ASSERT_EQ(ret, AVSESSION_SUCCESS);
124 ASSERT_NE(controller_, nullptr);
125 }
126
TearDown()127 void AvsessionTest::TearDown()
128 {
129 [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
130 if (avsession_ != nullptr) {
131 ret = avsession_->Destroy();
132 avsession_ = nullptr;
133 }
134 if (controller_ != nullptr) {
135 ret = controller_->Destroy();
136 controller_ = nullptr;
137 }
138 g_onCall = AVSESSION_ERROR;
139 }
140
141 class AVSessionCallbackImpl : public AVSessionCallback {
142 public:
143 void OnPlay() override;
144 void OnPause() override;
145 void OnStop() override;
146 void OnPlayNext() override;
147 void OnPlayPrevious() override;
148 void OnFastForward(int64_t time) override;
149 void OnRewind(int64_t time) override;
150 void OnSeek(int64_t time) override;
151 void OnSetSpeed(double speed) override;
152 void OnSetLoopMode(int32_t loopMode) override;
153 void OnToggleFavorite(const std::string& mediald) override;
154 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)155 void OnOutputDeviceChange(const int32_t connectionState,
156 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
157 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override;
OnSkipToQueueItem(int32_t itemId)158 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()159 void OnAVCallAnswer() override {};
OnAVCallHangUp()160 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()161 void OnAVCallToggleCallMute() override {};
162 void OnPlayFromAssetId(int64_t assetId) override;
163 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override;
164
165 ~AVSessionCallbackImpl() override;
166 };
167
OnPlay()168 void AVSessionCallbackImpl::OnPlay()
169 {
170 g_onCall = AVSESSION_SUCCESS;
171 SLOGE("OnPlay %{public}d", g_onCall);
172 }
OnPause()173 void AVSessionCallbackImpl::OnPause()
174 {
175 g_onCall = AVSESSION_SUCCESS;
176 SLOGE("OnPause %{public}d", g_onCall);
177 }
OnStop()178 void AVSessionCallbackImpl::OnStop()
179 {
180 g_onCall = AVSESSION_SUCCESS;
181 SLOGE("OnStop %{public}d", g_onCall);
182 }
OnPlayNext()183 void AVSessionCallbackImpl::OnPlayNext()
184 {
185 g_onCall = AVSESSION_SUCCESS;
186 SLOGE("OnPlayNext %{public}d", g_onCall);
187 }
OnPlayPrevious()188 void AVSessionCallbackImpl::OnPlayPrevious()
189 {
190 g_onCall = AVSESSION_SUCCESS;
191 SLOGE("OnPlayPrevious %{public}d", g_onCall);
192 }
OnFastForward(int64_t time)193 void AVSessionCallbackImpl::OnFastForward(int64_t time)
194 {
195 g_onCall = AVSESSION_SUCCESS;
196 SLOGE("OnFastForward %{public}d", g_onCall);
197 }
OnRewind(int64_t time)198 void AVSessionCallbackImpl::OnRewind(int64_t time)
199 {
200 g_onCall = AVSESSION_SUCCESS;
201 SLOGE("OnRewind %{public}d", g_onCall);
202 }
OnSeek(int64_t time)203 void AVSessionCallbackImpl::OnSeek(int64_t time)
204 {
205 SLOGE("OnSeek %{public}" PRId64, time);
206 g_onCall = AVSESSION_SUCCESS;
207 }
OnSetSpeed(double speed)208 void AVSessionCallbackImpl::OnSetSpeed(double speed)
209 {
210 SLOGE("OnSetSpeed %{public}f", speed);
211 g_onCall = AVSESSION_SUCCESS;
212 SLOGE("OnSetSpeed %{public}d", g_onCall);
213 }
OnSetLoopMode(int32_t loopMode)214 void AVSessionCallbackImpl::OnSetLoopMode(int32_t loopMode)
215 {
216 SLOGE("OnSetLoopMode %{public}d", loopMode);
217 g_onCall = AVSESSION_SUCCESS;
218 SLOGE("OnSetLoopMode %{public}d", g_onCall);
219 }
OnToggleFavorite(const std::string & mediald)220 void AVSessionCallbackImpl::OnToggleFavorite(const std::string& mediald)
221 {
222 SLOGE("OnToggleFavorite %{public}s", mediald.c_str());
223 g_onCall = AVSESSION_SUCCESS;
224 SLOGE("OnToggleFavorite %{public}d", g_onCall);
225 }
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)226 void AVSessionCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
227 {
228 SLOGE("OnMediaKeyEvent");
229 g_onCall = AVSESSION_SUCCESS;
230 }
231
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)232 void AVSessionCallbackImpl::OnCommonCommand(const std::string& commonCommand,
233 const OHOS::AAFwk::WantParams& commandArgs)
234 {
235 SLOGI("OnCommonCommand");
236 g_onCall = AVSESSION_SUCCESS;
237 }
238
OnPlayFromAssetId(int64_t assetId)239 void AVSessionCallbackImpl::OnPlayFromAssetId(int64_t assetId)
240 {
241 g_onCall = AVSESSION_SUCCESS;
242 SLOGE("OnPlayFromAssetId %{public}d", g_onCall);
243 }
244
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)245 void AVSessionCallbackImpl::OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo)
246 {
247 SLOGE("OnCastDisplayChange");
248 g_onCall = AVSESSION_SUCCESS;
249 }
250
~AVSessionCallbackImpl()251 AVSessionCallbackImpl::~AVSessionCallbackImpl()
252 {
253 }
254
255 /**
256 * @tc.name: SetAVCallMetaData001
257 * @tc.desc: Return the result of set avcall meta data
258 * @tc.type: FUNC
259 */
260 HWTEST_F(AvsessionTest, SetAVCallMetaData001, TestSize.Level1)
261 {
262 SLOGE("SetAVCallMetaData001 Begin");
263 g_avCallMetaData.Reset();
264 g_avCallMetaData.SetName("");
265 g_avCallMetaData.SetPhoneNumber("123456789");
266
267 EXPECT_EQ(avsession_->SetAVCallMetaData(g_avCallMetaData), AVSESSION_SUCCESS);
268 SLOGE("SetAVCallMetaData001 enable optional params End");
269 }
270
271 /**
272 * @tc.name: SetAVCallMetaData002
273 * @tc.desc: Return the result of set avcall meta data
274 * @tc.type: FUNC
275 */
276 HWTEST_F(AvsessionTest, SetAVCallMetaData002, TestSize.Level1)
277 {
278 SLOGE("SetAVCallMetaData002 Begin");
279 g_avCallMetaData.Reset();
280 g_avCallMetaData.SetName("xiaoming");
281 g_avCallMetaData.SetPhoneNumber("123456789");
282
283 EXPECT_EQ(avsession_->SetAVCallMetaData(g_avCallMetaData), AVSESSION_SUCCESS);
284 SLOGE("SetAVCallMetaData002 End");
285 }
286
287 /**
288 * @tc.name: SetAVCallState001
289 * @tc.desc: Return the result of set avcall meta data
290 * @tc.type: FUNC
291 */
292 HWTEST_F(AvsessionTest, SetAVCallState001, TestSize.Level1)
293 {
294 SLOGE("SetAVCallState001 Begin");
295 g_avCallState.SetAVCallState(2);
296 g_avCallState.SetAVCallMuted(false);
297
298 EXPECT_EQ(avsession_->SetAVCallState(g_avCallState), AVSESSION_SUCCESS);
299 SLOGE("SetAVCallState001 End");
300 }
301
302 /**
303 * @tc.name: GetSessionId001
304 * @tc.desc: Return is Session ID
305 * @tc.type: FUNC
306 * @tc.require: AR000H31JF
307 */
308 HWTEST_F(AvsessionTest, GetSessionId001, TestSize.Level1)
309 {
310 SLOGE("GetSessionId001 Begin");
311 auto sessionId = avsession_->GetSessionId();
312 EXPECT_EQ(sessionId.length() == SESSION_LEN, true);
313 SLOGE("GetSessionId001 End");
314 }
315
316 /**
317 * @tc.name: SetAVMetaData001
318 * @tc.desc: Return the result of set av meta data
319 * @tc.type: FUNC
320 * @tc.require: AR000H31JF
321 */
322 HWTEST_F(AvsessionTest, SetAVMetaData001, TestSize.Level1)
323 {
324 SLOGE("SetAVMetaData001 Begin");
325 g_metaData.Reset();
326 g_metaData.SetAssetId("");
327 g_metaData.SetTitle("Black Humor");
328 g_metaData.SetArtist("zhoujielun");
329 g_metaData.SetAuthor("zhoujielun");
330 g_metaData.SetAlbum("Jay");
331 g_metaData.SetWriter("zhoujielun");
332 g_metaData.SetComposer("zhoujielun");
333 g_metaData.SetDuration(40000);
334 g_metaData.SetMediaImageUri("xxxxx");
335 g_metaData.SetSubTitle("fac");
336 g_metaData.SetDescription("for friends");
337 g_metaData.SetLyric("xxxxx");
338 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_ERROR);
339 SLOGE("SetAVMetaData001 End");
340 }
341
342 /**
343 * @tc.name: SetAVMetaData002
344 * @tc.desc: Return the result of set av meta data
345 * @tc.type: FUNC
346 * @tc.require: AR000H31JF
347 */
348 HWTEST_F(AvsessionTest, SetAVMetaData002, TestSize.Level1)
349 {
350 SLOGE("SetAVMetaData002 Begin");
351 g_metaData.Reset();
352 g_metaData.SetAssetId("123");
353 g_metaData.SetTitle("Black Humor");
354 g_metaData.SetArtist("zhoujielun");
355 g_metaData.SetAuthor("zhoujielun");
356 g_metaData.SetAlbum("Jay");
357 g_metaData.SetWriter("zhoujielun");
358 g_metaData.SetComposer("zhoujielun");
359 g_metaData.SetDuration(40000);
360 g_metaData.SetMediaImageUri("xxxxx");
361 g_metaData.SetSubTitle("fac");
362 g_metaData.SetDescription("for friends");
363 g_metaData.SetLyric("xxxxx");
364 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
365 SLOGE("SetAVMetaData002 End");
366 }
367
368 /**
369 * @tc.name: GetAVMetaData001
370 * @tc.desc: Return get av meta data result
371 * @tc.type: FUNC
372 * @tc.require: AR000H31JF
373 */
374 HWTEST_F(AvsessionTest, GetAVMetaData001, TestSize.Level1)
375 {
376 SLOGE("GetAVMetaData001 Begin");
377 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
378 AVMetaData metaData;
379 metaData.Reset();
380 EXPECT_EQ(avsession_->GetAVMetaData(metaData), AVSESSION_SUCCESS);
381 EXPECT_EQ(metaData.GetAssetId(), g_metaData.GetAssetId());
382 std::string title1 = metaData.GetTitle();
383 SLOGE("title1 %{public}s", title1.c_str());
384 std::string title2 = g_metaData.GetTitle();
385 SLOGE("title2 %{public}s", title2.c_str());
386 EXPECT_EQ(title1, title2);
387 EXPECT_EQ(metaData.GetTitle(), g_metaData.GetTitle());
388 EXPECT_EQ(metaData.GetArtist(), g_metaData.GetArtist());
389 EXPECT_EQ(metaData.GetAuthor(), g_metaData.GetAuthor());
390 EXPECT_EQ(metaData.GetAlbum(), g_metaData.GetAlbum());
391 EXPECT_EQ(metaData.GetWriter(), g_metaData.GetWriter());
392 EXPECT_EQ(metaData.GetComposer(), g_metaData.GetComposer());
393 EXPECT_EQ(metaData.GetDuration(), g_metaData.GetDuration());
394 EXPECT_EQ(metaData.GetMediaImageUri(), g_metaData.GetMediaImageUri());
395 EXPECT_EQ(metaData.GetSubTitle(), g_metaData.GetSubTitle());
396 EXPECT_EQ(metaData.GetDescription(), g_metaData.GetDescription());
397 EXPECT_EQ(metaData.GetLyric(), g_metaData.GetLyric());
398 SLOGE("GetAVMetaData001 End");
399 }
400
401 /**
402 * @tc.name: SetAVPlaybackState001
403 * @tc.desc: Return the result of set av playback state
404 * @tc.type: FUNC
405 * @tc.require: AR000H31JF
406 */
407 HWTEST_F(AvsessionTest, SetAVPlaybackState001, TestSize.Level1)
408 {
409 SLOGE("SetAVPlaybackState001 Begin");
410 AVMetaData metaData;
411 metaData.Reset();
412 metaData.SetAssetId("playback");
413 metaData.SetDuration(20);
414 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
415 g_playbackState.SetState(1);
416 g_playbackState.SetSpeed(1.5);
417 g_playbackState.SetPosition({80000, 0});
418 g_playbackState.SetBufferedTime(60000);
419 g_playbackState.SetLoopMode(2);
420 g_playbackState.SetFavorite(true);
421 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
422 SLOGE("SetAVPlaybackState001 End");
423 }
424
425 /**
426 * @tc.name: SetAVPlaybackState002
427 * @tc.desc: Return the result of set av playback state
428 * @tc.type: FUNC
429 * @tc.require: AR000H31JF
430 */
431 HWTEST_F(AvsessionTest, SetAVPlaybackState002, TestSize.Level1)
432 {
433 SLOGE("SetAVPlaybackState002 Begin");
434 g_playbackState.SetState(1);
435 g_playbackState.SetSpeed(1);
436 g_playbackState.SetPosition({80000, 0});
437 g_playbackState.SetBufferedTime(700000);
438 g_playbackState.SetLoopMode(1);
439 g_playbackState.SetFavorite(true);
440 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
441 SLOGE("SetAVPlaybackState002 End");
442 }
443
444 /**
445 * @tc.name: SetAVPlaybackState003
446 * @tc.desc: Return the result of set av playback state
447 * @tc.type: FUNC
448 * @tc.require: AR000H31JF
449 */
450 HWTEST_F(AvsessionTest, SetAVPlaybackState003, TestSize.Level1)
451 {
452 SLOGE("SetAVPlaybackState003 Begin");
453 AVMetaData metaData;
454 metaData.Reset();
455 metaData.SetAssetId("playback");
456 metaData.SetDuration(2000000);
457 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
458 g_playbackState.SetState(1);
459 g_playbackState.SetSpeed(1);
460 g_playbackState.SetPosition({80000, 0});
461 g_playbackState.SetBufferedTime(17000);
462 g_playbackState.SetLoopMode(1);
463 g_playbackState.SetFavorite(true);
464 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
465 SLOGE("SetAVPlaybackState003 End");
466 }
467
468 /**
469 * @tc.name: SetAVPlaybackState004
470 * @tc.desc: Return the result of set av playback state
471 * @tc.type: FUNC
472 * @tc.require: AR000H31JF
473 */
474 HWTEST_F(AvsessionTest, SetAVPlaybackState004, TestSize.Level1)
475 {
476 SLOGE("SetAVPlaybackState004 Begin");
477 AVMetaData metaData;
478 metaData.Reset();
479 metaData.SetAssetId("playback");
480 metaData.SetDuration(2000000);
481 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
482 g_playbackState.SetState(1);
483 g_playbackState.SetSpeed(1);
484 g_playbackState.SetPosition({10000, 0});
485 g_playbackState.SetBufferedTime(17000);
486 g_playbackState.SetLoopMode(1);
487 g_playbackState.SetFavorite(true);
488 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
489 SLOGE("SetAVPlaybackState004 End");
490 }
491
492 /**
493 * @tc.name: SetSessionEventTest001
494 * @tc.desc: Set session event
495 * @tc.type: FUNC
496 * @tc.require: I6C6IN
497 */
498 HWTEST_F(AvsessionTest, SetSessionEventTest001, TestSize.Level1)
499 {
500 SLOGE("SetSessionEventTest001 Begin");
501 std::string event = "eventName";
502 OHOS::AAFwk::WantParams args;
503 EXPECT_EQ(avsession_->SetSessionEvent(event, args), AVSESSION_SUCCESS);
504 SLOGE("SetSessionEventTest001 End");
505 }
506
507 /**
508 * @tc.name: SetSessionEventTest002
509 * @tc.desc: Set session event - large number of calls
510 * @tc.type: FUNC
511 * @tc.require: I6C6IN
512 */
513 HWTEST_F(AvsessionTest, SetSessionEventTest002, TestSize.Level2)
514 {
515 SLOGE("SetSessionEventTest002 Begin");
516 std::string event = "eventName";
517 OHOS::AAFwk::WantParams args;
518
519 // Test the interface through 500 calls
520 for (int i = 0; i < 500; i++) {
521 EXPECT_EQ(avsession_->SetSessionEvent(event, args), AVSESSION_SUCCESS);
522 }
523 SLOGE("SetSessionEventTest002 End");
524 }
525
526 /**
527 * @tc.name: GetAVPlaybackState001
528 * @tc.desc: Return the result of get av playback state
529 * @tc.type: FUNC
530 * @tc.require: AR000H31JF
531 */
532 HWTEST_F(AvsessionTest, GetAVPlaybackState001, TestSize.Level1)
533 {
534 SLOGE("GetAVPlaybackState001 Begin");
535 AVMetaData metaData;
536 metaData.Reset();
537 metaData.SetAssetId("playback");
538 metaData.SetDuration(2000000);
539 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
540 g_playbackState.SetState(1);
541 g_playbackState.SetSpeed(1);
542 g_playbackState.SetPosition({80000, 0});
543 g_playbackState.SetBufferedTime(87000);
544 g_playbackState.SetLoopMode(1);
545 g_playbackState.SetFavorite(true);
546 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
547 AVPlaybackState state;
548 EXPECT_EQ(avsession_->GetAVPlaybackState(state), AVSESSION_SUCCESS);
549 EXPECT_EQ(state.GetState(), g_playbackState.GetState());
550 EXPECT_EQ(state.GetSpeed(), g_playbackState.GetSpeed());
551 EXPECT_EQ(state.GetPosition().elapsedTime_, g_playbackState.GetPosition().elapsedTime_);
552 EXPECT_EQ(state.GetBufferedTime(), g_playbackState.GetBufferedTime());
553 EXPECT_EQ(state.GetLoopMode(), g_playbackState.GetLoopMode());
554 EXPECT_EQ(state.GetFavorite(), g_playbackState.GetFavorite());
555 SLOGE("GetAVPlaybackState001 End");
556 }
557
558 /**
559 * @tc.name: SetLaunchAbility001
560 * @tc.desc: Return the result of set av launch ability
561 * @tc.type: FUNC
562 * @tc.require: AR000H31JF
563 */
564 HWTEST_F(AvsessionTest, SetLaunchAbility001, TestSize.Level1)
565 {
566 SLOGE("SetLaunchAbility001 Begin");
567 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
568 EXPECT_EQ(avsession_->SetLaunchAbility(ability), AVSESSION_SUCCESS);
569 SLOGE("SetLaunchAbility001 End");
570 }
571
572 /**
573 * @tc.name: GetController001
574 * @tc.desc: Return shared_ptr of controller
575 * @tc.type: FUNC
576 * @tc.require: AR000H31JF
577 */
578 HWTEST_F(AvsessionTest, GetController001, TestSize.Level1)
579 {
580 SLOGE("GetController001 Begin");
581 auto controller = avsession_->GetController();
582 EXPECT_NE(controller, nullptr);
583 SLOGE("GetController001 End");
584 }
585
586 /**
587 * @tc.name: GetController002
588 * @tc.desc: Return shared_ptr of controller
589 * @tc.type: FUNC
590 * @tc.require: AR000H31JF
591 */
592 HWTEST_F(AvsessionTest, GetController002, TestSize.Level1)
593 {
594 SLOGE("GetController002 Begin");
595 auto controller = avsession_->GetController();
596 auto controller1 = avsession_->GetController();
597 EXPECT_NE(controller, nullptr);
598 EXPECT_NE(controller1, nullptr);
599 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
600 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
601 SLOGE("GetController002 End");
602 }
603
604 /**
605 * @tc.name: SetAVQueueItems
606 * @tc.desc: Set queue items of current application
607 * @tc.type: FUNC
608 * @tc.require: I6RJST
609 */
610 HWTEST_F(AvsessionTest, SetAVQueueItems, TestSize.Level1)
611 {
612 SLOGE("SetAVQueueItems Begin");
613 std::vector<AVQueueItem> items;
614 AVQueueItem queueItem;
615 queueItem.SetItemId(1);
616 AVMediaDescription description;
617 description.SetMediaId("id");
618 queueItem.SetDescription(std::make_shared<AVMediaDescription>(description));
619 items.push_back(queueItem);
620 EXPECT_EQ(avsession_->SetAVQueueItems(items), AVSESSION_SUCCESS);
621 SLOGE("SetAVQueueItems End");
622 }
623
624 /**
625 * @tc.name: SetAVQueueTitle
626 * @tc.desc: Set queue title of current application
627 * @tc.type: FUNC
628 * @tc.require: I6RJST
629 */
630 HWTEST_F(AvsessionTest, SetAVQueueTitle, TestSize.Level1)
631 {
632 SLOGE("SetAVQueueTitle Begin");
633 std::string title = "AVQueueTitle";
634 EXPECT_EQ(avsession_->SetAVQueueTitle(title), AVSESSION_SUCCESS);
635 SLOGE("SetAVQueueTitle End");
636 }
637
638 /**
639 * @tc.name: SetExtrasTest001
640 * @tc.desc: Set custom media packets
641 * @tc.type: FUNC
642 * @tc.require: I6TD43
643 */
644 HWTEST_F(AvsessionTest, SetExtrasTest001, TestSize.Level1)
645 {
646 SLOGI("SetExtrasTest001 Begin");
647 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
648 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
649 std::string keyStr = "1234567";
650 bool valueBool = true;
651 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
652
653 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
654 SLOGI("SetExtrasTest001 End");
655 }
656
657 /**
658 * @tc.name: SetExtrasTest002
659 * @tc.desc: Set custom media packets - large number of calls
660 * @tc.type: FUNC
661 * @tc.require: I6TD43
662 */
663 HWTEST_F(AvsessionTest, SetExtrasTest002, TestSize.Level2)
664 {
665 SLOGI("SetExtrasTest002 Begin");
666 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
667 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
668 std::string keyStr = "1234567";
669 bool valueBool = true;
670 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
671
672 // Test the interface through 500 calls
673 for (int i = 0; i < 500; i++) {
674 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
675 }
676 SLOGI("SetExtrasTest002 End");
677 }
678
679 /**
680 * @tc.name: RegisterCallback001
681 * @tc.desc: register avsession callback
682 * @tc.type: FUNC
683 * @tc.require: AR000H31JG
684 */
685 HWTEST_F(AvsessionTest, RegisterCallback001, TestSize.Level1)
686 {
687 SLOGE("RegisterCallback001 Begin");
688 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
689 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
690 SLOGE("RegisterCallback001 End");
691 }
692
693 /**
694 * @tc.name: RegisterCallback002
695 * @tc.desc: register avsession callback
696 * @tc.type: FUNC
697 * @tc.require: AR000H31JG
698 */
699 HWTEST_F(AvsessionTest, RegisterCallback002, TestSize.Level1)
700 {
701 SLOGE("RegisterCallback002 Begin");
702 std::shared_ptr<AVSessionCallback> callback = nullptr;
703 EXPECT_NE(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
704 SLOGE("RegisterCallback002 End");
705 }
706
707 /**
708 * @tc.name: RegisterCallback003
709 * @tc.desc: register avsession callback
710 * @tc.type: FUNC
711 * @tc.require: AR000H31JG
712 */
713 HWTEST_F(AvsessionTest, RegisterCallback003, TestSize.Level1)
714 {
715 SLOGE("RegisterCallback003 Begin");
716 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
717 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
718 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
719 if (cmd == AVControlCommand::SESSION_CMD_MEDIA_KEY_SUPPORT) {
720 continue;
721 }
722 AVControlCommand controlCommand;
723 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
724 EXPECT_EQ(controlCommand.SetCommand(cmd), AVSESSION_SUCCESS);
725 switch (cmd) {
726 case AVControlCommand::SESSION_CMD_SEEK : controlCommand.SetSeekTime(100000);
727 break;
728 case AVControlCommand::SESSION_CMD_SET_SPEED : controlCommand.SetSpeed(1.5);
729 break;
730 case AVControlCommand::SESSION_CMD_SET_LOOP_MODE : controlCommand.SetLoopMode(2);
731 break;
732 case AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE : controlCommand.SetAssetId("callback");
733 break;
734 case AVControlCommand::SESSION_CMD_FAST_FORWARD : controlCommand.SetForwardTime(10);
735 break;
736 case AVControlCommand::SESSION_CMD_REWIND : controlCommand.SetRewindTime(10);
737 break;
738 case AVControlCommand::SESSION_CMD_PLAY_FROM_ASSETID: controlCommand.SetPlayFromAssetId(0);
739 break;
740 default:
741 break;
742 }
743 bool isActive = false;
744 controller_->IsSessionActive(isActive);
745 if (!isActive) {
746 avsession_->Activate();
747 }
748 EXPECT_EQ(controller_->SendControlCommand(controlCommand), AVSESSION_SUCCESS);
749 sleep(1);
750 EXPECT_EQ(g_onCall, AVSESSION_SUCCESS);
751 g_onCall = false;
752 }
753 SLOGE("RegisterCallback003 End");
754 }
755
756 /**
757 * @tc.name: RegisterCallback004
758 * @tc.desc: register avsession callback
759 * @tc.type: FUNC
760 * @tc.require: AR000H31JG
761 */
762 HWTEST_F(AvsessionTest, RegisterCallback004, TestSize.Level1)
763 {
764 SLOGE("RegisterCallback004 Begin");
765 std::shared_ptr<AVSessionCallback> callback001 = std::make_shared<AVSessionCallbackImpl>();
766 EXPECT_NE(callback001, nullptr);
767 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
768 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
769 std::shared_ptr<AVSessionCallback> callback002 = std::make_shared<AVSessionCallbackImpl>();
770 EXPECT_NE(callback002, nullptr);
771 EXPECT_EQ(avsession_->RegisterCallback(callback002), AVSESSION_SUCCESS);
772 SLOGE("RegisterCallback004 End");
773 }
774
775 /**
776 * @tc.name: Active001
777 * @tc.desc: Return the active result
778 * @tc.type: FUNC
779 * @tc.require: AR000H31JF
780 */
781 HWTEST_F(AvsessionTest, Activate001, TestSize.Level1)
782 {
783 SLOGE("Activate001 Begin");
784 bool isActive = false;
785 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
786 isActive = avsession_->IsActive();
787 EXPECT_EQ(isActive, true);
788 SLOGE("Activate001 End");
789 }
790
791 /**
792 * @tc.name: Disactive001
793 * @tc.desc: Return is Session Actived
794 * @tc.type: FUNC
795 * @tc.require: AR000H31JF
796 */
797 HWTEST_F(AvsessionTest, Deactivate001, TestSize.Level1)
798 {
799 SLOGE("Deactivate001 Begin");
800 bool isActive = true;
801 EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
802 isActive = avsession_->IsActive();
803 EXPECT_EQ(isActive, false);
804 SLOGE("Deactivate001 End");
805 }
806
807 /**
808 * @tc.name: AddSupportCommand001
809 * @tc.desc: add supported commands
810 * @tc.type: FUNC
811 * @tc.require: AR000H31JF
812 */
813 HWTEST_F(AvsessionTest, AddSupportCommand001, TestSize.Level1)
814 {
815 SLOGE("AddSupportCommand001 Begin");
816 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
817 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE), AVSESSION_SUCCESS);
818 SLOGE("AddSupportCommand001 End");
819 }
820
821 /**
822 * @tc.name: AddSupportCommand002
823 * @tc.desc: add supported commands
824 * @tc.type: FUNC
825 * @tc.require: AR000H31JF
826 */
827 HWTEST_F(AvsessionTest, AddSupportCommand002, TestSize.Level1)
828 {
829 SLOGE("AddSupportCommand002 Begin");
830 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
831 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
832 SLOGE("AddSupportCommand002 End");
833 }
834
835 /**
836 * @tc.name: AddSupportCommand003
837 * @tc.desc: add supported commands
838 * @tc.type: FUNC
839 * @tc.require: AR000H31JF
840 */
841 HWTEST_F(AvsessionTest, AddSupportCommand003, TestSize.Level1)
842 {
843 SLOGE("AddSupportCommand003 Begin");
844 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
845 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
846 }
847 std::vector<int32_t> cmds;
848 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
849 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
850 for (int32_t index = 0; index < cmds.size(); index++) {
851 EXPECT_EQ(cmds[index] > AVControlCommand::SESSION_CMD_INVALID, true);
852 EXPECT_EQ(cmds[index] < AVControlCommand::SESSION_CMD_MAX, true);
853 EXPECT_EQ(cmds[index], index);
854 }
855 SLOGE("AddSupportCommand003 End");
856 }
857
858 /**
859 * @tc.name: deleteSupportCommand001
860 * @tc.desc: delete supported commands
861 * @tc.type: FUNC
862 * @tc.require: AR000H31JF
863 */
864 HWTEST_F(AvsessionTest, deleteSupportCommand001, TestSize.Level1)
865 {
866 SLOGE("deleteSupportCommand001 Begin");
867 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
868 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
869 }
870 std::vector<int32_t> cmds;
871 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
872 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
873 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
874 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
875 }
876 cmds.clear();
877 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
878 EXPECT_EQ(cmds.size(), 0);
879 SLOGE("deleteSupportCommand001 End");
880 }
881
882 /**
883 * @tc.name: deleteSupportCommand002
884 * @tc.desc: delete supported commands
885 * @tc.type: FUNC
886 * @tc.require: AR000H31JF
887 */
888 HWTEST_F(AvsessionTest, deleteSupportCommand002, TestSize.Level1)
889 {
890 SLOGE("deleteSupportCommand002 Begin");
891 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
892 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
893 }
894 SLOGE("deleteSupportCommand002 End");
895 }
896
897 /**
898 * @tc.name: deleteSupportCommand003
899 * @tc.desc: delete supported commands
900 * @tc.type: FUNC
901 * @tc.require: AR000H31JF
902 */
903 HWTEST_F(AvsessionTest, deleteSupportCommand003, TestSize.Level1)
904 {
905 SLOGE("deleteSupportCommand003 Begin");
906 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
907 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
908 }
909 std::vector<int32_t> cmds;
910 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
911 EXPECT_EQ(cmds.size(), (AVControlCommand::SESSION_CMD_MAX - 1));
912 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
913 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
914 SLOGE("deleteSupportCommand003 End");
915 }
916
917 /**
918 * @tc.name: Destroy001
919 * @tc.desc: Return is Session destroyed result
920 * @tc.type: FUNC
921 * @tc.require: AR000H31JF
922 */
923 HWTEST_F(AvsessionTest, Destroy001, TestSize.Level1)
924 {
925 SLOGE("Destroy001 Begin");
926 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
927 avsession_ = nullptr;
928 SLOGE("Destroy001 End");
929 }
930
931 /**
932 * @tc.name: Destroy002
933 * @tc.desc: Return is Session destroyed result
934 * @tc.type: FUNC
935 * @tc.require: AR000H31JF
936 */
937 HWTEST_F(AvsessionTest, Destroy002, TestSize.Level1)
938 {
939 SLOGE("Destroy002 Begin");
940 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
941 EXPECT_EQ(avsession_->Destroy(), ERR_SESSION_NOT_EXIST);
942 avsession_ = nullptr;
943 SLOGE("Destroy002 End");
944 }
945
946 /**
947 * @tc.name: GetSessionType001
948 * @tc.desc: GetSessionType
949 * @tc.type: FUNC
950 * @tc.require:
951 */
952 HWTEST_F(AvsessionTest, GetSessionType001, TestSize.Level1)
953 {
954 SLOGD("GetSessionType001 Begin");
955 EXPECT_EQ(avsession_->GetSessionType(), "audio");
956 SLOGD("GetSessionType001 End");
957 }
958
959 /**
960 * @tc.name: GetAVQueueItems001
961 * @tc.desc: get que items
962 * @tc.type: FUNC
963 * @tc.require:
964 */
965 HWTEST_F(AvsessionTest, GetAVQueueItems001, TestSize.Level1)
966 {
967 SLOGD("GetAVQueueItems001 Begin");
968 std::vector<AVQueueItem> items;
969 EXPECT_EQ(avsession_->GetAVQueueItems(items), AVSESSION_SUCCESS);
970 SLOGD("GetAVQueueItems001 End");
971 }
972
973 /**
974 * @tc.name: GetAVQueueTitle001
975 * @tc.desc: get av que title
976 * @tc.type: FUNC
977 * @tc.require:
978 */
979 HWTEST_F(AvsessionTest, GetAVQueueTitle001, TestSize.Level1)
980 {
981 SLOGD("GetAVQueueTitle001 Begin");
982 std::string title1 = "AVQueueTitle";
983 std::string title2;
984 EXPECT_EQ(avsession_->SetAVQueueTitle(title1), AVSESSION_SUCCESS);
985 EXPECT_EQ(avsession_->GetAVQueueTitle(title2), AVSESSION_SUCCESS);
986 SLOGD("GetAVQueueTitle001 End");
987 }
988
989 /**
990 * @tc.name: GetExtras001
991 * @tc.desc: get extras
992 * @tc.type: FUNC
993 * @tc.require:
994 */
995 HWTEST_F(AvsessionTest, GetExtras001, TestSize.Level1)
996 {
997 SLOGD("GetExtras001 Begin");
998 std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
999 wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
1000 std::string keyStr = "1234567";
1001 bool valueBool = true;
1002 wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
1003 OHOS::AAFwk::WantParams wantParamsOut;
1004 EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
1005 EXPECT_EQ(avsession_->GetExtras(wantParamsOut), AVSESSION_SUCCESS);
1006 SLOGD("GetExtras001 End");
1007 }
1008
1009 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
1010 /**
1011 * @tc.name: GetAllCastDisplays001
1012 * @tc.desc: get all cast displays
1013 * @tc.type: FUNC
1014 * @tc.require:
1015 */
1016 HWTEST_F(AvsessionTest, GetAllCastDisplays001, TestSize.Level1)
1017 {
1018 SLOGD("GetAllCastDisplays001 Begin");
1019 std::vector<CastDisplayInfo> castDisplays;
1020 EXPECT_EQ(avsession_->GetAllCastDisplays(castDisplays), AVSESSION_SUCCESS);
1021 SLOGD("GetAllCastDisplays001 End");
1022 }
1023 #endif
1024 } // namespace AVSession
1025 } // namespace OHOS
1026