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