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_controller_stub.h"
19 #include "avsession_errors.h"
20 #include "avsession_manager.h"
21 #include "avsession_log.h"
22 #include "accesstoken_kit.h"
23 #include "bool_wrapper.h"
24 #include "nativetoken_kit.h"
25 #include "token_setproc.h"
26 #include "iavsession_controller.h"
27 #include "iremote_stub.h"
28 #include "want_params.h"
29 #include "ipc_skeleton.h"
30 
31 using namespace testing::ext;
32 using namespace OHOS::Security::AccessToken;
33 
34 namespace OHOS {
35 namespace AVSession {
36 static int32_t g_onCall = AVSESSION_ERROR;
37 static int32_t g_sessionId = AVSESSION_ERROR;
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     .isSystemApp = true
49 };
50 
51 static HapPolicyParams g_policy = {
52     .apl = APL_NORMAL,
53     .domain = "test.domain",
54     .permList = {
55         {
56             .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
57             .bundleName = "ohos.permission_test.demo",
58             .grantMode = 1,
59             .availableLevel = APL_NORMAL,
60             .label = "label",
61             .labelId = 1,
62             .description = "test",
63             .descriptionId = 1
64         }
65     },
66     .permStateList = {
67         {
68             .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
69             .isGeneral = true,
70             .resDeviceID = { "local" },
71             .grantStatus = { PermissionState::PERMISSION_GRANTED },
72             .grantFlags = { 1 }
73         }
74     }
75 };
76 
77 class AVSessionControllerTest : public testing::Test {
78 public:
79     static void SetUpTestCase();
80     static void TearDownTestCase();
81     void SetUp() override;
82     void TearDown() override;
83 
84     std::shared_ptr<AVSession> avsession_ = nullptr;
85     std::shared_ptr<AVSessionController> controller_ = nullptr;
86 
87     static constexpr int64_t TestMicroSecond = 1000;
88     static constexpr int SESSION_LEN = 64;
89 };
90 
SetUpTestCase()91 void AVSessionControllerTest::SetUpTestCase()
92 {
93     g_selfTokenId = GetSelfTokenID();
94     AccessTokenKit::AllocHapToken(g_info, g_policy);
95     AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
96     SetSelfTokenID(tokenID.tokenIDEx);
97 }
98 
TearDownTestCase()99 void AVSessionControllerTest::TearDownTestCase()
100 {
101     SetSelfTokenID(g_selfTokenId);
102     auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
103     AccessTokenKit::DeleteToken(tokenId);
104 }
105 
SetUp()106 void AVSessionControllerTest::SetUp()
107 {
108     OHOS::AppExecFwk::ElementName elementName;
109     elementName.SetBundleName(g_testBundleName);
110     elementName.SetAbilityName(g_testAbilityName);
111     SLOGE("check session create");
112     avsession_ = AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
113                                                                elementName);
114     ASSERT_NE(avsession_, nullptr);
115     g_sessionId++;
116     auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller_);
117     ASSERT_EQ(ret, AVSESSION_SUCCESS);
118     ASSERT_NE(controller_, nullptr);
119 }
120 
TearDown()121 void AVSessionControllerTest::TearDown()
122 {
123     [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
124     if (avsession_ != nullptr) {
125         ret = avsession_->Destroy();
126         avsession_ = nullptr;
127     }
128     if (controller_ != nullptr) {
129         ret = controller_->Destroy();
130         controller_ = nullptr;
131     }
132     g_onCall = AVSESSION_ERROR;
133 }
134 
135 class AVControllerCallbackImpl : public AVControllerCallback {
136 public:
137     void OnSessionDestroy() override;
138 
OnAVCallStateChange(const AVCallState & avCallState)139     void OnAVCallStateChange(const AVCallState& avCallState) override {};
140 
OnAVCallMetaDataChange(const AVCallMetaData & avCallMetaData)141     void OnAVCallMetaDataChange(const AVCallMetaData& avCallMetaData) override {};
142 
143     void OnPlaybackStateChange(const AVPlaybackState& state) override;
144 
145     void OnMetaDataChange(const AVMetaData& data) override;
146 
147     void OnActiveStateChange(bool isActive) override;
148 
149     void OnValidCommandChange(const std::vector<int32_t>& cmds) override;
150 
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 
OnSessionEventChange(const std::string & event,const OHOS::AAFwk::WantParams & args)154     void OnSessionEventChange(const std::string& event, const OHOS::AAFwk::WantParams& args) override {};
155 
OnQueueItemsChange(const std::vector<AVQueueItem> & items)156     void OnQueueItemsChange(const std::vector<AVQueueItem>& items) override {};
157 
OnQueueTitleChange(const std::string & title)158     void OnQueueTitleChange(const std::string& title) override {};
159 
OnExtrasChange(const OHOS::AAFwk::WantParams & extras)160     void OnExtrasChange(const OHOS::AAFwk::WantParams& extras) override {};
161 
162     ~AVControllerCallbackImpl() override;
163 
164     bool isActive_ = false;
165     AVMetaData data_;
166     AVPlaybackState state_;
167     bool isDestory_ = false;
168     std::vector<int32_t> cmds_;
169     std::vector<AVQueueItem> items_;
170     std::string title_;
171 };
172 
~AVControllerCallbackImpl()173 AVControllerCallbackImpl::~AVControllerCallbackImpl()
174 {
175 }
176 
OnSessionDestroy()177 void AVControllerCallbackImpl::OnSessionDestroy()
178 {
179     isDestory_ = true;
180 }
181 
OnPlaybackStateChange(const AVPlaybackState & state)182 void AVControllerCallbackImpl::OnPlaybackStateChange(const AVPlaybackState& state)
183 {
184     state_ = state;
185 }
186 
OnMetaDataChange(const AVMetaData & data)187 void AVControllerCallbackImpl::OnMetaDataChange(const AVMetaData& data)
188 {
189     data_ = data;
190 }
191 
OnActiveStateChange(bool isActive)192 void AVControllerCallbackImpl::OnActiveStateChange(bool isActive)
193 {
194     isActive_ = isActive;
195 }
196 
OnValidCommandChange(const std::vector<int32_t> & cmds)197 void AVControllerCallbackImpl::OnValidCommandChange(const std::vector<int32_t>& cmds)
198 {
199     cmds_ = cmds;
200 }
201 
IsAVPlaybackStateEqual(AVPlaybackState & state1,AVPlaybackState & state2)202 bool IsAVPlaybackStateEqual(AVPlaybackState& state1,  AVPlaybackState& state2)
203 {
204     return state1.GetState() == state2.GetState() &&
205         std::fabs(state1.GetSpeed() - state2.GetSpeed()) < 1e-6 &&
206         state1.GetPosition().elapsedTime_ == state2.GetPosition().elapsedTime_ &&
207         state1.GetBufferedTime() == state2.GetBufferedTime() &&
208         state1.GetLoopMode() == state2.GetLoopMode() &&
209         state1.GetFavorite() == state2.GetFavorite();
210 }
211 
212 class AVSessionControllerStubTest : public AVSessionControllerStub {
213 public:
214     int32_t GetAVCallState(AVCallState& avCallState) override;
215     int32_t GetAVCallMetaData(AVCallMetaData& avCallMetaData) override;
216     int32_t SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType& filter) override;
217     int32_t SetAVCallStateFilter(const AVCallState::AVCallStateMaskType& filter) override;
218     int32_t GetAVPlaybackState(AVPlaybackState& state) override;
219     int32_t GetAVMetaData(AVMetaData& data) override;
220     int32_t SendAVKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override;
221     int32_t GetLaunchAbility(OHOS::AbilityRuntime::WantAgent::WantAgent& ability) override;
222     int32_t GetValidCommands(std::vector<int32_t>& cmds) override;
223     int32_t IsSessionActive(bool& isActive) override;
224     int32_t SendControlCommand(const AVControlCommand& cmd) override;
225     int32_t SendCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override;
226     int32_t SetMetaFilter(const AVMetaData::MetaMaskType& filter) override;
227     int32_t SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType& filter) override;
228     int32_t GetAVQueueItems(std::vector<AVQueueItem>& items) override;
229     int32_t GetAVQueueTitle(std::string& title) override;
230     int32_t SkipToQueueItem(int32_t& itemId) override;
231     int32_t GetExtras(OHOS::AAFwk::WantParams& extras) override;
232     int32_t Destroy() override;
233     std::string GetSessionId() override;
234     int32_t RegisterCallbackInner(const OHOS::sptr<IRemoteObject>& callback) override;
235 };
236 
GetAVCallState(AVCallState & avCallState)237 int32_t AVSessionControllerStubTest::GetAVCallState(AVCallState& avCallState)
238 {
239     return 0;
240 }
GetAVCallMetaData(AVCallMetaData & avCallMetaData)241 int32_t AVSessionControllerStubTest::GetAVCallMetaData(AVCallMetaData& avCallMetaData)
242 {
243     return 0;
244 }
SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType & filter)245 int32_t AVSessionControllerStubTest::SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType& filter)
246 {
247     return 0;
248 }
SetAVCallStateFilter(const AVCallState::AVCallStateMaskType & filter)249 int32_t AVSessionControllerStubTest::SetAVCallStateFilter(const AVCallState::AVCallStateMaskType& filter)
250 {
251     return 0;
252 }
253 
GetAVPlaybackState(AVPlaybackState & state)254 int32_t AVSessionControllerStubTest::GetAVPlaybackState(AVPlaybackState& state)
255 {
256     return 0;
257 }
258 
GetAVMetaData(AVMetaData & data)259 int32_t AVSessionControllerStubTest::GetAVMetaData(AVMetaData& data)
260 {
261     return 0;
262 }
263 
SendAVKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)264 int32_t AVSessionControllerStubTest::SendAVKeyEvent(const OHOS::MMI::KeyEvent& keyEvent)
265 {
266     return 0;
267 }
268 
GetLaunchAbility(OHOS::AbilityRuntime::WantAgent::WantAgent & ability)269 int32_t AVSessionControllerStubTest::GetLaunchAbility(OHOS::AbilityRuntime::WantAgent::WantAgent& ability)
270 {
271     return 0;
272 }
273 
GetValidCommands(std::vector<int32_t> & cmds)274 int32_t AVSessionControllerStubTest::GetValidCommands(std::vector<int32_t>& cmds)
275 {
276     return 0;
277 }
278 
IsSessionActive(bool & isActive)279 int32_t AVSessionControllerStubTest::IsSessionActive(bool& isActive)
280 {
281     return 0;
282 }
283 
SendControlCommand(const AVControlCommand & cmd)284 int32_t AVSessionControllerStubTest::SendControlCommand(const AVControlCommand& cmd)
285 {
286     return 0;
287 }
288 
SendCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)289 int32_t AVSessionControllerStubTest::SendCommonCommand(const std::string& commonCommand,
290     const OHOS::AAFwk::WantParams& commandArgs)
291 {
292     return 0;
293 }
294 
SetMetaFilter(const AVMetaData::MetaMaskType & filter)295 int32_t AVSessionControllerStubTest::SetMetaFilter(const AVMetaData::MetaMaskType& filter)
296 {
297     return 0;
298 }
299 
SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType & filter)300 int32_t AVSessionControllerStubTest::SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType& filter)
301 {
302     return 0;
303 }
304 
GetAVQueueItems(std::vector<AVQueueItem> & items)305 int32_t AVSessionControllerStubTest::GetAVQueueItems(std::vector<AVQueueItem>& items)
306 {
307     return 0;
308 }
309 
GetAVQueueTitle(std::string & title)310 int32_t AVSessionControllerStubTest::GetAVQueueTitle(std::string& title)
311 {
312     return 0;
313 }
314 
SkipToQueueItem(int32_t & itemId)315 int32_t AVSessionControllerStubTest::SkipToQueueItem(int32_t& itemId)
316 {
317     return 0;
318 }
319 
GetExtras(OHOS::AAFwk::WantParams & extras)320 int32_t AVSessionControllerStubTest::GetExtras(OHOS::AAFwk::WantParams& extras)
321 {
322     return 0;
323 }
324 
Destroy()325 int32_t AVSessionControllerStubTest::Destroy()
326 {
327     return 0;
328 }
329 
GetSessionId()330 std::string AVSessionControllerStubTest::GetSessionId()
331 {
332     return NULL;
333 }
334 
RegisterCallbackInner(const OHOS::sptr<IRemoteObject> & callback)335 int32_t AVSessionControllerStubTest::RegisterCallbackInner(const OHOS::sptr<IRemoteObject>& callback)
336 {
337     return 0;
338 }
339 
340 /**
341 * @tc.name: IsSessionActive001
342 * @tc.desc: Return is Session Actived
343 * @tc.type: FUNC
344 * @tc.require: AR000H31JI
345 */
346 HWTEST_F(AVSessionControllerTest, IsSessionActive001, TestSize.Level1)
347 {
348     bool active = true;
349     EXPECT_EQ(controller_->IsSessionActive(active), AVSESSION_SUCCESS);
350     EXPECT_EQ(active, false);
351     EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
352     EXPECT_EQ(controller_->IsSessionActive(active), AVSESSION_SUCCESS);
353     EXPECT_EQ(active, true);
354 }
355 
356 /**
357 * @tc.name: IsSessionActive002
358 * @tc.desc: Return is Session Actived
359 * @tc.type: FUNC
360 * @tc.require: AR000H31JI
361 */
362 HWTEST_F(AVSessionControllerTest, IsSessionActive002, TestSize.Level1)
363 {
364     bool active = true;
365     EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
366     EXPECT_EQ(controller_->IsSessionActive(active), AVSESSION_SUCCESS);
367     EXPECT_EQ(active, false);
368 }
369 
370 /**
371 * @tc.name: IsSessionActive003
372 * @tc.desc: Return is Session Actived
373 * @tc.type: FUNC
374 * @tc.require: AR000H31JI
375 */
376 HWTEST_F(AVSessionControllerTest, IsSessionActive003, TestSize.Level1)
377 {
378     bool active = false;
379     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
380     EXPECT_EQ(controller_->IsSessionActive(active), ERR_SESSION_NOT_EXIST);
381 }
382 
383 /**
384 * @tc.name: GetAVPlaybackState001
385 * @tc.desc: Return AVPlaybackState
386 * @tc.type: FUNC
387 * @tc.require: AR000H31JI
388 */
389 HWTEST_F(AVSessionControllerTest, GetAVPlaybackState001, TestSize.Level1)
390 {
391     AVMetaData metaData;
392     metaData.Reset();
393     metaData.SetAssetId("001");
394     metaData.SetDuration(10);
395     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
396     AVPlaybackState state;
397     state.SetState(1);
398     state.SetSpeed(1);
399     state.SetBufferedTime(1);
400     state.SetPosition({1, 0});
401     state.SetLoopMode(1);
402     state.SetFavorite(true);
403     EXPECT_EQ(avsession_->SetAVPlaybackState(state), AVSESSION_SUCCESS);
404     AVPlaybackState resultState;
405     EXPECT_EQ(controller_->GetAVPlaybackState(resultState), AVSESSION_SUCCESS);
406     EXPECT_EQ(IsAVPlaybackStateEqual(state, resultState), true);
407 }
408 
409 /**
410 * @tc.name: GetAVPlaybackState002
411 * @tc.desc: Return AVPlaybackState
412 * @tc.type: FUNC
413 * @tc.require: AR000H31JI
414 */
415 HWTEST_F(AVSessionControllerTest, GetAVPlaybackState002, TestSize.Level1)
416 {
417     AVPlaybackState state;
418     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
419     EXPECT_EQ(controller_->GetAVPlaybackState(state), ERR_SESSION_NOT_EXIST);
420 }
421 
422 /**
423 * @tc.name: GetAVMetaData001
424 * @tc.desc: Return AVMetaData
425 * @tc.type: FUNC
426 * @tc.require: AR000H31JI
427 */
428 HWTEST_F(AVSessionControllerTest, GetAVMetaData001, TestSize.Level1)
429 {
430     AVMetaData metaData;
431     metaData.Reset();
432     metaData.SetAssetId("001");
433     metaData.SetTitle("123456");
434     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
435     AVMetaData resultMetaData;
436     resultMetaData.Reset();
437     EXPECT_EQ(controller_->GetAVMetaData(resultMetaData), AVSESSION_SUCCESS);
438     EXPECT_EQ(resultMetaData.GetAssetId(), "001");
439     EXPECT_EQ(resultMetaData.GetTitle(), "123456");
440 }
441 
442 /**
443 * @tc.name: GetAVMetaData002
444 * @tc.desc: Return AVMetaData
445 * @tc.type: FUNC
446 * @tc.require: AR000H31JI
447 */
448 HWTEST_F(AVSessionControllerTest, GetAVMetaData002, TestSize.Level1)
449 {
450     AVMetaData metaData;
451     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
452     EXPECT_EQ(controller_->GetAVMetaData(metaData), ERR_SESSION_NOT_EXIST);
453 }
454 
455 /**
456 * @tc.name: SendMediaButtonEvent001
457 * @tc.desc: send System Media KeyEvent to system center
458 * @tc.type: FUNC
459 * @tc.require: AR000H31JI
460 */
461 HWTEST_F(AVSessionControllerTest, SendMediaButtonEvent001, TestSize.Level1)
462 {
463     auto keyEvent = OHOS::MMI::KeyEvent::Create();
464     ASSERT_NE(keyEvent, nullptr);
465     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
466     keyEvent->SetActionTime(1);
467     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
468     OHOS::MMI::KeyEvent::KeyItem item;
469     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
470     item.SetDownTime(1);
471     item.SetPressed(true);
472     keyEvent->AddKeyItem(item);
473     ASSERT_EQ(keyEvent->IsValid(), true);
474 
475     bool isActive = false;
476     controller_->IsSessionActive(isActive);
477     if (!isActive) {
478         avsession_->Activate();
479     }
480     EXPECT_EQ(controller_->SendAVKeyEvent(*(keyEvent.get())), AVSESSION_SUCCESS);
481 }
482 
483 /**
484 * @tc.name: SendMediaButtonEvent002
485 * @tc.desc: send System Media KeyEvent to system center
486 * @tc.type: FUNC
487 * @tc.require: AR000H31JI
488 */
489 HWTEST_F(AVSessionControllerTest, SendMediaButtonEvent002, TestSize.Level1)
490 {
491     auto keyEvent = OHOS::MMI::KeyEvent::Create();
492     ASSERT_NE(keyEvent, nullptr);
493     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
494     keyEvent->SetActionTime(1);
495     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_CANCEL);
496     ASSERT_EQ(keyEvent->IsValid(), false);
497 
498     EXPECT_EQ(controller_->SendAVKeyEvent(*(keyEvent.get())), ERR_COMMAND_NOT_SUPPORT);
499 }
500 
501 /**
502 * @tc.name: SendMediaButtonEvent003
503 * @tc.desc: send System Media KeyEvent to system center
504 * @tc.type: FUNC
505 * @tc.require: AR000H31JI
506 */
507 HWTEST_F(AVSessionControllerTest, SendMediaButtonEvent003, TestSize.Level1)
508 {
509     auto keyEvent = OHOS::MMI::KeyEvent::Create();
510     ASSERT_NE(keyEvent, nullptr);
511     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
512     keyEvent->SetActionTime(1);
513     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
514     OHOS::MMI::KeyEvent::KeyItem item;
515     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HOME);
516     item.SetDownTime(1);
517     item.SetPressed(true);
518     keyEvent->AddKeyItem(item);
519     ASSERT_EQ(keyEvent->IsValid(), true);
520 
521     EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
522     EXPECT_EQ(controller_->SendAVKeyEvent(*(keyEvent.get())), ERR_SESSION_DEACTIVE);
523 }
524 
525 /**
526 * @tc.name: GetLaunchAbility001
527 * @tc.desc: get launch ability
528 * @tc.type: FUNC
529 * @tc.require: AR000H31JI
530 */
531 HWTEST_F(AVSessionControllerTest, GetLaunchAbility001, TestSize.Level1)
532 {
533     OHOS::AbilityRuntime::WantAgent::WantAgent ability1;
534     EXPECT_EQ(avsession_->SetLaunchAbility(ability1), AVSESSION_SUCCESS);
535     OHOS::AbilityRuntime::WantAgent::WantAgent ability2;
536     EXPECT_EQ(controller_->GetLaunchAbility(ability2), AVSESSION_SUCCESS);
537 }
538 
539 /**
540 * @tc.name: GetLaunchAbility002
541 * @tc.desc: get launch ability
542 * @tc.type: FUNC
543 * @tc.require: AR000H31JI
544 */
545 HWTEST_F(AVSessionControllerTest, GetLaunchAbility002, TestSize.Level1)
546 {
547     OHOS::AbilityRuntime::WantAgent::WantAgent ability;
548     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
549     EXPECT_EQ(controller_->GetLaunchAbility(ability), ERR_SESSION_NOT_EXIST);
550 }
551 
552 /**
553 * @tc.name: GetValidCommands001
554 * @tc.desc: get supported command
555 * @tc.type: FUNC
556 * @tc.require: AR000H31JI
557 */
558 HWTEST_F(AVSessionControllerTest, GetValidCommands001, TestSize.Level1)
559 {
560     std::vector<int32_t> cmds;
561     EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
562     EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PAUSE), AVSESSION_SUCCESS);
563     EXPECT_EQ(controller_->GetValidCommands(cmds), AVSESSION_SUCCESS);
564     std::vector<int32_t>::iterator it = std::find(cmds.begin(), cmds.end(), AVControlCommand::SESSION_CMD_PLAY);
565     EXPECT_NE(it, cmds.end());
566     it = std::find(cmds.begin(), cmds.end(), AVControlCommand::SESSION_CMD_PAUSE);
567     EXPECT_NE(it, cmds.end());
568     it = std::find(cmds.begin(), cmds.end(), AVControlCommand::SESSION_CMD_STOP);
569     EXPECT_EQ(it, cmds.end());
570 }
571 
572 /**
573 * @tc.name: GetValidCommands002
574 * @tc.desc: get supported command
575 * @tc.type: FUNC
576 * @tc.require: AR000H31JI
577 */
578 HWTEST_F(AVSessionControllerTest, GetValidCommands002, TestSize.Level1)
579 {
580     std::vector<int32_t> cmds;
581     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
582     EXPECT_EQ(controller_->GetValidCommands(cmds), ERR_SESSION_NOT_EXIST);
583 }
584 
585 /**
586 * @tc.name: SendControlCommand001
587 * @tc.desc: send command, check if AVControlCommand is invalid
588 * @tc.type: FUNC
589 * @tc.require: AR000H31JH
590 */
591 HWTEST_F(AVSessionControllerTest, SendControlCommand001, TestSize.Level1)
592 {
593     AVControlCommand command;
594     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_INVALID), ERR_INVALID_PARAM);
595     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_MAX), ERR_INVALID_PARAM);
596     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_CUSTOM + 1), ERR_INVALID_PARAM);
597     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_UNDEFINED - 1), ERR_INVALID_PARAM);
598     EXPECT_EQ(command.SetSpeed(-1), ERR_INVALID_PARAM);
599     EXPECT_EQ(command.SetAssetId(""), ERR_INVALID_PARAM);
600 }
601 
602 /**
603 * @tc.name: SendControlCommand002
604 * @tc.desc: send command, check if AVControlCommand is invalid
605 * @tc.type: FUNC
606 * @tc.require: AR000H31JH
607 */
608 HWTEST_F(AVSessionControllerTest, SendControlCommand002, TestSize.Level1)
609 {
610     AVControlCommand command;
611     int32_t mode = 0;
612     double speed = 0.0;
613     int64_t time = 0;
614     std::string assetId;
615     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_SEQUENCE), AVSESSION_SUCCESS);
616     EXPECT_EQ(command.GetSpeed(speed), AVSESSION_ERROR);
617     EXPECT_EQ(command.GetSeekTime(time), AVSESSION_ERROR);
618     EXPECT_EQ(command.GetAssetId(assetId), AVSESSION_ERROR);
619     EXPECT_EQ(command.GetLoopMode(mode), AVSESSION_SUCCESS);
620     EXPECT_EQ(mode, AVPlaybackState::LOOP_MODE_SEQUENCE);
621 }
622 
623 /**
624 * @tc.name: SendControlCommand003
625 * @tc.desc: send command, check if AVControlCommand is invalid
626 * @tc.type: FUNC
627 * @tc.require: AR000H31JH
628 */
629 HWTEST_F(AVSessionControllerTest, SendControlCommand003, TestSize.Level1)
630 {
631     AVControlCommand command;
632     int32_t mode = 0;
633     double speed = 0.0;
634     int64_t time = 0;
635     std::string assetId;
636     EXPECT_EQ(command.SetAssetId("123456"), AVSESSION_SUCCESS);
637     EXPECT_EQ(command.GetSpeed(speed), AVSESSION_ERROR);
638     EXPECT_EQ(command.GetSeekTime(time), AVSESSION_ERROR);
639     EXPECT_EQ(command.GetLoopMode(mode), AVSESSION_ERROR);
640     EXPECT_EQ(command.GetAssetId(assetId), AVSESSION_SUCCESS);
641     EXPECT_EQ(assetId, "123456");
642 }
643 
644 /**
645 * @tc.name: SendControlCommand004
646 * @tc.desc: send command, check if AVControlCommand is invalid
647 * @tc.type: FUNC
648 * @tc.require: AR000H31JH
649 */
650 HWTEST_F(AVSessionControllerTest, SendControlCommand004, TestSize.Level1)
651 {
652     AVControlCommand command;
653     int32_t mode = 0;
654     double speed = 0.0;
655     int64_t time = 0;
656     std::string assetId;
657     EXPECT_EQ(command.SetSpeed(1.0), AVSESSION_SUCCESS);
658     EXPECT_EQ(command.GetSeekTime(time), AVSESSION_ERROR);
659     EXPECT_EQ(command.GetAssetId(assetId), AVSESSION_ERROR);
660     EXPECT_EQ(command.GetLoopMode(mode), AVSESSION_ERROR);
661     EXPECT_EQ(command.GetSpeed(speed), AVSESSION_SUCCESS);
662     EXPECT_EQ(std::fabs(speed - 1.0) < 1e-6, true);
663 }
664 
665 /**
666 * @tc.name: SendControlCommand005
667 * @tc.desc: send command, check if AVControlCommand is invalid
668 * @tc.type: FUNC
669 * @tc.require: AR000H31JH
670 */
671 HWTEST_F(AVSessionControllerTest, SendControlCommand005, TestSize.Level1)
672 {
673     AVControlCommand command;
674     int32_t mode = 0;
675     double speed = 0.0;
676     int64_t time = 0;
677     std::string assetId;
678     command.SetSeekTime(1);
679     EXPECT_EQ(command.GetAssetId(assetId), AVSESSION_ERROR);
680     EXPECT_EQ(command.GetLoopMode(mode), AVSESSION_ERROR);
681     EXPECT_EQ(command.GetSpeed(speed), AVSESSION_ERROR);
682     EXPECT_EQ(command.GetSeekTime(time), AVSESSION_SUCCESS);
683     EXPECT_EQ(time, 1);
684 }
685 
686 /**
687 * @tc.name: SendControlCommand006
688 * @tc.desc: send command, check if AVControlCommand is invalid
689 * @tc.type: FUNC
690 * @tc.require: AR000H31JH
691 */
692 HWTEST_F(AVSessionControllerTest, SendControlCommand006, TestSize.Level1)
693 {
694     AVControlCommand command;
695     OHOS::Parcel parcel;
696     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE), AVSESSION_SUCCESS);
697     EXPECT_EQ(command.SetAssetId("123456"), AVSESSION_SUCCESS);
698     EXPECT_EQ(command.Marshalling(parcel), false);
699 }
700 
701 /**
702 * @tc.name: SendControlCommand007
703 * @tc.desc: send command, check if AVControlCommand is invalid
704 * @tc.type: FUNC
705 * @tc.require: AR000H31JH
706 */
707 HWTEST_F(AVSessionControllerTest, SendControlCommand007, TestSize.Level1)
708 {
709     AVControlCommand command;
710     int32_t mode = -1;
711     OHOS::Parcel parcel;
712     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE), AVSESSION_SUCCESS);
713     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_SEQUENCE), AVSESSION_SUCCESS);
714     EXPECT_EQ(command.Marshalling(parcel), true);
715     AVControlCommand *ret = AVControlCommand::Unmarshalling(parcel);
716     EXPECT_NE(ret, nullptr);
717     EXPECT_EQ(ret->GetCommand(), AVControlCommand::SESSION_CMD_SET_LOOP_MODE);
718     EXPECT_EQ(ret->GetLoopMode(mode), AVSESSION_SUCCESS);
719     EXPECT_EQ(mode, AVPlaybackState::LOOP_MODE_SEQUENCE);
720     delete ret;
721 }
722 
723 /**
724 * @tc.name: SendControlCommand008
725 * @tc.desc: send command, check if AVControlCommand is valid
726 * @tc.type: FUNC
727 * @tc.require: AR000H31JH
728 */
729 HWTEST_F(AVSessionControllerTest, SendControlCommand008, TestSize.Level1)
730 {
731     AVControlCommand command;
732     EXPECT_EQ(controller_->SendControlCommand(command), ERR_COMMAND_NOT_SUPPORT);
733 }
734 
735 /**
736 * @tc.name: SendControlCommand009
737 * @tc.desc: send command, check if AVControlCommand is valid
738 * @tc.type: FUNC
739 * @tc.require: AR000H31JH
740 */
741 HWTEST_F(AVSessionControllerTest, SendControlCommand009, TestSize.Level1)
742 {
743     AVControlCommand command;
744     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE), AVSESSION_SUCCESS);
745     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_SEQUENCE), AVSESSION_SUCCESS);
746     bool isActive = false;
747     controller_->IsSessionActive(isActive);
748     if (!isActive) {
749         avsession_->Activate();
750     }
751     EXPECT_EQ(controller_->SendControlCommand(command), ERR_COMMAND_NOT_SUPPORT);
752 }
753 
754 /**
755 * @tc.name: SendControlCommand010
756 * @tc.desc: send command, check if AVControlCommand is valid
757 * @tc.type: FUNC
758 * @tc.require: AR000H31JH
759 */
760 HWTEST_F(AVSessionControllerTest, SendControlCommand010, TestSize.Level1)
761 {
762     AVControlCommand command;
763     EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE), AVSESSION_SUCCESS);
764     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_SET_LOOP_MODE), AVSESSION_SUCCESS);
765     EXPECT_EQ(command.SetLoopMode(AVPlaybackState::LOOP_MODE_SEQUENCE), AVSESSION_SUCCESS);
766     bool isActive = false;
767     controller_->IsSessionActive(isActive);
768     if (!isActive) {
769         avsession_->Activate();
770     }
771     EXPECT_EQ(controller_->SendControlCommand(command), AVSESSION_SUCCESS);
772 }
773 
774 /**
775 * @tc.name: SendControlCommand011
776 * @tc.desc: send command, check if AVControlCommand is valid
777 * @tc.type: FUNC
778 * @tc.require: AR000H31JH
779 */
780 HWTEST_F(AVSessionControllerTest, SendControlCommand011, TestSize.Level1)
781 {
782     AVControlCommand command;
783     EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_TOGGLE_FAVORITE), AVSESSION_SUCCESS);
784     EXPECT_EQ(command.SetAssetId("123456"), AVSESSION_SUCCESS);
785 
786     EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
787     EXPECT_EQ(controller_->SendControlCommand(command), ERR_SESSION_DEACTIVE);
788 }
789 
790 /**
791 * @tc.name: SendControlCommand012
792 * @tc.desc: same pid can only send command 10 times per second successful
793 * @tc.type: FUNC
794 * @tc.require: AR000H31JH
795 */
796 HWTEST_F(AVSessionControllerTest, SendControlCommand012, TestSize.Level1)
797 {
798     sleep(1);
799     EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
800     EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
801     int failedCount = 0;
802     /**
803     * 21 = 10 * 2 + 1,
804     * The timer resets the number of command sending times per second.
805     * 21 can ensure at least one failure
806     */
807     for (int i = 0; i < 21; i++) {
808         AVControlCommand command;
809         EXPECT_EQ(command.SetCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
810         auto ret = controller_->SendControlCommand(command);
811         if (ret != AVSESSION_SUCCESS) {
812             failedCount++;
813             EXPECT_EQ(ret, ERR_COMMAND_SEND_EXCEED_MAX);
814         }
815     }
816     EXPECT_EQ(failedCount >= 1, true);
817     EXPECT_EQ(failedCount <= 11, true);
818 }
819 
820 /**
821 * @tc.name: SendCommonCommand001
822 * @tc.desc: Send common command - session is activate
823 * @tc.type: FUNC
824 * @tc.require: I6ETY6
825 */
826 HWTEST_F(AVSessionControllerTest, SendCommonCommand001, TestSize.Level1)
827 {
828     SLOGI("SendCommonCommand001 Begin");
829     avsession_->Activate();
830     std::string commonCommand = "common_command";
831     OHOS::AAFwk::WantParams commandArgs;
832     sleep(1);
833     int ret = controller_->SendCommonCommand(commonCommand, commandArgs);
834     SLOGI("SendCommonCommand001 get ret %{public}d", ret);
835     EXPECT_EQ(ret, AVSESSION_SUCCESS);
836 
837     SLOGI("SendCommonCommand001 End");
838 }
839 
840 /**
841 * @tc.name: SendCommonCommand002
842 * @tc.desc: Send common command - session is deactivate
843 * @tc.type: FUNC
844 * @tc.require: I6ETY6
845 */
846 HWTEST_F(AVSessionControllerTest, SendCommonCommand002, TestSize.Level1)
847 {
848     SLOGI("SendCommonCommand002 Begin");
849     avsession_->Activate();
850     std::string commonCommand = "common_command";
851     OHOS::AAFwk::WantParams commandArgs;
852     sleep(1);
853     int ret = controller_->SendCommonCommand(commonCommand, commandArgs);
854     SLOGI("SendCommonCommand002 get ret %{public}d", ret);
855     EXPECT_EQ(ret, AVSESSION_SUCCESS);
856     EXPECT_EQ(avsession_->Deactivate(), AVSESSION_SUCCESS);
857     EXPECT_EQ(controller_->SendCommonCommand(commonCommand, commandArgs), ERR_SESSION_DEACTIVE);
858     SLOGI("SendCommonCommand002 End");
859 }
860 
861 /**
862 * @tc.name: RegisterCallback001
863 * @tc.desc: register AVControllerCallback
864 * @tc.type: FUNC
865 * @tc.require: AR000H31JK
866 */
867 HWTEST_F(AVSessionControllerTest, RegisterCallback001, TestSize.Level1)
868 {
869     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
870     EXPECT_NE(callback, nullptr);
871     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
872 }
873 
874 /**
875 * @tc.name: RegisterCallback002
876 * @tc.desc: register AVControllerCallback
877 * @tc.type: FUNC
878 * @tc.require: AR000H31JK
879 */
880 HWTEST_F(AVSessionControllerTest, RegisterCallback002, TestSize.Level1)
881 {
882     std::shared_ptr<AVControllerCallbackImpl> callback = nullptr;
883     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
884 }
885 
886 /**
887 * @tc.name: RegisterCallback003
888 * @tc.desc: register AVControllerCallback
889 * @tc.type: FUNC
890 * @tc.require: AR000H31JK
891 */
892 HWTEST_F(AVSessionControllerTest, RegisterCallback003, TestSize.Level1)
893 {
894     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
895     EXPECT_NE(callback, nullptr);
896     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
897     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
898     std::shared_ptr<AVControllerCallbackImpl> callbackNew = std::make_shared<AVControllerCallbackImpl>();
899     EXPECT_EQ(controller_->RegisterCallback(callbackNew), AVSESSION_SUCCESS);
900 }
901 
902 /**
903 * @tc.name: RegisterCallback004
904 * @tc.desc: register AVControllerCallback
905 * @tc.type: FUNC
906 * @tc.require: AR000H31JK
907 */
908 HWTEST_F(AVSessionControllerTest, RegisterCallback004, TestSize.Level1)
909 {
910     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
911     EXPECT_NE(callback, nullptr);
912     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
913 
914     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
915     sleep(1);
916     EXPECT_EQ(callback->isDestory_, true);
917 }
918 
919 /**
920 * @tc.name: RegisterCallback005
921 * @tc.desc: register AVControllerCallback
922 * @tc.type: FUNC
923 * @tc.require: AR000H31JK
924 */
925 HWTEST_F(AVSessionControllerTest, RegisterCallback005, TestSize.Level1)
926 {
927     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
928     EXPECT_NE(callback, nullptr);
929     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
930 
931     EXPECT_EQ(avsession_->Activate(), AVSESSION_SUCCESS);
932     sleep(1);
933     EXPECT_EQ(callback->isActive_, true);
934 }
935 
936 /**
937 * @tc.name: RegisterCallback006
938 * @tc.desc: register AVControllerCallback
939 * @tc.type: FUNC
940 * @tc.require: AR000H31JK
941 */
942 HWTEST_F(AVSessionControllerTest, RegisterCallback006, TestSize.Level1)
943 {
944     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
945     EXPECT_NE(callback, nullptr);
946     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
947 
948     EXPECT_EQ(avsession_->AddSupportCommand(AVControlCommand::SESSION_CMD_PLAY), AVSESSION_SUCCESS);
949     sleep(1);
950     std::vector<int32_t> cmds = callback->cmds_;
951     std::vector<int32_t>::iterator it = std::find(cmds.begin(), cmds.end(), AVControlCommand::SESSION_CMD_PLAY);
952     EXPECT_NE(it, cmds.end());
953 }
954 
955 /**
956 * @tc.name: SetMetaFilter001
957 * @tc.desc: set meta filter,the func GetAVMetaData will return the item which is not in the meta filter
958 * @tc.type: FUNC
959 * @tc.require: AR000H31JK
960 */
961 HWTEST_F(AVSessionControllerTest, SetMetaFilter001, TestSize.Level1)
962 {
963     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
964     EXPECT_NE(callback, nullptr);
965     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
966     AVMetaData::MetaMaskType filter;
967     filter.set(AVMetaData::META_KEY_TITLE);
968     EXPECT_EQ(controller_->SetMetaFilter(filter), AVSESSION_SUCCESS);
969     AVMetaData metaData;
970     metaData.Reset();
971     metaData.SetAssetId("001");
972     metaData.SetTitle("123456");
973     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
974 
975     sleep(1);
976     EXPECT_EQ(callback->data_.GetAssetId(), "001");
977     EXPECT_EQ(callback->data_.GetTitle(), "123456");
978 }
979 
980 /**
981 * @tc.name: SetMetaFilter002
982 * @tc.desc: set meta filter,the func GetAVMetaData will return the item which is not in the meta filter
983 * @tc.type: FUNC
984 * @tc.require: AR000H31JK
985 */
986 HWTEST_F(AVSessionControllerTest, SetMetaFilter002, TestSize.Level1)
987 {
988     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
989     EXPECT_NE(callback, nullptr);
990     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
991     AVMetaData::MetaMaskType filter;
992     EXPECT_EQ(controller_->SetMetaFilter(filter), AVSESSION_SUCCESS);
993     AVMetaData metaData;
994     metaData.Reset();
995     metaData.SetAssetId("001");
996     metaData.SetTitle("123456");
997     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
998 
999     sleep(1);
1000     EXPECT_EQ(callback->data_.GetAssetId(), "");
1001     EXPECT_EQ(callback->data_.GetTitle(), "");
1002 }
1003 
1004 /**
1005 * @tc.name: SetPlaybackFilter001
1006 * @tc.desc: set playback filter,the func GetAVPlaybackData will return the item which is not in the playback filter
1007 * @tc.type: FUNC
1008 * @tc.require: AR000H31JK
1009 */
1010 HWTEST_F(AVSessionControllerTest, SetPlaybackFilter001, TestSize.Level1)
1011 {
1012     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
1013     EXPECT_NE(callback, nullptr);
1014     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
1015     AVPlaybackState::PlaybackStateMaskType filter;
1016     filter.set();
1017     EXPECT_EQ(controller_->SetPlaybackFilter(filter), AVSESSION_SUCCESS);
1018     AVPlaybackState state;
1019     state.SetLoopMode(AVPlaybackState::LOOP_MODE_LIST);
1020     state.SetState(AVPlaybackState::PLAYBACK_STATE_PREPARE);
1021     EXPECT_EQ(avsession_->SetAVPlaybackState(state), AVSESSION_SUCCESS);
1022 
1023     sleep(1);
1024     EXPECT_EQ(callback->state_.GetState(), AVPlaybackState::PLAYBACK_STATE_PREPARE);
1025     EXPECT_EQ(callback->state_.GetLoopMode(), AVPlaybackState::LOOP_MODE_LIST);
1026 }
1027 
1028 /**
1029 * @tc.name: SetPlaybackFilter002
1030 * @tc.desc: set meta filter,the func GetAVPlaybackData will return the item which is not in the playback filter
1031 * @tc.type: FUNC
1032 * @tc.require: AR000H31JK
1033 */
1034 HWTEST_F(AVSessionControllerTest, SetPlaybackFilter002, TestSize.Level1)
1035 {
1036     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
1037     EXPECT_NE(callback, nullptr);
1038     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
1039     AVPlaybackState::PlaybackStateMaskType filter;
1040     EXPECT_EQ(controller_->SetPlaybackFilter(filter), AVSESSION_SUCCESS);
1041     AVPlaybackState state;
1042     state.SetLoopMode(AVPlaybackState::LOOP_MODE_LIST);
1043     state.SetState(AVPlaybackState::PLAYBACK_STATE_PREPARE);
1044     EXPECT_EQ(avsession_->SetAVPlaybackState(state), AVSESSION_SUCCESS);
1045 
1046     sleep(1);
1047     EXPECT_NE(callback->state_.GetState(), AVPlaybackState::PLAYBACK_STATE_PREPARE);
1048     EXPECT_NE(callback->state_.GetLoopMode(), AVPlaybackState::LOOP_MODE_LIST);
1049 }
1050 
1051 /**
1052 * @tc.name: GetSessionId001
1053 * @tc.desc: Get SessionId bind with controller, check if GetSessionId is valid
1054 * @tc.type: FUNC
1055 * @tc.require: AR000H31JH
1056 */
1057 HWTEST_F(AVSessionControllerTest, GetSessionId001, TestSize.Level1)
1058 {
1059     std::string id = controller_->GetSessionId();
1060     EXPECT_EQ(id.length() == SESSION_LEN, true);
1061     EXPECT_EQ(id, avsession_->GetSessionId());
1062 }
1063 
1064 /**
1065 * @tc.name: GetSessionId002
1066 * @tc.desc: Get SessionId bind with controller, check if GetSessionId is valid
1067 * @tc.type: FUNC
1068 * @tc.require: AR000H31JH
1069 */
1070 HWTEST_F(AVSessionControllerTest, GetSessionId002, TestSize.Level1)
1071 {
1072     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
1073     std::string id = controller_->GetSessionId();
1074     EXPECT_EQ(id, "");
1075 }
1076 
1077 /**
1078 * @tc.name: GetRealPlaybackPosition001
1079 * @tc.desc: GetRealPlaybackPosition after recive callback
1080 * @tc.type: FUNC
1081 * @tc.require: AR000H31JK
1082 */
1083 HWTEST_F(AVSessionControllerTest, GetRealPlaybackPosition001, TestSize.Level1)
1084 {
1085     EXPECT_EQ(controller_->GetRealPlaybackPosition(), 0);
1086 }
1087 
1088 /**
1089 * @tc.name: GetRealPlaybackPosition002
1090 * @tc.desc: GetRealPlaybackPosition after recive callback
1091 * @tc.type: FUNC
1092 * @tc.require: AR000H31JK
1093 */
1094 HWTEST_F(AVSessionControllerTest, GetRealPlaybackPosition002, TestSize.Level1)
1095 {
1096     AVMetaData metaData;
1097     metaData.Reset();
1098     metaData.SetAssetId("GetRealPlaybackPosition");
1099     metaData.SetDuration(TestMicroSecond * TestMicroSecond + TestMicroSecond);
1100     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
1101     AVPlaybackState state;
1102     state.SetPosition({TestMicroSecond * TestMicroSecond, TestMicroSecond});
1103     EXPECT_EQ(avsession_->SetAVPlaybackState(state), AVSESSION_SUCCESS);
1104     AVPlaybackState resultState;
1105     EXPECT_EQ(controller_->GetAVPlaybackState(resultState), AVSESSION_SUCCESS);
1106     EXPECT_EQ(controller_->GetRealPlaybackPosition() > 0, true);
1107 }
1108 
1109 /**
1110 * @tc.name: GetRealPlaybackPosition003
1111 * @tc.desc: GetRealPlaybackPosition after recive callback
1112 * @tc.type: FUNC
1113 * @tc.require: AR000H31JK
1114 */
1115 HWTEST_F(AVSessionControllerTest, GetRealPlaybackPosition003, TestSize.Level1)
1116 {
1117     std::shared_ptr<AVControllerCallbackImpl> callback = std::make_shared<AVControllerCallbackImpl>();
1118     EXPECT_NE(callback, nullptr);
1119     EXPECT_EQ(controller_->RegisterCallback(callback), AVSESSION_SUCCESS);
1120 
1121     AVPlaybackState::PlaybackStateMaskType filter;
1122     filter.set();
1123     EXPECT_EQ(controller_->SetPlaybackFilter(filter), AVSESSION_SUCCESS);
1124     AVMetaData metaData;
1125     metaData.Reset();
1126     metaData.SetAssetId("GetRealPlaybackPosition");
1127     metaData.SetDuration(TestMicroSecond * TestMicroSecond + TestMicroSecond);
1128     EXPECT_EQ(avsession_->SetAVMetaData(metaData), AVSESSION_SUCCESS);
1129     AVPlaybackState state;
1130     state.SetPosition({TestMicroSecond * TestMicroSecond, TestMicroSecond});
1131     EXPECT_EQ(avsession_->SetAVPlaybackState(state), AVSESSION_SUCCESS);
1132     sleep(1);
1133     EXPECT_EQ(controller_->GetRealPlaybackPosition() > 0, true);
1134 }
1135 
1136 /**
1137 * @tc.name: IsDestroy001
1138 * @tc.desc: Return is controller isdestroy success
1139 * @tc.type: FUNC
1140 * @tc.require: I5YMXD
1141 */
1142 HWTEST_F(AVSessionControllerTest, IsDestroy001, TestSize.Level1)
1143 {
1144     EXPECT_EQ(controller_->IsDestroy(), false);
1145 }
1146 
1147 /**
1148 * @tc.name: Destroy001
1149 * @tc.desc: Return is controller destroy success
1150 * @tc.type: FUNC
1151 * @tc.require: AR000H31JH
1152 */
1153 HWTEST_F(AVSessionControllerTest, Destroy001, TestSize.Level1)
1154 {
1155     EXPECT_EQ(controller_->Destroy(), AVSESSION_SUCCESS);
1156     EXPECT_EQ(controller_->Destroy(), ERR_CONTROLLER_NOT_EXIST);
1157 }
1158 
1159 /**
1160 * @tc.name: GetAVQueueItems001
1161 * @tc.desc: Get queue items of current application
1162 * @tc.type: FUNC
1163 * @tc.require: I6RJST
1164 */
1165 HWTEST_F(AVSessionControllerTest, GetAVQueueItems001, TestSize.Level1)
1166 {
1167     SLOGD("GetAVQueueItems001 Begin");
1168     int32_t itemId = 1;
1169     std::string mediaId = "id";
1170     std::vector<AVQueueItem> items;
1171     std::vector<AVQueueItem> receivedItems;
1172     AVQueueItem queueItem;
1173     queueItem.SetItemId(itemId);
1174     AVMediaDescription description;
1175     description.SetMediaId(mediaId);
1176     queueItem.SetDescription(std::make_shared<AVMediaDescription>(description));
1177     items.push_back(queueItem);
1178     EXPECT_EQ(avsession_->SetAVQueueItems(items), AVSESSION_SUCCESS);
1179     EXPECT_EQ(controller_->GetAVQueueItems(receivedItems), AVSESSION_SUCCESS);
1180     EXPECT_EQ(receivedItems[0].GetItemId(), itemId);
1181     EXPECT_EQ(receivedItems[0].GetDescription()->GetMediaId(), mediaId);
1182     SLOGD("GetAVQueueItems001 End");
1183 }
1184 
1185 /**
1186 * @tc.name: GetAVQueueTitle001
1187 * @tc.desc: Set queue title of current application
1188 * @tc.type: FUNC
1189 * @tc.require: I6RJST
1190 */
1191 HWTEST_F(AVSessionControllerTest, GetAVQueueTitle001, TestSize.Level1)
1192 {
1193     SLOGD("GetAVQueueTitle001 Begin");
1194     std::string title = "AVQueueTitle";
1195     std::string getTitle;
1196     EXPECT_EQ(avsession_->SetAVQueueTitle(title), AVSESSION_SUCCESS);
1197     EXPECT_EQ(controller_->GetAVQueueTitle(getTitle), AVSESSION_SUCCESS);
1198     EXPECT_EQ(getTitle, title);
1199     SLOGD("GetAVQueueTitle001 End");
1200 }
1201 
1202 /**
1203 * @tc.name: SkipToQueueItem001
1204 * @tc.desc: Skip to queue items of current application
1205 * @tc.type: FUNC
1206 * @tc.require: I6RJST
1207 */
1208 HWTEST_F(AVSessionControllerTest, SkipToQueueItem001, TestSize.Level1)
1209 {
1210     SLOGD("SkipToQueueItem001 Begin");
1211     int32_t itemId = 1;
1212     std::string mediaId = "id";
1213     std::vector<AVQueueItem> items;
1214     AVQueueItem queueItem;
1215     queueItem.SetItemId(itemId);
1216     AVMediaDescription description;
1217     description.SetMediaId(mediaId);
1218     queueItem.SetDescription(std::make_shared<AVMediaDescription>(description));
1219     items.push_back(queueItem);
1220     EXPECT_EQ(avsession_->SetAVQueueItems(items), AVSESSION_SUCCESS);
1221     EXPECT_EQ(controller_->SkipToQueueItem(itemId), AVSESSION_SUCCESS);
1222     SLOGD("SkipToQueueItem001 End");
1223 }
1224 
1225 /**
1226 * @tc.name: HasSession001
1227 * @tc.desc: Skip to queue items of current application
1228 * @tc.type: FUNC
1229 * @tc.require: I6RJST
1230 */
1231 HWTEST_F(AVSessionControllerTest, HasSession001, TestSize.Level1)
1232 {
1233     SLOGD("HasSession001 Begin");
1234     std::shared_ptr<AVSessionController> controller2 = nullptr;
1235     auto ret = AVSessionManager::GetInstance().CreateController(avsession_->GetSessionId(), controller2);
1236     EXPECT_EQ(ret, ERR_CONTROLLER_IS_EXIST);
1237     SLOGD("HasSession001 with controller already exist test End");
1238 }
1239 
1240 /**
1241 * @tc.name: GetExtrasTest001
1242 * @tc.desc: Return cumtom media packets - extras
1243 * @tc.type: FUNC
1244 * @tc.require: I6TD43
1245 */
1246 HWTEST_F(AVSessionControllerTest, GetExtrasTest001, TestSize.Level1)
1247 {
1248     SLOGI("GetExtrasTest001 Begin");
1249     std::shared_ptr<OHOS::AAFwk::WantParams> wantParamsIn = nullptr;
1250     wantParamsIn = std::make_shared<OHOS::AAFwk::WantParams>();
1251     std::string keyStr = "1234567";
1252     bool valueBool = true;
1253     wantParamsIn->SetParam(keyStr, OHOS::AAFwk::Boolean::Box(valueBool));
1254     EXPECT_EQ(avsession_->SetExtras(*wantParamsIn), AVSESSION_SUCCESS);
1255 
1256     OHOS::AAFwk::WantParams resultExtras;
1257     EXPECT_EQ(controller_->GetExtras(resultExtras), AVSESSION_SUCCESS);
1258     EXPECT_EQ(resultExtras.HasParam("1234567"), 1);
1259     SLOGI("GetExtrasTest001 End");
1260 }
1261 
1262 /**
1263 * @tc.name: GetExtrasTest003
1264 * @tc.desc: Return custom media packets - session not exist
1265 * @tc.type: FUNC
1266 * @tc.require: I6TD43
1267 */
1268 HWTEST_F(AVSessionControllerTest, GetExtrasTest003, TestSize.Level1)
1269 {
1270     SLOGI("GetExtrasTest003 Begin");
1271     OHOS::AAFwk::WantParams resultExtras;
1272     EXPECT_EQ(avsession_->Destroy(), AVSESSION_SUCCESS);
1273     EXPECT_EQ(controller_->GetExtras(resultExtras), ERR_SESSION_NOT_EXIST);
1274     SLOGI("GetExtrasTest003 End");
1275 }
1276 } // namespace AVSession
1277 } // namespace OHOS
1278