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