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 #include <memory>
18 
19 #include "avsession_log.h"
20 #include "input_manager.h"
21 #include "key_event.h"
22 #include "avsession_manager.h"
23 #include "avsession_errors.h"
24 #include "avmeta_data.h"
25 #include "avplayback_state.h"
26 #include "avmedia_description.h"
27 #include "avqueue_item.h"
28 #include "avsession_log.h"
29 #include "nativetoken_kit.h"
30 #include "token_setproc.h"
31 #include "accesstoken_kit.h"
32 #include "system_ability_definition.h"
33 #include "audio_info.h"
34 #include "avsession_callback_client.h"
35 
36 #define private public
37 #define protected public
38 #include "avsession_service.h"
39 #undef protected
40 #undef private
41 
42 using namespace testing::ext;
43 using namespace OHOS::AVSession;
44 using namespace OHOS::Security::AccessToken;
45 using namespace OHOS::AudioStandard;
46 static AVMetaData g_metaData;
47 static AVPlaybackState g_playbackState;
48 static char g_testSessionTag[] = "test";
49 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
50 static char g_testAnotherAbilityName[] = "testAnother.ability";
51 static int32_t g_playOnCall = AVSESSION_ERROR;
52 static int32_t g_pauseOnCall = AVSESSION_ERROR;
53 static int32_t g_nextOnCall = AVSESSION_ERROR;
54 static int32_t g_previousOnCall = AVSESSION_ERROR;
55 static AVSessionService *avservice_;
56 
57 class AVSessionServiceTest : public testing::Test {
58 public:
59     static void SetUpTestCase();
60     static void TearDownTestCase();
61     void SetUp() override;
62     void TearDown() override;
63 
64     std::shared_ptr<AVSession> avsession_ = nullptr;
65 };
66 
SetUpTestCase()67 void AVSessionServiceTest::SetUpTestCase()
68 {
69     SLOGI("set up AVSessionServiceTest");
70     system("killall -9 com.example.hiMusicDemo");
71     sleep(1);
72     avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
73     avservice_->InitKeyEvent();
74 }
75 
TearDownTestCase()76 void AVSessionServiceTest::TearDownTestCase()
77 {
78 }
79 
SetUp()80 void AVSessionServiceTest::SetUp()
81 {
82     SLOGI("set up test function in AVSessionServiceTest");
83 }
84 
TearDown()85 void AVSessionServiceTest::TearDown()
86 {
87     SLOGI("tear down test function in AVSessionServiceTest");
88     [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
89     if (avsession_ != nullptr) {
90         ret = avsession_->Destroy();
91         avsession_ = nullptr;
92     }
93 }
94 
95 class AVSessionCallbackImpl : public AVSessionCallback {
96 public:
97     void OnPlay() override;
98     void OnPause() override;
OnStop()99     void OnStop() override {};
100     void OnPlayNext() override;
101     void OnPlayPrevious() override;
OnFastForward(int64_t time)102     void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)103     void OnRewind(int64_t time) override {};
OnSeek(int64_t time)104     void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)105     void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)106     void OnSetLoopMode(int32_t loopMode) override {};
OnToggleFavorite(const std::string & mediaId)107     void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)108     void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)109     void OnOutputDeviceChange(const int32_t connectionState,
110         const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)111     void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)112     void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()113     void OnAVCallAnswer() override {};
OnAVCallHangUp()114     void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()115     void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)116     void OnPlayFromAssetId(int64_t assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)117     void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
118 
119     ~AVSessionCallbackImpl() override;
120 };
121 
OnPlay()122 void AVSessionCallbackImpl::OnPlay()
123 {
124     g_playOnCall = AVSESSION_SUCCESS;
125     SLOGI("OnPlay %{public}d", g_playOnCall);
126 }
127 
OnPause()128 void AVSessionCallbackImpl::OnPause()
129 {
130     g_pauseOnCall = AVSESSION_SUCCESS;
131     SLOGI("OnPause %{public}d", g_pauseOnCall);
132 }
133 
OnPlayNext()134 void AVSessionCallbackImpl::OnPlayNext()
135 {
136     g_nextOnCall = AVSESSION_SUCCESS;
137     SLOGI("OnPlayNext %{public}d", g_nextOnCall);
138 }
139 
OnPlayPrevious()140 void AVSessionCallbackImpl::OnPlayPrevious()
141 {
142     g_previousOnCall = AVSESSION_SUCCESS;
143     SLOGI("OnPlayPrevious %{public}d", g_previousOnCall);
144 }
145 
~AVSessionCallbackImpl()146 AVSessionCallbackImpl::~AVSessionCallbackImpl()
147 {
148 }
149 
150 /**
151 * @tc.name: SendSystemAVKeyEvent001
152 * @tc.desc: verifying send system keyEvent
153 * @tc.type: FUNC
154 * @tc.require: #I5Y4MZ
155 */
156 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent001, TestSize.Level1)
157 {
158     SLOGI("SendSystemAVKeyEvent001 begin!");
159     OHOS::AppExecFwk::ElementName elementName;
160     elementName.SetBundleName(g_testAnotherBundleName);
161     elementName.SetAbilityName(g_testAnotherAbilityName);
162     OHOS::sptr<AVSessionItem> avsessionHere_ =
163         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
164     avsessionHere_->Activate();
165     avservice_->UpdateTopSession(avsessionHere_);
166 
167     g_metaData.Reset();
168     g_metaData.SetAssetId("123");
169     g_metaData.SetTitle("Black Humor");
170     g_metaData.SetArtist("zhoujielun");
171     g_metaData.SetAuthor("zhoujielun");
172     g_metaData.SetAlbum("Jay");
173     g_metaData.SetWriter("zhoujielun");
174     g_metaData.SetComposer("zhoujielun");
175     g_metaData.SetDuration(40000);
176     g_metaData.SetMediaImageUri("xxxxx");
177     g_metaData.SetSubTitle("fac");
178     g_metaData.SetDescription("for friends");
179     g_metaData.SetLyric("xxxxx");
180     avsessionHere_->SetAVMetaData(g_metaData);
181 
182     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
183     g_playbackState.SetSpeed(1.5);
184     g_playbackState.SetPosition({80000, 0});
185     g_playbackState.SetBufferedTime(60000);
186     g_playbackState.SetLoopMode(2);
187     g_playbackState.SetFavorite(true);
188     avsessionHere_->SetAVPlaybackState(g_playbackState);
189 
190     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
191     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
192     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
193 
194     auto keyEvent = OHOS::MMI::KeyEvent::Create();
195     ASSERT_NE(keyEvent, nullptr);
196     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
197     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
198     OHOS::MMI::KeyEvent::KeyItem item;
199     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
200     item.SetDownTime(0);
201     item.SetPressed(true);
202     keyEvent->AddPressedKeyItems(item);
203     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
204     sleep(1);
205     EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
206     g_pauseOnCall = false;
207     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
208     SLOGI("SendSystemAVKeyEvent001 end!");
209 }
210 
211 /**
212 * @tc.name: SendSystemAVKeyEvent002
213 * @tc.desc: verifying send system keyEvent
214 * @tc.type: FUNC
215 * @tc.require: #I5Y4MZ
216 */
217 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent002, TestSize.Level1)
218 {
219     SLOGI("SendSystemAVKeyEvent002 begin!");
220     OHOS::AppExecFwk::ElementName elementName;
221     elementName.SetBundleName(g_testAnotherBundleName);
222     elementName.SetAbilityName(g_testAnotherAbilityName);
223     OHOS::sptr<AVSessionItem> avsessionHere_ =
224         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
225     avsessionHere_->Activate();
226     avservice_->UpdateTopSession(avsessionHere_);
227 
228     g_metaData.Reset();
229     g_metaData.SetAssetId("123");
230     g_metaData.SetTitle("Black Humor");
231     g_metaData.SetArtist("zhoujielun");
232     g_metaData.SetAuthor("zhoujielun");
233     g_metaData.SetAlbum("Jay");
234     g_metaData.SetWriter("zhoujielun");
235     g_metaData.SetComposer("zhoujielun");
236     g_metaData.SetDuration(40000);
237     g_metaData.SetMediaImageUri("xxxxx");
238     g_metaData.SetSubTitle("fac");
239     g_metaData.SetDescription("for friends");
240     g_metaData.SetLyric("xxxxx");
241     avsessionHere_->SetAVMetaData(g_metaData);
242 
243     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
244     g_playbackState.SetSpeed(1.5);
245     g_playbackState.SetPosition({80000, 0});
246     g_playbackState.SetBufferedTime(60000);
247     g_playbackState.SetLoopMode(2);
248     g_playbackState.SetFavorite(true);
249     avsessionHere_->SetAVPlaybackState(g_playbackState);
250 
251     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
252     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
253     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
254 
255     auto keyEvent = OHOS::MMI::KeyEvent::Create();
256     ASSERT_NE(keyEvent, nullptr);
257     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
258     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
259     OHOS::MMI::KeyEvent::KeyItem item;
260     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
261     item.SetDownTime(0);
262     item.SetPressed(true);
263     keyEvent->AddPressedKeyItems(item);
264     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
265     sleep(1);
266     EXPECT_EQ(g_playOnCall, AVSESSION_SUCCESS);
267     g_playOnCall = false;
268     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
269     SLOGI("SendSystemAVKeyEvent002 end!");
270 }
271 
272 /**
273 * @tc.name: SendSystemAVKeyEvent003
274 * @tc.desc: verifying send system keyEvent
275 * @tc.type: FUNC
276 * @tc.require: #I5Y4MZ
277 */
278 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent003, TestSize.Level1)
279 {
280     SLOGI("SendSystemAVKeyEvent003 begin!");
281     OHOS::AppExecFwk::ElementName elementName;
282     elementName.SetBundleName(g_testAnotherBundleName);
283     elementName.SetAbilityName(g_testAnotherAbilityName);
284     OHOS::sptr<AVSessionItem> avsessionHere_ =
285         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
286     avsessionHere_->Activate();
287     avservice_->UpdateTopSession(avsessionHere_);
288 
289     g_metaData.Reset();
290     g_metaData.SetAssetId("123");
291     g_metaData.SetTitle("Black Humor");
292     g_metaData.SetArtist("zhoujielun");
293     g_metaData.SetAuthor("zhoujielun");
294     g_metaData.SetAlbum("Jay");
295     g_metaData.SetWriter("zhoujielun");
296     g_metaData.SetComposer("zhoujielun");
297     g_metaData.SetDuration(40000);
298     g_metaData.SetMediaImageUri("xxxxx");
299     g_metaData.SetSubTitle("fac");
300     g_metaData.SetDescription("for friends");
301     g_metaData.SetLyric("xxxxx");
302     avsessionHere_->SetAVMetaData(g_metaData);
303 
304     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
305     g_playbackState.SetSpeed(1.5);
306     g_playbackState.SetPosition({80000, 0});
307     g_playbackState.SetBufferedTime(60000);
308     g_playbackState.SetLoopMode(2);
309     g_playbackState.SetFavorite(true);
310     avsessionHere_->SetAVPlaybackState(g_playbackState);
311 
312     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
313     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
314     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
315 
316     auto keyEvent = OHOS::MMI::KeyEvent::Create();
317     ASSERT_NE(keyEvent, nullptr);
318     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
319     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
320     OHOS::MMI::KeyEvent::KeyItem item;
321     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
322     item.SetDownTime(0);
323     item.SetPressed(true);
324     keyEvent->AddPressedKeyItems(item);
325     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
326     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
327     sleep(1);
328     EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
329     g_nextOnCall = false;
330     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
331     SLOGI("SendSystemAVKeyEvent003 end!");
332 }
333 
334 /**
335 * @tc.name: SendSystemAVKeyEvent004
336 * @tc.desc: verifying send system keyEvent
337 * @tc.type: FUNC
338 * @tc.require: #I5Y4MZ
339 */
340 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent004, TestSize.Level1)
341 {
342     SLOGI("SendSystemAVKeyEvent004 begin!");
343     OHOS::AppExecFwk::ElementName elementName;
344     elementName.SetBundleName(g_testAnotherBundleName);
345     elementName.SetAbilityName(g_testAnotherAbilityName);
346     OHOS::sptr<AVSessionItem> avsessionHere_ =
347         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
348     avsessionHere_->Activate();
349     avservice_->UpdateTopSession(avsessionHere_);
350     g_metaData.SetAssetId("123");
351     g_metaData.SetTitle("Black Humor");
352     g_metaData.SetArtist("zhoujielun");
353     g_metaData.SetAuthor("zhoujielun");
354     g_metaData.SetAlbum("Jay");
355     g_metaData.SetWriter("zhoujielun");
356     g_metaData.SetComposer("zhoujielun");
357     g_metaData.SetDuration(40000);
358     g_metaData.SetSubTitle("fac");
359     g_metaData.SetDescription("for friends");
360     g_metaData.SetLyric("xxxxx");
361     avsessionHere_->SetAVMetaData(g_metaData);
362     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
363     g_playbackState.SetSpeed(1.5);
364     g_playbackState.SetPosition({80000, 0});
365     g_playbackState.SetBufferedTime(60000);
366     g_playbackState.SetLoopMode(2);
367     g_playbackState.SetFavorite(true);
368     avsessionHere_->SetAVPlaybackState(g_playbackState);
369     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
370     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
371     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
372     auto keyEvent = OHOS::MMI::KeyEvent::Create();
373     ASSERT_NE(keyEvent, nullptr);
374     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
375     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
376     OHOS::MMI::KeyEvent::KeyItem item;
377     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
378     item.SetDownTime(0);
379     item.SetPressed(true);
380     keyEvent->AddPressedKeyItems(item);
381     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
382     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
383     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
384     sleep(1);
385     EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
386     g_previousOnCall = false;
387     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
388     SLOGI("SendSystemAVKeyEvent004 end!");
389 }
390 
391 /**
392 * @tc.name: SendSystemAVKeyEvent005
393 * @tc.desc: verifying send system keyEvent
394 * @tc.type: FUNC
395 * @tc.require: #I5Y4MZ
396 */
397 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent005, TestSize.Level1)
398 {
399     SLOGI("SendSystemAVKeyEvent005 begin!");
400     OHOS::AppExecFwk::ElementName elementName;
401     elementName.SetBundleName(g_testAnotherBundleName);
402     elementName.SetAbilityName(g_testAnotherAbilityName);
403     OHOS::sptr<AVSessionItem> avsessionHere_ =
404         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
405     avsessionHere_->Activate();
406     avservice_->UpdateTopSession(avsessionHere_);
407     g_metaData.SetAssetId("123");
408     g_metaData.SetTitle("Black Humor");
409     g_metaData.SetArtist("zhoujielun");
410     g_metaData.SetAuthor("zhoujielun");
411     g_metaData.SetAlbum("Jay");
412     g_metaData.SetWriter("zhoujielun");
413     g_metaData.SetComposer("zhoujielun");
414     g_metaData.SetDuration(40000);
415     g_metaData.SetMediaImageUri("xxxxx");
416     g_metaData.SetDescription("for friends");
417     avsessionHere_->SetAVMetaData(g_metaData);
418     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
419     g_playbackState.SetSpeed(1.5);
420     g_playbackState.SetPosition({80000, 0});
421     g_playbackState.SetBufferedTime(60000);
422     g_playbackState.SetLoopMode(2);
423     g_playbackState.SetFavorite(true);
424     avsessionHere_->SetAVPlaybackState(g_playbackState);
425     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
426     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
427     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
428     auto keyEvent = OHOS::MMI::KeyEvent::Create();
429     ASSERT_NE(keyEvent, nullptr);
430     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
431     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
432     OHOS::MMI::KeyEvent::KeyItem item;
433     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
434     item.SetDownTime(0);
435     item.SetPressed(true);
436     keyEvent->AddPressedKeyItems(item);
437     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
438     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
439     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
440     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
441     sleep(1);
442     EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
443     g_previousOnCall = false;
444     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
445     SLOGI("SendSystemAVKeyEvent005 end!");
446 }
447 
448 /**
449 * @tc.name: SendSystemAVKeyEvent006
450 * @tc.desc: verifying send system keyEvent
451 * @tc.type: FUNC
452 * @tc.require: #I5Y4MZ
453 */
454 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent006, TestSize.Level1)
455 {
456     SLOGI("SendSystemAVKeyEvent006 begin!");
457     OHOS::AppExecFwk::ElementName elementName;
458     elementName.SetBundleName(g_testAnotherBundleName);
459     elementName.SetAbilityName(g_testAnotherAbilityName);
460     OHOS::sptr<AVSessionItem> avsessionHere_ =
461         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
462     avsessionHere_->Activate();
463     avservice_->UpdateTopSession(avsessionHere_);
464     g_metaData.SetAssetId("123");
465     g_metaData.SetTitle("Black Humor");
466     g_metaData.SetArtist("zhoujielun");
467     g_metaData.SetAuthor("zhoujielun");
468     g_metaData.SetAlbum("Jay");
469     g_metaData.SetWriter("zhoujielun");
470     g_metaData.SetComposer("zhoujielun");
471     g_metaData.SetDuration(40000);
472     avsessionHere_->SetAVMetaData(g_metaData);
473     g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
474     g_playbackState.SetSpeed(1.5);
475     g_playbackState.SetPosition({80000, 0});
476     g_playbackState.SetBufferedTime(60000);
477     g_playbackState.SetLoopMode(2);
478     g_playbackState.SetFavorite(true);
479     avsessionHere_->SetAVPlaybackState(g_playbackState);
480     std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
481     OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
482     EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
483     auto keyEvent = OHOS::MMI::KeyEvent::Create();
484     ASSERT_NE(keyEvent, nullptr);
485     keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
486     keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
487     OHOS::MMI::KeyEvent::KeyItem item;
488     item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
489     item.SetDownTime(0);
490     item.SetPressed(true);
491     keyEvent->AddPressedKeyItems(item);
492     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
493     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
494     sleep(1);
495     EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
496     g_nextOnCall = false;
497     OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
498     sleep(1);
499     EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
500     g_pauseOnCall = false;
501     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
502     SLOGI("SendSystemAVKeyEvent006 end!");
503 }
504 
505 static HWTEST_F(AVSessionServiceTest, NotifyDeviceAvailable001, TestSize.Level1)
506 {
507     SLOGI("NotifyDeviceAvailable001 begin!");
508 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
509     SLOGI("NotifyDeviceAvailable001 in!");
510     OutputDeviceInfo outputDeviceInfo;
511     OHOS::AVSession::DeviceInfo deviceInfo;
512     deviceInfo.castCategory_ = 1;
513     deviceInfo.deviceId_ = "deviceId";
514     outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
515     avservice_->NotifyDeviceAvailable(outputDeviceInfo);
516     EXPECT_EQ(0, AVSESSION_SUCCESS);
517 #endif
518     EXPECT_EQ(0, AVSESSION_SUCCESS);
519     SLOGI("NotifyDeviceAvailable001 end!");
520 }
521 
522 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast001, TestSize.Level1)
523 {
524     SLOGI("NotifyMirrorToStreamCast001 begin!");
525 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
526     SLOGI("NotifyMirrorToStreamCast001 in!");
527     avservice_->NotifyMirrorToStreamCast();
528 #endif
529     EXPECT_EQ(0, AVSESSION_SUCCESS);
530     SLOGI("NotifyMirrorToStreamCast001 end!");
531 }
532 
533 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast002, TestSize.Level1)
534 {
535     SLOGI("NotifyMirrorToStreamCast002 begin!");
536 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
537     SLOGI("NotifyMirrorToStreamCast002 in!");
538     OHOS::AppExecFwk::ElementName elementName;
539     elementName.SetBundleName(g_testAnotherBundleName);
540     elementName.SetAbilityName(g_testAnotherAbilityName);
541     OHOS::sptr<AVSessionItem> avsessionHere_ =
542         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
543     EXPECT_EQ(avsessionHere_ != nullptr, true);
544     avservice_->UpdateTopSession(avsessionHere_);
545     avservice_->NotifyMirrorToStreamCast();
546     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
547 #endif
548     EXPECT_EQ(0, AVSESSION_SUCCESS);
549     SLOGI("NotifyMirrorToStreamCast002 end!");
550 }
551 
552 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast003, TestSize.Level1)
553 {
554     SLOGI("NotifyMirrorToStreamCast003 begin!");
555 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
556     SLOGI("NotifyMirrorToStreamCast002 in!");
557     OHOS::AppExecFwk::ElementName elementName;
558     elementName.SetBundleName(g_testAnotherBundleName);
559     elementName.SetAbilityName(g_testAnotherAbilityName);
560     OHOS::sptr<AVSessionItem> avsessionHere_ =
561         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
562     EXPECT_EQ(avsessionHere_ != nullptr, true);
563     avservice_->UpdateTopSession(avsessionHere_);
564     avservice_->NotifyMirrorToStreamCast();
565     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
566 #endif
567     EXPECT_EQ(0, AVSESSION_SUCCESS);
568     SLOGI("NotifyMirrorToStreamCast003 end!");
569 }
570 
571 static HWTEST_F(AVSessionServiceTest, RefreshFocusSessionSort001, TestSize.Level1)
572 {
573     SLOGI("RefreshFocusSessionSort001 begin!");
574     OHOS::AppExecFwk::ElementName elementName;
575     elementName.SetBundleName(g_testAnotherBundleName);
576     elementName.SetAbilityName(g_testAnotherAbilityName);
577     OHOS::sptr<AVSessionItem> avsessionHere_ =
578         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
579     EXPECT_EQ(avsessionHere_ != nullptr, true);
580     avservice_->RefreshFocusSessionSort(avsessionHere_);
581     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
582     EXPECT_EQ(0, AVSESSION_SUCCESS);
583     SLOGI("RefreshFocusSessionSort001 end!");
584 }
585 
586 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid001, TestSize.Level1)
587 {
588     SLOGI("SelectSessionByUid001 begin!");
589     OHOS::AppExecFwk::ElementName elementName;
590     elementName.SetBundleName(g_testAnotherBundleName);
591     elementName.SetAbilityName(g_testAnotherAbilityName);
592     OHOS::sptr<AVSessionItem> avsessionHere_ =
593         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
594     EXPECT_EQ(avsessionHere_ != nullptr, true);
595     AudioRendererChangeInfo info = {};
596     info.clientUID = 0;
597     avservice_->SelectSessionByUid(info);
598     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
599     EXPECT_EQ(0, AVSESSION_SUCCESS);
600     SLOGI("SelectSessionByUid001 end!");
601 }
602 
603 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid002, TestSize.Level1)
604 {
605     SLOGI("SelectSessionByUid002 begin!");
606     OHOS::AppExecFwk::ElementName elementName;
607     elementName.SetBundleName(g_testAnotherBundleName);
608     elementName.SetAbilityName(g_testAnotherAbilityName);
609     OHOS::sptr<AVSessionItem> avsessionHere_ =
610         avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
611     EXPECT_EQ(avsessionHere_ != nullptr, true);
612     AudioRendererChangeInfo info = {};
613     info.clientUID = avsessionHere_->GetUid();
614     avservice_->SelectSessionByUid(info);
615     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
616     EXPECT_EQ(0, AVSESSION_SUCCESS);
617     SLOGI("SelectSessionByUid002 end!");
618 }
619 
620 static HWTEST_F(AVSessionServiceTest, InitBMS001, TestSize.Level1)
621 {
622     SLOGI("InitBMS001 begin!");
623     avservice_->InitBMS();
624     EXPECT_EQ(0, AVSESSION_SUCCESS);
625     SLOGI("InitBMS001 end!");
626 }
627 
628 static HWTEST_F(AVSessionServiceTest, ReleaseCastSession001, TestSize.Level1)
629 {
630     SLOGI("ReleaseCastSession001 begin!");
631     OHOS::AppExecFwk::ElementName elementName;
632     elementName.SetBundleName(g_testAnotherBundleName);
633     elementName.SetAbilityName(g_testAnotherAbilityName);
634     OHOS::sptr<AVSessionItem> avsessionHere_ =
635         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
636     EXPECT_EQ(avsessionHere_ != nullptr, true);
637 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
638     SLOGI("ReleaseCastSession001 in!");
639     avservice_->ReleaseCastSession();
640 #endif
641     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
642     EXPECT_EQ(0, AVSESSION_SUCCESS);
643     SLOGI("ReleaseCastSession001 end!");
644 }
645 
646 static HWTEST_F(AVSessionServiceTest, CreateSessionByCast001, TestSize.Level1)
647 {
648     SLOGI("CreateSessionByCast001 begin!");
649 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
650     SLOGI("CreateSessionByCast001 in!");
651     avservice_->CreateSessionByCast(0);
652     avservice_->ClearSessionForClientDiedNoLock(getpid());
653 #endif
654     EXPECT_EQ(0, AVSESSION_SUCCESS);
655     SLOGI("CreateSessionByCast001 end!");
656 }
657 
658 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast001, TestSize.Level1)
659 {
660     SLOGI("MirrorToStreamCast001 begin!");
661 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
662     SLOGI("MirrorToStreamCast001 in!");
663     OHOS::AppExecFwk::ElementName elementName;
664     elementName.SetBundleName(g_testAnotherBundleName);
665     elementName.SetAbilityName(g_testAnotherAbilityName);
666     OHOS::sptr<AVSessionItem> avsessionHere_ =
667         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
668     EXPECT_EQ(avsessionHere_ != nullptr, true);
669     avservice_->is2in1_ = true;
670     avservice_->MirrorToStreamCast(avsessionHere_);
671     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
672 #endif
673     EXPECT_EQ(0, AVSESSION_SUCCESS);
674     SLOGI("MirrorToStreamCast001 end!");
675 }
676 
677 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast002, TestSize.Level1)
678 {
679     SLOGI("MirrorToStreamCast002 begin!");
680 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
681     SLOGI("MirrorToStreamCast002 in!");
682     OHOS::AppExecFwk::ElementName elementName;
683     elementName.SetBundleName(g_testAnotherBundleName);
684     elementName.SetAbilityName(g_testAnotherAbilityName);
685     OHOS::sptr<AVSessionItem> avsessionHere_ =
686         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
687     EXPECT_EQ(avsessionHere_ != nullptr, true);
688     avservice_->is2in1_ = false;
689     avservice_->MirrorToStreamCast(avsessionHere_);
690     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
691 #endif
692     EXPECT_EQ(0, AVSESSION_SUCCESS);
693     SLOGI("MirrorToStreamCast002 end!");
694 }
695 
696 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast003, TestSize.Level1)
697 {
698     SLOGI("MirrorToStreamCast003 begin!");
699 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
700     SLOGI("MirrorToStreamCast003 in!");
701     OHOS::AppExecFwk::ElementName elementName;
702     elementName.SetBundleName(g_testAnotherBundleName);
703     elementName.SetAbilityName(g_testAnotherAbilityName);
704     OHOS::sptr<AVSessionItem> avsessionHere_ =
705         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
706     EXPECT_EQ(avsessionHere_ != nullptr, true);
707     avservice_->is2in1_ = true;
708     avservice_->MirrorToStreamCast(avsessionHere_);
709     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
710 #endif
711     EXPECT_EQ(0, AVSESSION_SUCCESS);
712     SLOGI("MirrorToStreamCast003 end!");
713 }
714 
715 static HWTEST_F(AVSessionServiceTest, RefreshSortFileOnCreateSession001, TestSize.Level1)
716 {
717     SLOGI("RefreshSortFileOnCreateSession001 begin!");
718     OHOS::AppExecFwk::ElementName elementName;
719     elementName.SetBundleName(g_testAnotherBundleName);
720     elementName.SetAbilityName(g_testAnotherAbilityName);
721     OHOS::sptr<AVSessionItem> avsessionHere_ =
722         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
723     EXPECT_EQ(avsessionHere_ != nullptr, true);
724     SLOGE("AVSession not to do refreshSortFileOnCreateSession for crash");
725     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
726     EXPECT_EQ(0, AVSESSION_SUCCESS);
727     SLOGI("RefreshSortFileOnCreateSession001 end!");
728 }
729 
730 static HWTEST_F(AVSessionServiceTest, GetHistoricalAVQueueInfos001, TestSize.Level1)
731 {
732     SLOGI("GetHistoricalAVQueueInfos001 begin!");
733     std::vector<AVQueueInfo> avQueueInfos_;
734     avservice_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
735     EXPECT_EQ(0, AVSESSION_SUCCESS);
736     SLOGI("GetHistoricalAVQueueInfos001 end!");
737 }
738 
739 static HWTEST_F(AVSessionServiceTest, SaveAvQueueInfo001, TestSize.Level1)
740 {
741     SLOGI("SaveAvQueueInfo001 begin!");
742     OHOS::AppExecFwk::ElementName elementName;
743     elementName.SetBundleName(g_testAnotherBundleName);
744     elementName.SetAbilityName(g_testAnotherAbilityName);
745     OHOS::sptr<AVSessionItem> avsessionHere_ =
746         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
747     EXPECT_EQ(avsessionHere_ != nullptr, true);
748     AVMetaData meta = avsessionHere_->GetMetaData();
749     std::string oldContent;
750     if (!avservice_->LoadStringFromFileEx(avservice_->GetAVQueueDir(), oldContent)) {
751         SLOGE("SaveAvQueueInfo001 read avqueueinfo fail, Return!");
752         return;
753     }
754     avservice_->SaveAvQueueInfo(oldContent, g_testAnotherBundleName, meta,
755         avservice_->GetUsersManager().GetCurrentUserId());
756     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
757     EXPECT_EQ(0, AVSESSION_SUCCESS);
758     SLOGI("SaveAvQueueInfo001 end!");
759 }
760 
761 static HWTEST_F(AVSessionServiceTest, AddAvQueueInfoToFile001, TestSize.Level1)
762 {
763     SLOGI("AddAvQueueInfoToFile001 begin!");
764     OHOS::AppExecFwk::ElementName elementName;
765     elementName.SetBundleName(g_testAnotherBundleName);
766     elementName.SetAbilityName(g_testAnotherAbilityName);
767     OHOS::sptr<AVSessionItem> avsessionHere_ =
768         avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
769     EXPECT_EQ(avsessionHere_ != nullptr, true);
770     avservice_->AddAvQueueInfoToFile(*avsessionHere_);
771     avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
772     EXPECT_EQ(0, AVSESSION_SUCCESS);
773     SLOGI("AddAvQueueInfoToFile001 end!");
774 }
775 
776 static HWTEST_F(AVSessionServiceTest, StartAVPlayback001, TestSize.Level1)
777 {
778     SLOGI("StartAVPlayback001 begin!");
779     avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME");
780     EXPECT_EQ(0, AVSESSION_SUCCESS);
781     SLOGI("StartAVPlayback001 end!");
782 }
783 
784 static HWTEST_F(AVSessionServiceTest, GetSubNode001, TestSize.Level1)
785 {
786     SLOGI("GetSubNode001 begin!");
787     nlohmann::json value;
788     value["bundleName"] = g_testAnotherBundleName;
789     avservice_->GetSubNode(value, "FAKE_NAME");
790     EXPECT_EQ(0, AVSESSION_SUCCESS);
791     SLOGI("GetSubNode001 end!");
792 }
793 
794 static HWTEST_F(AVSessionServiceTest, Close001, TestSize.Level1)
795 {
796     SLOGI("Close001 begin!");
797     avservice_->Close();
798     EXPECT_EQ(0, AVSESSION_SUCCESS);
799     SLOGI("Close001 end!");
800 }
801 
802 static HWTEST_F(AVSessionServiceTest, DeleteHistoricalRecord001, TestSize.Level1)
803 {
804     SLOGI("DeleteHistoricalRecord001 begin!");
805     avservice_->DeleteHistoricalRecord(g_testAnotherBundleName);
806     EXPECT_EQ(0, AVSESSION_SUCCESS);
807     SLOGI("DeleteHistoricalRecord001 end!");
808 }
809 
810 static HWTEST_F(AVSessionServiceTest, Dump001, TestSize.Level1)
811 {
812     SLOGI("Dump001 begin!");
813     std::vector<std::u16string> argsList;
814     avservice_->Dump(1, argsList);
815     EXPECT_EQ(0, AVSESSION_SUCCESS);
816     SLOGI("Dump001 end!");
817 }
818 
819 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand001, TestSize.Level1)
820 {
821     SLOGI("ProcessCastAudioCommand001 begin!");
822     std::string sourceSessionInfo = "SOURCE";
823     std::string sinkSessionInfo = " SINK";
824     avservice_->ProcessCastAudioCommand(
825         OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
826         sourceSessionInfo, sinkSessionInfo);
827     EXPECT_EQ(0, AVSESSION_SUCCESS);
828     SLOGI("ProcessCastAudioCommand001 end!");
829 }
830 
831 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand002, TestSize.Level1)
832 {
833     SLOGI("ProcessCastAudioCommand002 begin!");
834     std::string sourceSessionInfo = "SOURCE";
835     std::string sinkSessionInfo = " SINK";
836     avservice_->ProcessCastAudioCommand(
837         OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
838         sourceSessionInfo, sinkSessionInfo);
839     EXPECT_EQ(0, AVSESSION_SUCCESS);
840     SLOGI("ProcessCastAudioCommand002 end!");
841 }
842 
843 static HWTEST_F(AVSessionServiceTest, HandleDeviceChange001, TestSize.Level1)
844 {
845     SLOGI("HandleDeviceChange001 begin!");
846     DeviceChangeAction deviceChange;
847     deviceChange.type = static_cast<DeviceChangeType>(0);
848     deviceChange.flag = static_cast<DeviceFlag>(0);
849     avservice_->HandleDeviceChange(deviceChange);
850     EXPECT_EQ(0, AVSESSION_SUCCESS);
851     SLOGI("HandleDeviceChange001 end!");
852 }
853 
854 static HWTEST_F(AVSessionServiceTest, HandleDeviceChange002, TestSize.Level1)
855 {
856     SLOGI("HandleDeviceChange002 begin!");
857     DeviceChangeAction deviceChange;
858     std::vector<OHOS::sptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
859     OHOS::sptr<AudioDeviceDescriptor> descriptor = new(std::nothrow) AudioDeviceDescriptor();
860     descriptor->deviceType_ = OHOS::AudioStandard::DEVICE_TYPE_WIRED_HEADSET;
861     deviceChange.type = static_cast<DeviceChangeType>(0);
862     deviceChange.flag = static_cast<DeviceFlag>(0);
863 
864     audioDeviceDescriptors.push_back(descriptor);
865     deviceChange.deviceDescriptors = audioDeviceDescriptors;
866     avservice_->HandleDeviceChange(deviceChange);
867     EXPECT_EQ(0, AVSESSION_SUCCESS);
868     SLOGI("HandleDeviceChange002 end!");
869 }