1 /*
2 * Copyright (c) 2022 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 "avsession_log.h"
24 #include "avcontrol_command.h"
25
26 #include "accesstoken_kit.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29
30 using namespace testing::ext;
31 using namespace OHOS::AVSession;
32 using namespace OHOS::Security::AccessToken;
33
34 static int32_t g_onCall = AVSESSION_ERROR;
35 static int32_t g_sessionId = AVSESSION_ERROR;
36 static AVMetaData g_metaData;
37 static AVPlaybackState g_playbackState;
38 static char g_testSessionTag[] = "test";
39 static char g_testBundleName[] = "test.ohos.avsession";
40 static char g_testAbilityName[] = "test.ability";
41 static uint64_t g_selfTokenId = 0;
42
43 static HapInfoParams g_info = {
44 .userID = 100,
45 .bundleName = "ohos.permission_test.demo",
46 .instIndex = 0,
47 .appIDDesc = "ohos.permission_test.demo"
48 };
49
50 static HapPolicyParams g_policy = {
51 .apl = APL_NORMAL,
52 .domain = "test.domain",
53 .permList = {
54 {
55 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
56 .bundleName = "ohos.permission_test.demo",
57 .grantMode = 1,
58 .availableLevel = APL_NORMAL,
59 .label = "label",
60 .labelId = 1,
61 .description = "test",
62 .descriptionId = 1
63 }
64 },
65 .permStateList = {
66 {
67 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
68 .isGeneral = true,
69 .resDeviceID = { "local" },
70 .grantStatus = { PermissionState::PERMISSION_GRANTED },
71 .grantFlags = { 1 }
72 }
73 }
74 };
75
76 class AvsessionTest : public testing::Test {
77 public:
78 static void SetUpTestCase();
79 static void TearDownTestCase();
80 void SetUp() override;
81 void TearDown() override;
82
83 std::shared_ptr<AVSession> avsession_ = nullptr;
84 std::shared_ptr<AVSessionController> controller_ = nullptr;
85
86 static constexpr int SESSION_LEN = 64;
87 };
88
SetUpTestCase()89 void AvsessionTest::SetUpTestCase()
90 {
91 g_selfTokenId = GetSelfTokenID();
92 AccessTokenIDEx tokenIdEx = AccessTokenKit::AllocHapToken(g_info, g_policy);
93 SetSelfTokenID(tokenIdEx.tokenIdExStruct.tokenID);
94 }
95
TearDownTestCase()96 void AvsessionTest::TearDownTestCase()
97 {
98 SetSelfTokenID(g_selfTokenId);
99 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
100 AccessTokenKit::DeleteToken(tokenId);
101 }
102
SetUp()103 void AvsessionTest::SetUp()
104 {
105 OHOS::AppExecFwk::ElementName elementName;
106 elementName.SetBundleName(g_testBundleName);
107 elementName.SetAbilityName(g_testAbilityName);
108 avsession_ = AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
109 elementName);
110 ASSERT_NE(avsession_, nullptr);
111 g_sessionId++;
112 auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller_);
113 ASSERT_EQ(ret, AVSESSION_SUCCESS);
114 ASSERT_NE(controller_, nullptr);
115 }
116
TearDown()117 void AvsessionTest::TearDown()
118 {
119 int32_t ret = AVSESSION_ERROR;
120 if (avsession_ != nullptr) {
121 ret = avsession_->Destroy();
122 avsession_ = nullptr;
123 }
124 if (controller_ != nullptr) {
125 ret = controller_->Destroy();
126 controller_ = nullptr;
127 }
128 g_onCall = AVSESSION_ERROR;
129 }
130
131 class AVSessionCallbackImpl : public AVSessionCallback {
132 public:
133 void OnPlay() override;
134 void OnPause() override;
135 void OnStop() override;
136 void OnPlayNext() override;
137 void OnPlayPrevious() override;
138 void OnFastForward() override;
139 void OnRewind() override;
140 void OnSeek(int64_t time) override;
141 void OnSetSpeed(double speed) override;
142 void OnSetLoopMode(int32_t loopMode) override;
143 void OnToggleFavorite(const std::string& mediald) override;
144 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
OnOutputDeviceChange(const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)145 void OnOutputDeviceChange(const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
146
147 ~AVSessionCallbackImpl() override;
148 };
149
OnPlay()150 void AVSessionCallbackImpl::OnPlay()
151 {
152 g_onCall = AVSESSION_SUCCESS;
153 SLOGE("OnPlay %{public}d", g_onCall);
154 }
OnPause()155 void AVSessionCallbackImpl::OnPause()
156 {
157 g_onCall = AVSESSION_SUCCESS;
158 SLOGE("OnPause %{public}d", g_onCall);
159 }
OnStop()160 void AVSessionCallbackImpl::OnStop()
161 {
162 g_onCall = AVSESSION_SUCCESS;
163 SLOGE("OnStop %{public}d", g_onCall);
164 }
OnPlayNext()165 void AVSessionCallbackImpl::OnPlayNext()
166 {
167 g_onCall = AVSESSION_SUCCESS;
168 SLOGE("OnPlayNext %{public}d", g_onCall);
169 }
OnPlayPrevious()170 void AVSessionCallbackImpl::OnPlayPrevious()
171 {
172 g_onCall = AVSESSION_SUCCESS;
173 SLOGE("OnPlayPrevious %{public}d", g_onCall);
174 }
OnFastForward()175 void AVSessionCallbackImpl::OnFastForward()
176 {
177 g_onCall = AVSESSION_SUCCESS;
178 SLOGE("OnFastForward %{public}d", g_onCall);
179 }
OnRewind()180 void AVSessionCallbackImpl::OnRewind()
181 {
182 g_onCall = AVSESSION_SUCCESS;
183 SLOGE("OnRewind %{public}d", g_onCall);
184 }
OnSeek(int64_t time)185 void AVSessionCallbackImpl::OnSeek(int64_t time)
186 {
187 SLOGE("OnSeek %{public}" PRId64, time);
188 g_onCall = AVSESSION_SUCCESS;
189 }
OnSetSpeed(double speed)190 void AVSessionCallbackImpl::OnSetSpeed(double speed)
191 {
192 SLOGE("OnSetSpeed %{public}f", speed);
193 g_onCall = AVSESSION_SUCCESS;
194 SLOGE("OnSetSpeed %{public}d", g_onCall);
195 }
OnSetLoopMode(int32_t loopMode)196 void AVSessionCallbackImpl::OnSetLoopMode(int32_t loopMode)
197 {
198 SLOGE("OnSetLoopMode %{public}d", loopMode);
199 g_onCall = AVSESSION_SUCCESS;
200 SLOGE("OnSetLoopMode %{public}d", g_onCall);
201 }
OnToggleFavorite(const std::string & mediald)202 void AVSessionCallbackImpl::OnToggleFavorite(const std::string& mediald)
203 {
204 SLOGE("OnToggleFavorite %{public}s", mediald.c_str());
205 g_onCall = AVSESSION_SUCCESS;
206 SLOGE("OnToggleFavorite %{public}d", g_onCall);
207 }
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)208 void AVSessionCallbackImpl::OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
209 {
210 SLOGE("OnMediaKeyEvent");
211 g_onCall = AVSESSION_SUCCESS;
212 }
~AVSessionCallbackImpl()213 AVSessionCallbackImpl::~AVSessionCallbackImpl()
214 {
215 }
216
217 /**
218 * @tc.name: GetSessionId001
219 * @tc.desc: Return is Session ID
220 * @tc.type: FUNC
221 * @tc.require: AR000H31JF
222 */
223 HWTEST_F(AvsessionTest, GetSessionId001, TestSize.Level1)
224 {
225 SLOGE("GetSessionId001 Begin");
226 auto sessionId = avsession_->GetSessionId();
227 EXPECT_EQ(sessionId.length() == SESSION_LEN, true);
228 SLOGE("GetSessionId001 End");
229 }
230
231 /**
232 * @tc.name: SetAVMetaData001
233 * @tc.desc: Return the result of set av meta data
234 * @tc.type: FUNC
235 * @tc.require: AR000H31JF
236 */
237 HWTEST_F(AvsessionTest, SetAVMetaData001, TestSize.Level1)
238 {
239 SLOGE("SetAVMetaData001 Begin");
240 g_metaData.Reset();
241 g_metaData.SetAssetId("");
242 g_metaData.SetTitle("Black Humor");
243 g_metaData.SetArtist("zhoujielun");
244 g_metaData.SetAuthor("zhoujielun");
245 g_metaData.SetAlbum("Jay");
246 g_metaData.SetWriter("zhoujielun");
247 g_metaData.SetComposer("zhoujielun");
248 g_metaData.SetDuration(40000);
249 g_metaData.SetMediaImageUri("xxxxx");
250 g_metaData.SetSubTitle("fac");
251 g_metaData.SetDescription("for friends");
252 g_metaData.SetLyric("xxxxx");
253 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_ERROR);
254 SLOGE("SetAVMetaData001 End");
255 }
256
257 /**
258 * @tc.name: SetAVMetaData002
259 * @tc.desc: Return the result of set av meta data
260 * @tc.type: FUNC
261 * @tc.require: AR000H31JF
262 */
263 HWTEST_F(AvsessionTest, SetAVMetaData002, TestSize.Level1)
264 {
265 SLOGE("SetAVMetaData002 Begin");
266 g_metaData.Reset();
267 g_metaData.SetAssetId("123");
268 g_metaData.SetTitle("Black Humor");
269 g_metaData.SetArtist("zhoujielun");
270 g_metaData.SetAuthor("zhoujielun");
271 g_metaData.SetAlbum("Jay");
272 g_metaData.SetWriter("zhoujielun");
273 g_metaData.SetComposer("zhoujielun");
274 g_metaData.SetDuration(40000);
275 g_metaData.SetMediaImageUri("xxxxx");
276 g_metaData.SetSubTitle("fac");
277 g_metaData.SetDescription("for friends");
278 g_metaData.SetLyric("xxxxx");
279 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
280 SLOGE("SetAVMetaData002 End");
281 }
282
283 /**
284 * @tc.name: GetAVMetaData001
285 * @tc.desc: Return get av meta data result
286 * @tc.type: FUNC
287 * @tc.require: AR000H31JF
288 */
289 HWTEST_F(AvsessionTest, GetAVMetaData001, TestSize.Level1)
290 {
291 SLOGE("GetAVMetaData001 Begin");
292 EXPECT_EQ(avsession_->SetAVMetaData(g_metaData), AVSESSION_SUCCESS);
293 AVMetaData metaData;
294 metaData.Reset();
295 EXPECT_EQ(avsession_->GetAVMetaData(metaData), AVSESSION_SUCCESS);
296 EXPECT_EQ(metaData.GetAssetId(), g_metaData.GetAssetId());
297 std::string title1 = metaData.GetTitle();
298 SLOGE("title1 %{public}s", title1.c_str());
299 std::string title2 = g_metaData.GetTitle();
300 SLOGE("title2 %{public}s", title2.c_str());
301 EXPECT_EQ(title1, title2);
302 EXPECT_EQ(metaData.GetTitle(), g_metaData.GetTitle());
303 EXPECT_EQ(metaData.GetArtist(), g_metaData.GetArtist());
304 EXPECT_EQ(metaData.GetAuthor(), g_metaData.GetAuthor());
305 EXPECT_EQ(metaData.GetAlbum(), g_metaData.GetAlbum());
306 EXPECT_EQ(metaData.GetWriter(), g_metaData.GetWriter());
307 EXPECT_EQ(metaData.GetComposer(), g_metaData.GetComposer());
308 EXPECT_EQ(metaData.GetDuration(), g_metaData.GetDuration());
309 EXPECT_EQ(metaData.GetMediaImageUri(), g_metaData.GetMediaImageUri());
310 EXPECT_EQ(metaData.GetSubTitle(), g_metaData.GetSubTitle());
311 EXPECT_EQ(metaData.GetDescription(), g_metaData.GetDescription());
312 EXPECT_EQ(metaData.GetLyric(), g_metaData.GetLyric());
313 SLOGE("GetAVMetaData001 End");
314 }
315
316 /**
317 * @tc.name: SetAVPlaybackState001
318 * @tc.desc: Return the result of set av playback state
319 * @tc.type: FUNC
320 * @tc.require: AR000H31JF
321 */
322 HWTEST_F(AvsessionTest, SetAVPlaybackState001, TestSize.Level1)
323 {
324 SLOGE("SetAVPlaybackState001 Begin");
325 AVMetaData metaData;
326 metaData.Reset();
327 metaData.SetAssetId("playback");
328 metaData.SetDuration(20);
329 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
330 g_playbackState.SetState(1);
331 g_playbackState.SetSpeed(1.5);
332 g_playbackState.SetPosition({80000, 0});
333 g_playbackState.SetBufferedTime(60000);
334 g_playbackState.SetLoopMode(2);
335 g_playbackState.SetFavorite(true);
336 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
337 SLOGE("SetAVPlaybackState001 End");
338 }
339
340 /**
341 * @tc.name: SetAVPlaybackState002
342 * @tc.desc: Return the result of set av playback state
343 * @tc.type: FUNC
344 * @tc.require: AR000H31JF
345 */
346 HWTEST_F(AvsessionTest, SetAVPlaybackState002, TestSize.Level1)
347 {
348 SLOGE("SetAVPlaybackState002 Begin");
349 g_playbackState.SetState(1);
350 g_playbackState.SetSpeed(1);
351 g_playbackState.SetPosition({80000, 0});
352 g_playbackState.SetBufferedTime(700000);
353 g_playbackState.SetLoopMode(1);
354 g_playbackState.SetFavorite(true);
355 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
356 SLOGE("SetAVPlaybackState002 End");
357 }
358
359 /**
360 * @tc.name: SetAVPlaybackState003
361 * @tc.desc: Return the result of set av playback state
362 * @tc.type: FUNC
363 * @tc.require: AR000H31JF
364 */
365 HWTEST_F(AvsessionTest, SetAVPlaybackState003, TestSize.Level1)
366 {
367 SLOGE("SetAVPlaybackState003 Begin");
368 AVMetaData metaData;
369 metaData.Reset();
370 metaData.SetAssetId("playback");
371 metaData.SetDuration(2000000);
372 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
373 g_playbackState.SetState(1);
374 g_playbackState.SetSpeed(1);
375 g_playbackState.SetPosition({80000, 0});
376 g_playbackState.SetBufferedTime(17000);
377 g_playbackState.SetLoopMode(1);
378 g_playbackState.SetFavorite(true);
379 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
380 SLOGE("SetAVPlaybackState003 End");
381 }
382
383 /**
384 * @tc.name: SetAVPlaybackState004
385 * @tc.desc: Return the result of set av playback state
386 * @tc.type: FUNC
387 * @tc.require: AR000H31JF
388 */
389 HWTEST_F(AvsessionTest, SetAVPlaybackState004, TestSize.Level1)
390 {
391 SLOGE("SetAVPlaybackState004 Begin");
392 AVMetaData metaData;
393 metaData.Reset();
394 metaData.SetAssetId("playback");
395 metaData.SetDuration(2000000);
396 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
397 g_playbackState.SetState(1);
398 g_playbackState.SetSpeed(1);
399 g_playbackState.SetPosition({10000, 0});
400 g_playbackState.SetBufferedTime(17000);
401 g_playbackState.SetLoopMode(1);
402 g_playbackState.SetFavorite(true);
403 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
404 SLOGE("SetAVPlaybackState004 End");
405 }
406
407 /**
408 * @tc.name: GetAVPlaybackState001
409 * @tc.desc: Return the result of get av playback state
410 * @tc.type: FUNC
411 * @tc.require: AR000H31JF
412 */
413 HWTEST_F(AvsessionTest, GetAVPlaybackState001, TestSize.Level1)
414 {
415 SLOGE("GetAVPlaybackState001 Begin");
416 AVMetaData metaData;
417 metaData.Reset();
418 metaData.SetAssetId("playback");
419 metaData.SetDuration(2000000);
420 EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
421 g_playbackState.SetState(1);
422 g_playbackState.SetSpeed(1);
423 g_playbackState.SetPosition({80000, 0});
424 g_playbackState.SetBufferedTime(87000);
425 g_playbackState.SetLoopMode(1);
426 g_playbackState.SetFavorite(true);
427 EXPECT_EQ(avsession_->SetAVPlaybackState(g_playbackState), AVSESSION_SUCCESS);
428 AVPlaybackState state;
429 EXPECT_EQ(avsession_->GetAVPlaybackState(state), AVSESSION_SUCCESS);
430 EXPECT_EQ(state.GetState(), g_playbackState.GetState());
431 EXPECT_EQ(state.GetSpeed(), g_playbackState.GetSpeed());
432 EXPECT_EQ(state.GetPosition().elapsedTime_, g_playbackState.GetPosition().elapsedTime_);
433 EXPECT_EQ(state.GetBufferedTime(), g_playbackState.GetBufferedTime());
434 EXPECT_EQ(state.GetLoopMode(), g_playbackState.GetLoopMode());
435 EXPECT_EQ(state.GetFavorite(), g_playbackState.GetFavorite());
436 SLOGE("GetAVPlaybackState001 End");
437 }
438
439 /**
440 * @tc.name: SetLaunchAbility001
441 * @tc.desc: Return the result of set av launch ability
442 * @tc.type: FUNC
443 * @tc.require: AR000H31JF
444 */
445 HWTEST_F(AvsessionTest, SetLaunchAbility001, TestSize.Level1)
446 {
447 SLOGE("SetLaunchAbility001 Begin");
448 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
449 EXPECT_EQ(avsession_->SetLaunchAbility(ability), AVSESSION_SUCCESS);
450 SLOGE("SetLaunchAbility001 End");
451 }
452
453 /**
454 * @tc.name: GetController001
455 * @tc.desc: Return shared_ptr of controller
456 * @tc.type: FUNC
457 * @tc.require: AR000H31JF
458 */
459 HWTEST_F(AvsessionTest, GetController001, TestSize.Level1)
460 {
461 SLOGE("GetController001 Begin");
462 auto controller = avsession_->GetController();
463 EXPECT_NE(controller, nullptr);
464 SLOGE("GetController001 End");
465 }
466
467 /**
468 * @tc.name: GetController002
469 * @tc.desc: Return shared_ptr of controller
470 * @tc.type: FUNC
471 * @tc.require: AR000H31JF
472 */
473 HWTEST_F(AvsessionTest, GetController002, TestSize.Level1)
474 {
475 SLOGE("GetController002 Begin");
476 auto controller = avsession_->GetController();
477 auto controller1 = avsession_->GetController();
478 EXPECT_NE(controller, nullptr);
479 EXPECT_NE(controller1, nullptr);
480 EXPECT_EQ(controller->Destroy(), AVSESSION_SUCCESS);
481 EXPECT_EQ(controller1->Destroy(), ERR_CONTROLLER_NOT_EXIST);
482 SLOGE("GetController002 End");
483 }
484
485 /**
486 * @tc.name: RegisterCallback001
487 * @tc.desc: register avsession callback
488 * @tc.type: FUNC
489 * @tc.require: AR000H31JG
490 */
491 HWTEST_F(AvsessionTest, RegisterCallback001, TestSize.Level1)
492 {
493 SLOGE("RegisterCallback001 Begin");
494 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
495 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
496 SLOGE("RegisterCallback001 End");
497 }
498
499 /**
500 * @tc.name: RegisterCallback002
501 * @tc.desc: register avsession callback
502 * @tc.type: FUNC
503 * @tc.require: AR000H31JG
504 */
505 HWTEST_F(AvsessionTest, RegisterCallback002, TestSize.Level1)
506 {
507 SLOGE("RegisterCallback002 Begin");
508 std::shared_ptr<AVSessionCallback> callback = nullptr;
509 EXPECT_NE(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
510 SLOGE("RegisterCallback002 End");
511 }
512
513 /**
514 * @tc.name: RegisterCallback003
515 * @tc.desc: register avsession callback
516 * @tc.type: FUNC
517 * @tc.require: AR000H31JG
518 */
519 HWTEST_F(AvsessionTest, RegisterCallback003, TestSize.Level1)
520 {
521 SLOGE("RegisterCallback003 Begin");
522 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
523 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
524 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
525 AVControlCommand controlCommand;
526 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
527 EXPECT_EQ(controlCommand.SetCommand(cmd), AVSESSION_SUCCESS);
528 switch (cmd) {
529 case AVControlCommand::SESSION_CMD_SEEK : controlCommand.SetSeekTime(100000);
530 break;
531 case AVControlCommand::SESSION_CMD_SET_SPEED : controlCommand.SetSpeed(1.5);
532 break;
533 case AVControlCommand::SESSION_CMD_SET_LOOP_MODE : controlCommand.SetLoopMode(2);
534 break;
535 case AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE : controlCommand.SetAssetId("callback");
536 break;
537 default:
538 break;
539 }
540 bool isActive = false;
541 controller_->IsSessionActive(isActive);
542 if (!isActive) {
543 avsession_->Activate();
544 }
545 EXPECT_EQ(controller_->SendControlCommand(controlCommand), AVSESSION_SUCCESS);
546 sleep(1);
547 EXPECT_EQ(g_onCall, AVSESSION_SUCCESS);
548 g_onCall = false;
549 }
550 SLOGE("RegisterCallback003 End");
551 }
552
553 /**
554 * @tc.name: RegisterCallback004
555 * @tc.desc: register avsession callback
556 * @tc.type: FUNC
557 * @tc.require: AR000H31JG
558 */
559 HWTEST_F(AvsessionTest, RegisterCallback004, TestSize.Level1)
560 {
561 SLOGE("RegisterCallback004 Begin");
562 std::shared_ptr<AVSessionCallback> callback001 = std::make_shared<AVSessionCallbackImpl>();
563 EXPECT_NE(callback001, nullptr);
564 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
565 EXPECT_EQ(avsession_->RegisterCallback(callback001), AVSESSION_SUCCESS);
566 std::shared_ptr<AVSessionCallback> callback002 = std::make_shared<AVSessionCallbackImpl>();
567 EXPECT_NE(callback002, nullptr);
568 EXPECT_EQ(avsession_->RegisterCallback(callback002), AVSESSION_SUCCESS);
569 SLOGE("RegisterCallback004 End");
570 }
571
572 /**
573 * @tc.name: Active001
574 * @tc.desc: Return the active result
575 * @tc.type: FUNC
576 * @tc.require: AR000H31JF
577 */
578 HWTEST_F(AvsessionTest, Activate001, TestSize.Level1)
579 {
580 SLOGE("Activate001 Begin");
581 bool isActive = false;
582 EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
583 isActive = avsession_->IsActive();
584 EXPECT_EQ(isActive, true);
585 SLOGE("Activate001 End");
586 }
587
588 /**
589 * @tc.name: Disactive001
590 * @tc.desc: Return is Session Actived
591 * @tc.type: FUNC
592 * @tc.require: AR000H31JF
593 */
594 HWTEST_F(AvsessionTest, Deactivate001, TestSize.Level1)
595 {
596 SLOGE("Deactivate001 Begin");
597 bool isActive = true;
598 EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
599 isActive = avsession_->IsActive();
600 EXPECT_EQ(isActive, false);
601 SLOGE("Deactivate001 End");
602 }
603
604 /**
605 * @tc.name: AddSupportCommand001
606 * @tc.desc: add supported commands
607 * @tc.type: FUNC
608 * @tc.require: AR000H31JF
609 */
610 HWTEST_F(AvsessionTest, AddSupportCommand001, TestSize.Level1)
611 {
612 SLOGE("AddSupportCommand001 Begin");
613 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
614 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE), AVSESSION_SUCCESS);
615 SLOGE("AddSupportCommand001 End");
616 }
617
618 /**
619 * @tc.name: AddSupportCommand002
620 * @tc.desc: add supported commands
621 * @tc.type: FUNC
622 * @tc.require: AR000H31JF
623 */
624 HWTEST_F(AvsessionTest, AddSupportCommand002, TestSize.Level1)
625 {
626 SLOGE("AddSupportCommand002 Begin");
627 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
628 EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
629 SLOGE("AddSupportCommand002 End");
630 }
631
632 /**
633 * @tc.name: AddSupportCommand003
634 * @tc.desc: add supported commands
635 * @tc.type: FUNC
636 * @tc.require: AR000H31JF
637 */
638 HWTEST_F(AvsessionTest, AddSupportCommand003, TestSize.Level1)
639 {
640 SLOGE("AddSupportCommand003 Begin");
641 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
642 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
643 }
644 std::vector<int32_t> cmds;
645 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
646 EXPECT_EQ(cmds.size(), AVControlCommand::SESSION_CMD_MAX);
647 for (int32_t index = 0; index < cmds.size(); index++) {
648 EXPECT_EQ(cmds[index] > AVControlCommand::SESSION_CMD_INVALID, true);
649 EXPECT_EQ(cmds[index] < AVControlCommand::SESSION_CMD_MAX, true);
650 EXPECT_EQ(cmds[index], index);
651 }
652 SLOGE("AddSupportCommand003 End");
653 }
654
655 /**
656 * @tc.name: deleteSupportCommand001
657 * @tc.desc: delete supported commands
658 * @tc.type: FUNC
659 * @tc.require: AR000H31JF
660 */
661 HWTEST_F(AvsessionTest, deleteSupportCommand001, TestSize.Level1)
662 {
663 SLOGE("deleteSupportCommand001 Begin");
664 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
665 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
666 }
667 std::vector<int32_t> cmds;
668 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
669 EXPECT_EQ(cmds.size(), AVControlCommand::SESSION_CMD_MAX);
670 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
671 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
672 }
673 cmds.clear();
674 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
675 EXPECT_EQ(cmds.size(), 0);
676 SLOGE("deleteSupportCommand001 End");
677 }
678
679 /**
680 * @tc.name: deleteSupportCommand002
681 * @tc.desc: delete supported commands
682 * @tc.type: FUNC
683 * @tc.require: AR000H31JF
684 */
685 HWTEST_F(AvsessionTest, deleteSupportCommand002, TestSize.Level1)
686 {
687 SLOGE("deleteSupportCommand002 Begin");
688 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
689 EXPECT_EQ(avsession_->DeleteSupportCommand(cmd), AVSESSION_SUCCESS);
690 }
691 SLOGE("deleteSupportCommand002 End");
692 }
693
694 /**
695 * @tc.name: deleteSupportCommand003
696 * @tc.desc: delete supported commands
697 * @tc.type: FUNC
698 * @tc.require: AR000H31JF
699 */
700 HWTEST_F(AvsessionTest, deleteSupportCommand003, TestSize.Level1)
701 {
702 SLOGE("deleteSupportCommand003 Begin");
703 for (int32_t cmd = AVControlCommand::SESSION_CMD_PLAY; cmd < AVControlCommand::SESSION_CMD_MAX; cmd++) {
704 EXPECT_EQ(avsession_->AddSupportCommand(cmd), AVSESSION_SUCCESS);
705 }
706 std::vector<int32_t> cmds;
707 EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
708 EXPECT_EQ(cmds.size(), AVControlCommand::SESSION_CMD_MAX);
709 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_INVALID), AVSESSION_ERROR);
710 EXPECT_EQ(avsession_->DeleteSupportCommand(AVControlCommand::SESSION_CMD_MAX), AVSESSION_ERROR);
711 SLOGE("deleteSupportCommand003 End");
712 }
713
714 /**
715 * @tc.name: Destroy001
716 * @tc.desc: Return is Session destroyed result
717 * @tc.type: FUNC
718 * @tc.require: AR000H31JF
719 */
720 HWTEST_F(AvsessionTest, Destroy001, TestSize.Level1)
721 {
722 SLOGE("Destroy001 Begin");
723 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
724 avsession_ = nullptr;
725 SLOGE("Destroy001 End");
726 }
727
728 /**
729 * @tc.name: Destroy002
730 * @tc.desc: Return is Session destroyed result
731 * @tc.type: FUNC
732 * @tc.require: AR000H31JF
733 */
734 HWTEST_F(AvsessionTest, Destroy002, TestSize.Level1)
735 {
736 SLOGE("Destroy002 Begin");
737 EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
738 EXPECT_EQ(avsession_->Destroy(), ERR_SESSION_NOT_EXIST);
739 avsession_ = nullptr;
740 SLOGE("Destroy002 End");
741 }