1 /*
2 * Copyright (c) 2022-2025 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 #include <fstream>
19 #include <cstdio>
20
21 #include "avsession_log.h"
22 #include "input_manager.h"
23 #include "key_event.h"
24 #include "avsession_manager.h"
25 #include "avsession_errors.h"
26 #include "avmeta_data.h"
27 #include "avplayback_state.h"
28 #include "avmedia_description.h"
29 #include "avqueue_item.h"
30 #include "avsession_log.h"
31 #include "nativetoken_kit.h"
32 #include "token_setproc.h"
33 #include "accesstoken_kit.h"
34 #include "system_ability_definition.h"
35 #include "system_ability_ondemand_reason.h"
36 #include "audio_info.h"
37 #include "avsession_callback_client.h"
38 #include "avsession_pixel_map.h"
39 #include "avsession_pixel_map_adapter.h"
40 #include "avsession_info.h"
41 #include "params_config_operator.h"
42 #include "avcontrol_command.h"
43
44 #define private public
45 #define protected public
46 #include "avsession_service.h"
47 #undef protected
48 #undef private
49
50 using namespace testing::ext;
51 using namespace OHOS::AVSession;
52 using namespace OHOS::Security::AccessToken;
53 using namespace OHOS::AudioStandard;
54 static AVMetaData g_metaData;
55 static AVPlaybackState g_playbackState;
56 static char g_testSessionTag[] = "test";
57 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
58 static char g_testAnotherAbilityName[] = "testAnother.ability";
59 static int32_t g_playOnCall = AVSESSION_ERROR;
60 static int32_t g_pauseOnCall = AVSESSION_ERROR;
61 static int32_t g_nextOnCall = AVSESSION_ERROR;
62 static int32_t g_previousOnCall = AVSESSION_ERROR;
63 static AVSessionService *avservice_;
64 static AVControlCommand *avcommand_;
65
66 class AVSessionServiceTest : public testing::Test {
67 public:
68 static void SetUpTestCase();
69 static void TearDownTestCase();
70 void SetUp() override;
71 void TearDown() override;
72
73 std::shared_ptr<AVSession> avsession_ = nullptr;
74 };
75
SetUpTestCase()76 void AVSessionServiceTest::SetUpTestCase()
77 {
78 SLOGI("set up AVSessionServiceTest");
79 system("killall -9 com.example.hiMusicDemo");
80 sleep(1);
81 avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
82 avservice_->InitKeyEvent();
83 }
84
TearDownTestCase()85 void AVSessionServiceTest::TearDownTestCase()
86 {
87 }
88
SetUp()89 void AVSessionServiceTest::SetUp()
90 {
91 SLOGI("set up test function in AVSessionServiceTest");
92 }
93
TearDown()94 void AVSessionServiceTest::TearDown()
95 {
96 SLOGI("tear down test function in AVSessionServiceTest");
97 [[maybe_unused]] int32_t ret = AVSESSION_ERROR;
98 if (avsession_ != nullptr) {
99 ret = avsession_->Destroy();
100 avsession_ = nullptr;
101 }
102 }
103
104 class AVSessionCallbackImpl : public AVSessionCallback {
105 public:
106 void OnPlay() override;
107 void OnPause() override;
OnStop()108 void OnStop() override {};
109 void OnPlayNext() override;
110 void OnPlayPrevious() override;
OnFastForward(int64_t time)111 void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)112 void OnRewind(int64_t time) override {};
OnSeek(int64_t time)113 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)114 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)115 void OnSetLoopMode(int32_t loopMode) override {};
OnSetTargetLoopMode(int32_t targetLoopMode)116 void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
OnToggleFavorite(const std::string & mediaId)117 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)118 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)119 void OnOutputDeviceChange(const int32_t connectionState,
120 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)121 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)122 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()123 void OnAVCallAnswer() override {};
OnAVCallHangUp()124 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()125 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)126 void OnPlayFromAssetId(int64_t assetId) override {};
OnPlayWithAssetId(const std::string & assetId)127 void OnPlayWithAssetId(const std::string& assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)128 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
129
130 ~AVSessionCallbackImpl() override;
131 };
132
OnPlay()133 void AVSessionCallbackImpl::OnPlay()
134 {
135 g_playOnCall = AVSESSION_SUCCESS;
136 SLOGI("OnPlay %{public}d", g_playOnCall);
137 }
138
OnPause()139 void AVSessionCallbackImpl::OnPause()
140 {
141 g_pauseOnCall = AVSESSION_SUCCESS;
142 SLOGI("OnPause %{public}d", g_pauseOnCall);
143 }
144
OnPlayNext()145 void AVSessionCallbackImpl::OnPlayNext()
146 {
147 g_nextOnCall = AVSESSION_SUCCESS;
148 SLOGI("OnPlayNext %{public}d", g_nextOnCall);
149 }
150
OnPlayPrevious()151 void AVSessionCallbackImpl::OnPlayPrevious()
152 {
153 g_previousOnCall = AVSESSION_SUCCESS;
154 SLOGI("OnPlayPrevious %{public}d", g_previousOnCall);
155 }
156
~AVSessionCallbackImpl()157 AVSessionCallbackImpl::~AVSessionCallbackImpl()
158 {
159 }
160
161 /**
162 * @tc.name: SendSystemAVKeyEvent001
163 * @tc.desc: verifying send system keyEvent
164 * @tc.type: FUNC
165 * @tc.require: #I5Y4MZ
166 */
167 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent001, TestSize.Level0)
168 {
169 SLOGI("SendSystemAVKeyEvent001 with level0 begin!");
170 OHOS::AppExecFwk::ElementName elementName;
171 elementName.SetBundleName(g_testAnotherBundleName);
172 elementName.SetAbilityName(g_testAnotherAbilityName);
173 OHOS::sptr<AVSessionItem> avsessionHere_ =
174 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
175 avsessionHere_->Activate();
176 avservice_->UpdateTopSession(avsessionHere_);
177
178 g_metaData.Reset();
179 g_metaData.SetAssetId("123");
180 g_metaData.SetTitle("Black Humor");
181 g_metaData.SetArtist("zhoujielun");
182 g_metaData.SetAuthor("zhoujielun");
183 g_metaData.SetAlbum("Jay");
184 g_metaData.SetWriter("zhoujielun");
185 g_metaData.SetComposer("zhoujielun");
186 g_metaData.SetDuration(40000);
187 g_metaData.SetMediaImageUri("xxxxx");
188 g_metaData.SetSubTitle("fac");
189 g_metaData.SetDescription("for friends");
190 g_metaData.SetLyric("xxxxx");
191 avsessionHere_->SetAVMetaData(g_metaData);
192
193 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
194 g_playbackState.SetSpeed(1.5);
195 g_playbackState.SetPosition({80000, 0});
196 g_playbackState.SetBufferedTime(60000);
197 g_playbackState.SetLoopMode(2);
198 g_playbackState.SetFavorite(true);
199 avsessionHere_->SetAVPlaybackState(g_playbackState);
200
201 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
202 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
203 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
204
205 auto keyEvent = OHOS::MMI::KeyEvent::Create();
206 ASSERT_NE(keyEvent, nullptr);
207 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
208 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
209 OHOS::MMI::KeyEvent::KeyItem item;
210 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
211 item.SetDownTime(0);
212 item.SetPressed(true);
213 keyEvent->AddPressedKeyItems(item);
214 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
215 sleep(1);
216 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
217 g_pauseOnCall = false;
218 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
219 SLOGI("SendSystemAVKeyEvent001 end!");
220 }
221
222 /**
223 * @tc.name: SendSystemAVKeyEvent002
224 * @tc.desc: verifying send system keyEvent
225 * @tc.type: FUNC
226 * @tc.require: #I5Y4MZ
227 */
228 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent002, TestSize.Level0)
229 {
230 SLOGI("SendSystemAVKeyEvent002 begin!");
231 OHOS::AppExecFwk::ElementName elementName;
232 elementName.SetBundleName(g_testAnotherBundleName);
233 elementName.SetAbilityName(g_testAnotherAbilityName);
234 OHOS::sptr<AVSessionItem> avsessionHere_ =
235 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
236 avsessionHere_->Activate();
237 avservice_->UpdateTopSession(avsessionHere_);
238
239 g_metaData.Reset();
240 g_metaData.SetAssetId("123");
241 g_metaData.SetTitle("Black Humor");
242 g_metaData.SetArtist("zhoujielun");
243 g_metaData.SetAuthor("zhoujielun");
244 g_metaData.SetAlbum("Jay");
245 g_metaData.SetWriter("zhoujielun");
246 g_metaData.SetComposer("zhoujielun");
247 g_metaData.SetDuration(40000);
248 g_metaData.SetMediaImageUri("xxxxx");
249 g_metaData.SetSubTitle("fac");
250 g_metaData.SetDescription("for friends");
251 g_metaData.SetLyric("xxxxx");
252 avsessionHere_->SetAVMetaData(g_metaData);
253
254 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
255 g_playbackState.SetSpeed(1.5);
256 g_playbackState.SetPosition({80000, 0});
257 g_playbackState.SetBufferedTime(60000);
258 g_playbackState.SetLoopMode(2);
259 g_playbackState.SetFavorite(true);
260 avsessionHere_->SetAVPlaybackState(g_playbackState);
261
262 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
263 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
264 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
265
266 auto keyEvent = OHOS::MMI::KeyEvent::Create();
267 ASSERT_NE(keyEvent, nullptr);
268 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
269 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
270 OHOS::MMI::KeyEvent::KeyItem item;
271 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
272 item.SetDownTime(0);
273 item.SetPressed(true);
274 keyEvent->AddPressedKeyItems(item);
275 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
276 sleep(1);
277 EXPECT_EQ(g_playOnCall, AVSESSION_SUCCESS);
278 g_playOnCall = false;
279 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
280 SLOGI("SendSystemAVKeyEvent002 end!");
281 }
282
283 /**
284 * @tc.name: SendSystemAVKeyEvent003
285 * @tc.desc: verifying send system keyEvent
286 * @tc.type: FUNC
287 * @tc.require: #I5Y4MZ
288 */
289 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent003, TestSize.Level0)
290 {
291 SLOGI("SendSystemAVKeyEvent003 begin!");
292 OHOS::AppExecFwk::ElementName elementName;
293 elementName.SetBundleName(g_testAnotherBundleName);
294 elementName.SetAbilityName(g_testAnotherAbilityName);
295 OHOS::sptr<AVSessionItem> avsessionHere_ =
296 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
297 avsessionHere_->Activate();
298 avservice_->UpdateTopSession(avsessionHere_);
299
300 g_metaData.Reset();
301 g_metaData.SetAssetId("123");
302 g_metaData.SetTitle("Black Humor");
303 g_metaData.SetArtist("zhoujielun");
304 g_metaData.SetAuthor("zhoujielun");
305 g_metaData.SetAlbum("Jay");
306 g_metaData.SetWriter("zhoujielun");
307 g_metaData.SetComposer("zhoujielun");
308 g_metaData.SetDuration(40000);
309 g_metaData.SetMediaImageUri("xxxxx");
310 g_metaData.SetSubTitle("fac");
311 g_metaData.SetDescription("for friends");
312 g_metaData.SetLyric("xxxxx");
313 avsessionHere_->SetAVMetaData(g_metaData);
314
315 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
316 g_playbackState.SetSpeed(1.5);
317 g_playbackState.SetPosition({80000, 0});
318 g_playbackState.SetBufferedTime(60000);
319 g_playbackState.SetLoopMode(2);
320 g_playbackState.SetFavorite(true);
321 avsessionHere_->SetAVPlaybackState(g_playbackState);
322
323 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
324 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
325 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
326
327 auto keyEvent = OHOS::MMI::KeyEvent::Create();
328 ASSERT_NE(keyEvent, nullptr);
329 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
330 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
331 OHOS::MMI::KeyEvent::KeyItem item;
332 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
333 item.SetDownTime(0);
334 item.SetPressed(true);
335 keyEvent->AddPressedKeyItems(item);
336 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
337 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
338 sleep(1);
339 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
340 g_nextOnCall = false;
341 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
342 SLOGI("SendSystemAVKeyEvent003 end!");
343 }
344
345 /**
346 * @tc.name: SendSystemAVKeyEvent004
347 * @tc.desc: verifying send system keyEvent
348 * @tc.type: FUNC
349 * @tc.require: #I5Y4MZ
350 */
351 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent004, TestSize.Level0)
352 {
353 SLOGI("SendSystemAVKeyEvent004 begin!");
354 OHOS::AppExecFwk::ElementName elementName;
355 elementName.SetBundleName(g_testAnotherBundleName);
356 elementName.SetAbilityName(g_testAnotherAbilityName);
357 OHOS::sptr<AVSessionItem> avsessionHere_ =
358 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
359 avsessionHere_->Activate();
360 avservice_->UpdateTopSession(avsessionHere_);
361 g_metaData.SetAssetId("123");
362 g_metaData.SetTitle("Black Humor");
363 g_metaData.SetArtist("zhoujielun");
364 g_metaData.SetAuthor("zhoujielun");
365 g_metaData.SetAlbum("Jay");
366 g_metaData.SetWriter("zhoujielun");
367 g_metaData.SetComposer("zhoujielun");
368 g_metaData.SetDuration(40000);
369 g_metaData.SetSubTitle("fac");
370 g_metaData.SetDescription("for friends");
371 g_metaData.SetLyric("xxxxx");
372 avsessionHere_->SetAVMetaData(g_metaData);
373 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
374 g_playbackState.SetSpeed(1.5);
375 g_playbackState.SetPosition({80000, 0});
376 g_playbackState.SetBufferedTime(60000);
377 g_playbackState.SetLoopMode(2);
378 g_playbackState.SetFavorite(true);
379 avsessionHere_->SetAVPlaybackState(g_playbackState);
380 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
381 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
382 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
383 auto keyEvent = OHOS::MMI::KeyEvent::Create();
384 ASSERT_NE(keyEvent, nullptr);
385 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
386 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
387 OHOS::MMI::KeyEvent::KeyItem item;
388 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
389 item.SetDownTime(0);
390 item.SetPressed(true);
391 keyEvent->AddPressedKeyItems(item);
392 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
393 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
394 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
395 sleep(1);
396 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
397 g_previousOnCall = false;
398 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
399 SLOGI("SendSystemAVKeyEvent004 end!");
400 }
401
402 /**
403 * @tc.name: SendSystemAVKeyEvent005
404 * @tc.desc: verifying send system keyEvent
405 * @tc.type: FUNC
406 * @tc.require: #I5Y4MZ
407 */
408 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent005, TestSize.Level0)
409 {
410 SLOGI("SendSystemAVKeyEvent005 begin!");
411 OHOS::AppExecFwk::ElementName elementName;
412 elementName.SetBundleName(g_testAnotherBundleName);
413 elementName.SetAbilityName(g_testAnotherAbilityName);
414 OHOS::sptr<AVSessionItem> avsessionHere_ =
415 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
416 avsessionHere_->Activate();
417 avservice_->UpdateTopSession(avsessionHere_);
418 g_metaData.SetAssetId("123");
419 g_metaData.SetTitle("Black Humor");
420 g_metaData.SetArtist("zhoujielun");
421 g_metaData.SetAuthor("zhoujielun");
422 g_metaData.SetAlbum("Jay");
423 g_metaData.SetWriter("zhoujielun");
424 g_metaData.SetComposer("zhoujielun");
425 g_metaData.SetDuration(40000);
426 g_metaData.SetMediaImageUri("xxxxx");
427 g_metaData.SetDescription("for friends");
428 avsessionHere_->SetAVMetaData(g_metaData);
429 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
430 g_playbackState.SetSpeed(1.5);
431 g_playbackState.SetPosition({80000, 0});
432 g_playbackState.SetBufferedTime(60000);
433 g_playbackState.SetLoopMode(2);
434 g_playbackState.SetFavorite(true);
435 avsessionHere_->SetAVPlaybackState(g_playbackState);
436 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
437 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
438 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
439 auto keyEvent = OHOS::MMI::KeyEvent::Create();
440 ASSERT_NE(keyEvent, nullptr);
441 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
442 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
443 OHOS::MMI::KeyEvent::KeyItem item;
444 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
445 item.SetDownTime(0);
446 item.SetPressed(true);
447 keyEvent->AddPressedKeyItems(item);
448 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
449 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
450 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
451 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
452 sleep(1);
453 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
454 g_previousOnCall = false;
455 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
456 SLOGI("SendSystemAVKeyEvent005 end!");
457 }
458
459 /**
460 * @tc.name: SendSystemAVKeyEvent006
461 * @tc.desc: verifying send system keyEvent
462 * @tc.type: FUNC
463 * @tc.require: #I5Y4MZ
464 */
465 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent006, TestSize.Level0)
466 {
467 SLOGI("SendSystemAVKeyEvent006 begin!");
468 OHOS::AppExecFwk::ElementName elementName;
469 elementName.SetBundleName(g_testAnotherBundleName);
470 elementName.SetAbilityName(g_testAnotherAbilityName);
471 OHOS::sptr<AVSessionItem> avsessionHere_ =
472 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
473 avsessionHere_->Activate();
474 avservice_->UpdateTopSession(avsessionHere_);
475 g_metaData.SetAssetId("123");
476 g_metaData.SetTitle("Black Humor");
477 g_metaData.SetArtist("zhoujielun");
478 g_metaData.SetAuthor("zhoujielun");
479 g_metaData.SetAlbum("Jay");
480 g_metaData.SetWriter("zhoujielun");
481 g_metaData.SetComposer("zhoujielun");
482 g_metaData.SetDuration(40000);
483 avsessionHere_->SetAVMetaData(g_metaData);
484 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
485 g_playbackState.SetSpeed(1.5);
486 g_playbackState.SetPosition({80000, 0});
487 g_playbackState.SetBufferedTime(60000);
488 g_playbackState.SetLoopMode(2);
489 g_playbackState.SetFavorite(true);
490 avsessionHere_->SetAVPlaybackState(g_playbackState);
491 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
492 OHOS::sptr<IAVSessionCallback> callbackClient = new(std::nothrow) AVSessionCallbackClient(callback);
493 EXPECT_EQ(avsessionHere_->RegisterCallbackInner(callbackClient), AVSESSION_SUCCESS);
494 auto keyEvent = OHOS::MMI::KeyEvent::Create();
495 ASSERT_NE(keyEvent, nullptr);
496 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
497 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
498 OHOS::MMI::KeyEvent::KeyItem item;
499 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
500 item.SetDownTime(0);
501 item.SetPressed(true);
502 keyEvent->AddPressedKeyItems(item);
503 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
504 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
505 sleep(1);
506 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
507 g_nextOnCall = false;
508 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
509 sleep(1);
510 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
511 g_pauseOnCall = false;
512 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
513 SLOGI("SendSystemAVKeyEvent006 end!");
514 }
515
516 static HWTEST_F(AVSessionServiceTest, NotifyDeviceAvailable001, TestSize.Level0)
517 {
518 SLOGI("NotifyDeviceAvailable001 begin!");
519 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
520 SLOGI("NotifyDeviceAvailable001 in!");
521 OutputDeviceInfo outputDeviceInfo;
522 OHOS::AVSession::DeviceInfo deviceInfo;
523 deviceInfo.castCategory_ = 1;
524 deviceInfo.deviceId_ = "deviceId";
525 outputDeviceInfo.deviceInfos_.push_back(deviceInfo);
526 avservice_->NotifyDeviceAvailable(outputDeviceInfo);
527 EXPECT_EQ(0, AVSESSION_SUCCESS);
528 #endif
529 EXPECT_EQ(0, AVSESSION_SUCCESS);
530 SLOGI("NotifyDeviceAvailable001 end!");
531 }
532
533 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast001, TestSize.Level0)
534 {
535 SLOGI("NotifyMirrorToStreamCast001 begin!");
536 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
537 SLOGI("NotifyMirrorToStreamCast001 in!");
538 avservice_->NotifyMirrorToStreamCast();
539 #endif
540 EXPECT_EQ(0, AVSESSION_SUCCESS);
541 SLOGI("NotifyMirrorToStreamCast001 end!");
542 }
543
544 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast002, TestSize.Level0)
545 {
546 SLOGI("NotifyMirrorToStreamCast002 begin!");
547 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
548 SLOGI("NotifyMirrorToStreamCast002 in!");
549 OHOS::AppExecFwk::ElementName elementName;
550 elementName.SetBundleName(g_testAnotherBundleName);
551 elementName.SetAbilityName(g_testAnotherAbilityName);
552 OHOS::sptr<AVSessionItem> avsessionHere_ =
553 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
554 EXPECT_EQ(avsessionHere_ != nullptr, true);
555 avservice_->UpdateTopSession(avsessionHere_);
556 avservice_->NotifyMirrorToStreamCast();
557 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
558 #endif
559 EXPECT_EQ(0, AVSESSION_SUCCESS);
560 SLOGI("NotifyMirrorToStreamCast002 end!");
561 }
562
563 static HWTEST_F(AVSessionServiceTest, NotifyMirrorToStreamCast003, TestSize.Level0)
564 {
565 SLOGI("NotifyMirrorToStreamCast003 begin!");
566 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
567 SLOGI("NotifyMirrorToStreamCast002 in!");
568 OHOS::AppExecFwk::ElementName elementName;
569 elementName.SetBundleName(g_testAnotherBundleName);
570 elementName.SetAbilityName(g_testAnotherAbilityName);
571 OHOS::sptr<AVSessionItem> avsessionHere_ =
572 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
573 EXPECT_EQ(avsessionHere_ != nullptr, true);
574 avservice_->UpdateTopSession(avsessionHere_);
575 avservice_->NotifyMirrorToStreamCast();
576 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
577 #endif
578 EXPECT_EQ(0, AVSESSION_SUCCESS);
579 SLOGI("NotifyMirrorToStreamCast003 end!");
580 }
581
582 static HWTEST_F(AVSessionServiceTest, RefreshFocusSessionSort001, TestSize.Level0)
583 {
584 SLOGI("RefreshFocusSessionSort001 begin!");
585 OHOS::AppExecFwk::ElementName elementName;
586 elementName.SetBundleName(g_testAnotherBundleName);
587 elementName.SetAbilityName(g_testAnotherAbilityName);
588 OHOS::sptr<AVSessionItem> avsessionHere_ =
589 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
590 EXPECT_EQ(avsessionHere_ != nullptr, true);
591 avservice_->RefreshFocusSessionSort(avsessionHere_);
592 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
593 EXPECT_EQ(0, AVSESSION_SUCCESS);
594 SLOGI("RefreshFocusSessionSort001 end!");
595 }
596
597 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid001, TestSize.Level0)
598 {
599 SLOGI("SelectSessionByUid001 begin!");
600 OHOS::AppExecFwk::ElementName elementName;
601 elementName.SetBundleName(g_testAnotherBundleName);
602 elementName.SetAbilityName(g_testAnotherAbilityName);
603 OHOS::sptr<AVSessionItem> avsessionHere_ =
604 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
605 EXPECT_EQ(avsessionHere_ != nullptr, true);
606 AudioRendererChangeInfo info = {};
607 info.clientUID = 0;
608 avservice_->SelectSessionByUid(info);
609 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
610 EXPECT_EQ(0, AVSESSION_SUCCESS);
611 SLOGI("SelectSessionByUid001 end!");
612 }
613
614 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid002, TestSize.Level0)
615 {
616 SLOGI("SelectSessionByUid002 begin!");
617 OHOS::AppExecFwk::ElementName elementName;
618 elementName.SetBundleName(g_testAnotherBundleName);
619 elementName.SetAbilityName(g_testAnotherAbilityName);
620 OHOS::sptr<AVSessionItem> avsessionHere_ =
621 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
622 EXPECT_EQ(avsessionHere_ != nullptr, true);
623 AudioRendererChangeInfo info = {};
624 info.clientUID = avsessionHere_->GetUid();
625 avservice_->SelectSessionByUid(info);
626 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
627 EXPECT_EQ(0, AVSESSION_SUCCESS);
628 SLOGI("SelectSessionByUid002 end!");
629 }
630
631 static HWTEST_F(AVSessionServiceTest, InitBMS001, TestSize.Level0)
632 {
633 SLOGI("InitBMS001 begin!");
634 avservice_->InitBMS();
635 EXPECT_EQ(0, AVSESSION_SUCCESS);
636 SLOGI("InitBMS001 end!");
637 }
638
639 static HWTEST_F(AVSessionServiceTest, ReleaseCastSession001, TestSize.Level0)
640 {
641 SLOGI("ReleaseCastSession001 begin!");
642 OHOS::AppExecFwk::ElementName elementName;
643 elementName.SetBundleName(g_testAnotherBundleName);
644 elementName.SetAbilityName(g_testAnotherAbilityName);
645 OHOS::sptr<AVSessionItem> avsessionHere_ =
646 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
647 EXPECT_EQ(avsessionHere_ != nullptr, true);
648 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
649 SLOGI("ReleaseCastSession001 in!");
650 avservice_->ReleaseCastSession();
651 #endif
652 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
653 EXPECT_EQ(0, AVSESSION_SUCCESS);
654 SLOGI("ReleaseCastSession001 end!");
655 }
656
657 static HWTEST_F(AVSessionServiceTest, CreateSessionByCast001, TestSize.Level0)
658 {
659 SLOGI("CreateSessionByCast001 begin!");
660 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
661 SLOGI("CreateSessionByCast001 in!");
662 avservice_->CreateSessionByCast(0);
663 avservice_->ClearSessionForClientDiedNoLock(getpid(), false);
664 #endif
665 EXPECT_EQ(0, AVSESSION_SUCCESS);
666 SLOGI("CreateSessionByCast001 end!");
667 }
668
669 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast001, TestSize.Level0)
670 {
671 SLOGI("MirrorToStreamCast001 begin!");
672 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
673 SLOGI("MirrorToStreamCast001 in!");
674 OHOS::AppExecFwk::ElementName elementName;
675 elementName.SetBundleName(g_testAnotherBundleName);
676 elementName.SetAbilityName(g_testAnotherAbilityName);
677 OHOS::sptr<AVSessionItem> avsessionHere_ =
678 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
679 EXPECT_EQ(avsessionHere_ != nullptr, true);
680 avservice_->is2in1_ = true;
681 avservice_->MirrorToStreamCast(avsessionHere_);
682 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
683 #endif
684 EXPECT_EQ(0, AVSESSION_SUCCESS);
685 SLOGI("MirrorToStreamCast001 end!");
686 }
687
688 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast002, TestSize.Level0)
689 {
690 SLOGI("MirrorToStreamCast002 begin!");
691 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
692 SLOGI("MirrorToStreamCast002 in!");
693 OHOS::AppExecFwk::ElementName elementName;
694 elementName.SetBundleName(g_testAnotherBundleName);
695 elementName.SetAbilityName(g_testAnotherAbilityName);
696 OHOS::sptr<AVSessionItem> avsessionHere_ =
697 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
698 EXPECT_EQ(avsessionHere_ != nullptr, true);
699 avservice_->is2in1_ = false;
700 avservice_->MirrorToStreamCast(avsessionHere_);
701 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
702 #endif
703 EXPECT_EQ(0, AVSESSION_SUCCESS);
704 SLOGI("MirrorToStreamCast002 end!");
705 }
706
707 static HWTEST_F(AVSessionServiceTest, MirrorToStreamCast003, TestSize.Level0)
708 {
709 SLOGI("MirrorToStreamCast003 begin!");
710 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
711 SLOGI("MirrorToStreamCast003 in!");
712 OHOS::AppExecFwk::ElementName elementName;
713 elementName.SetBundleName(g_testAnotherBundleName);
714 elementName.SetAbilityName(g_testAnotherAbilityName);
715 OHOS::sptr<AVSessionItem> avsessionHere_ =
716 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
717 EXPECT_EQ(avsessionHere_ != nullptr, true);
718 avservice_->is2in1_ = true;
719 avservice_->MirrorToStreamCast(avsessionHere_);
720 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
721 #endif
722 EXPECT_EQ(0, AVSESSION_SUCCESS);
723 SLOGI("MirrorToStreamCast003 end!");
724 }
725
726 static HWTEST_F(AVSessionServiceTest, SaveSessionInfoInFile001, TestSize.Level0)
727 {
728 SLOGI("SaveSessionInfoInFile001 begin!");
729 OHOS::AppExecFwk::ElementName elementName;
730 elementName.SetBundleName(g_testAnotherBundleName);
731 elementName.SetAbilityName(g_testAnotherAbilityName);
732 OHOS::sptr<AVSessionItem> avsessionHere_ =
733 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
734 EXPECT_EQ(avsessionHere_ != nullptr, true);
735 avservice_->SaveSessionInfoInFile(avsessionHere_->GetSessionId(),
736 "audio", elementName);
737 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
738 EXPECT_EQ(0, AVSESSION_SUCCESS);
739 SLOGI("SaveSessionInfoInFile001 end!");
740 }
741
742 static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart001, TestSize.Level0)
743 {
744 SLOGI("HandleSystemKeyColdStart001 begin");
745 ASSERT_TRUE(avservice_ != nullptr);
746 OHOS::AppExecFwk::ElementName elementName;
747 elementName.SetBundleName(g_testAnotherBundleName);
748 elementName.SetAbilityName(g_testAnotherAbilityName);
749 OHOS::sptr<AVSessionItem> avsessionHere_ =
750 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
751 ASSERT_EQ(avsessionHere_ != nullptr, true);
752 AVControlCommand command;
753 avservice_->HandleSystemKeyColdStart(command);
754 EXPECT_NE(avsessionHere_, avservice_->topSession_);
755 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
756 avsessionHere_->Destroy();
757 SLOGI("HandleSystemKeyColdStart001 end");
758 }
759
760 static HWTEST_F(AVSessionServiceTest, HandleSystemKeyColdStart002, TestSize.Level0)
761 {
762 SLOGD("HandleSystemKeyColdStart002 begin");
763 ASSERT_TRUE(avservice_ != nullptr);
764 OHOS::AppExecFwk::ElementName elementName;
765 elementName.SetBundleName(g_testAnotherBundleName);
766 elementName.SetAbilityName(g_testAnotherAbilityName);
767 OHOS::sptr<AVSessionItem> avsessionHere =
768 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
769 ASSERT_EQ(avsessionHere != nullptr, true);
770 AVControlCommand command;
771 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
772 avservice_->HandleSystemKeyColdStart(command);
773 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY_PREVIOUS);
774 avservice_->HandleSystemKeyColdStart(command);
775 command.SetCommand(AVControlCommand::SESSION_CMD_PLAY_NEXT);
776 avservice_->HandleSystemKeyColdStart(command);
777 EXPECT_NE(avsessionHere, avservice_->topSession_);
778 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
779 avsessionHere->Destroy();
780 SLOGD("HandleSystemKeyColdStart002 end");
781 }
782
783 static HWTEST_F(AVSessionServiceTest, GetHistoricalAVQueueInfos001, TestSize.Level0)
784 {
785 SLOGI("GetHistoricalAVQueueInfos001 begin!");
786 std::vector<AVQueueInfo> avQueueInfos_;
787 avservice_->GetHistoricalAVQueueInfos(0, 0, avQueueInfos_);
788 EXPECT_EQ(0, AVSESSION_SUCCESS);
789 SLOGI("GetHistoricalAVQueueInfos001 end!");
790 }
791
792 static HWTEST_F(AVSessionServiceTest, SaveAvQueueInfo001, TestSize.Level0)
793 {
794 SLOGI("SaveAvQueueInfo001 begin!");
795 OHOS::AppExecFwk::ElementName elementName;
796 elementName.SetBundleName(g_testAnotherBundleName);
797 elementName.SetAbilityName(g_testAnotherAbilityName);
798 OHOS::sptr<AVSessionItem> avsessionHere_ =
799 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
800 EXPECT_EQ(avsessionHere_ != nullptr, true);
801 AVMetaData meta = avsessionHere_->GetMetaData();
802 std::string oldContent;
803 if (!avservice_->LoadStringFromFileEx(avservice_->GetAVQueueDir(), oldContent)) {
804 SLOGE("SaveAvQueueInfo001 read avqueueinfo fail, Return!");
805 } else {
806 avservice_->SaveAvQueueInfo(oldContent, g_testAnotherBundleName, meta,
807 avservice_->GetUsersManager().GetCurrentUserId());
808 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
809 EXPECT_EQ(0, AVSESSION_SUCCESS);
810 SLOGI("SaveAvQueueInfo001 end!");
811 }
812 }
813
814 static HWTEST_F(AVSessionServiceTest, AddAvQueueInfoToFile001, TestSize.Level0)
815 {
816 SLOGI("AddAvQueueInfoToFile001 begin!");
817 OHOS::AppExecFwk::ElementName elementName;
818 elementName.SetBundleName(g_testAnotherBundleName);
819 elementName.SetAbilityName(g_testAnotherAbilityName);
820 OHOS::sptr<AVSessionItem> avsessionHere_ =
821 avservice_->CreateSessionInner("RemoteCast", AVSession::SESSION_TYPE_AUDIO, false, elementName);
822 EXPECT_EQ(avsessionHere_ != nullptr, true);
823 avservice_->AddAvQueueInfoToFile(*avsessionHere_);
824 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
825 EXPECT_EQ(0, AVSESSION_SUCCESS);
826 SLOGI("AddAvQueueInfoToFile001 end!");
827 }
828
829 static HWTEST_F(AVSessionServiceTest, StartAVPlayback001, TestSize.Level0)
830 {
831 SLOGI("StartAVPlayback001 begin!");
832 avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME");
833 EXPECT_EQ(0, AVSESSION_SUCCESS);
834 SLOGI("StartAVPlayback001 end!");
835 }
836
837 static HWTEST_F(AVSessionServiceTest, StartAVPlayback002, TestSize.Level0)
838 {
839 SLOGI("StartAVPlayback002 begin!");
840 std::string deviceId = "123";
841 avservice_->StartAVPlayback(g_testAnotherBundleName, "FAKE_ASSET_NAME", deviceId);
842 EXPECT_EQ(0, AVSESSION_SUCCESS);
843 SLOGI("StartAVPlayback002 end!");
844 }
845
846 static HWTEST_F(AVSessionServiceTest, GetSubNode001, TestSize.Level0)
847 {
848 SLOGI("GetSubNode001 begin!");
849
850 cJSON* value = cJSON_CreateObject();
851 if (value == nullptr) {
852 SLOGE("get value nullptr");
853 FAIL();
854 }
855 if (cJSON_IsInvalid(value)) {
856 SLOGE("get value invalid");
857 cJSON_Delete(value);
858 value = nullptr;
859 FAIL();
860 }
861 cJSON_AddStringToObject(value, "bundleName", g_testAnotherBundleName);
862 avservice_->GetSubNode(value, "FAKE_NAME");
863 EXPECT_EQ(0, AVSESSION_SUCCESS);
864
865 cJSON_Delete(value);
866 value = nullptr;
867 SLOGI("GetSubNode001 end!");
868 }
869
870 static HWTEST_F(AVSessionServiceTest, Close001, TestSize.Level0)
871 {
872 SLOGI("Close001 begin!");
873 avservice_->Close();
874 EXPECT_EQ(0, AVSESSION_SUCCESS);
875 SLOGI("Close001 end!");
876 }
877
878 static HWTEST_F(AVSessionServiceTest, DeleteHistoricalRecord001, TestSize.Level0)
879 {
880 SLOGI("DeleteHistoricalRecord001 begin!");
881 avservice_->DeleteHistoricalRecord(g_testAnotherBundleName);
882 EXPECT_EQ(0, AVSESSION_SUCCESS);
883 SLOGI("DeleteHistoricalRecord001 end!");
884 }
885
886 static HWTEST_F(AVSessionServiceTest, Dump001, TestSize.Level0)
887 {
888 SLOGI("Dump001 begin!");
889 std::vector<std::u16string> argsList;
890 avservice_->Dump(1, argsList);
891 EXPECT_EQ(0, AVSESSION_SUCCESS);
892 SLOGI("Dump001 end!");
893 }
894
895 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand001, TestSize.Level0)
896 {
897 SLOGI("ProcessCastAudioCommand001 begin!");
898 std::string sourceSessionInfo = "SOURCE";
899 std::string sinkSessionInfo = " SINK";
900 avservice_->ProcessCastAudioCommand(
901 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CAST_AUDIO,
902 sourceSessionInfo, sinkSessionInfo);
903 EXPECT_EQ(0, AVSESSION_SUCCESS);
904 SLOGI("ProcessCastAudioCommand001 end!");
905 }
906
907 static HWTEST_F(AVSessionServiceTest, ProcessCastAudioCommand002, TestSize.Level0)
908 {
909 SLOGI("ProcessCastAudioCommand002 begin!");
910 std::string sourceSessionInfo = "SOURCE";
911 std::string sinkSessionInfo = " SINK";
912 avservice_->ProcessCastAudioCommand(
913 OHOS::AVSession::AVSessionServiceStub::RemoteServiceCommand::COMMAND_CANCEL_CAST_AUDIO,
914 sourceSessionInfo, sinkSessionInfo);
915 EXPECT_EQ(0, AVSESSION_SUCCESS);
916 SLOGI("ProcessCastAudioCommand002 end!");
917 }
918
919 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent001, TestSize.Level1)
920 {
921 SLOGI("OnReceiveEvent001 begin!");
922 OHOS::EventFwk::CommonEventData eventData;
923 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_ON;
924 OHOS::AAFwk::Want want = eventData.GetWant();
925 want.SetAction(action);
926 eventData.SetWant(want);
927 OHOS::EventFwk::MatchingSkills matchingSkills;
928 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
929 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
930 eventSubscriber.OnReceiveEvent(eventData);
931 EXPECT_EQ(0, AVSESSION_SUCCESS);
932 SLOGI("OnReceiveEvent001 end!");
933 }
934
935 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent002, TestSize.Level0)
936 {
937 SLOGI("OnReceiveEvent002 begin!");
938 OHOS::EventFwk::CommonEventData eventData;
939 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_OFF;
940 OHOS::AAFwk::Want want = eventData.GetWant();
941 want.SetAction(action);
942 eventData.SetWant(want);
943 OHOS::EventFwk::MatchingSkills matchingSkills;
944 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
945 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
946 eventSubscriber.OnReceiveEvent(eventData);
947 EXPECT_EQ(0, AVSESSION_SUCCESS);
948 SLOGI("OnReceiveEvent002 end!");
949 }
950
951 static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent001, TestSize.Level0)
952 {
953 SLOGI("SubscribeCommonEvent001 begin!");
954 EXPECT_TRUE(avservice_ != nullptr);
955 avservice_->SubscribeCommonEvent();
956 avservice_->UnSubscribeCommonEvent();
957 SLOGI("SubscribeCommonEvent001 end!");
958 }
959
960 static HWTEST_F(AVSessionServiceTest, UnSubscribeCommonEvent002, TestSize.Level0)
961 {
962 SLOGI("SubscribeCommonEvent002 begin!");
963 EXPECT_TRUE(avservice_ != nullptr);
964 avservice_->UnSubscribeCommonEvent();
965 SLOGI("SubscribeCommonEvent002 end!");
966 }
967
968 static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility001, TestSize.Level0)
969 {
970 SLOGI("OnRemoveSystemAbility001 begin!");
971 EXPECT_TRUE(avservice_ != nullptr);
972 int32_t systemAbilityId = 65546;
973 std::string deviceId = "";
974 avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
975 SLOGI("OnRemoveSystemAbility001 end!");
976 }
977
978 static HWTEST_F(AVSessionServiceTest, OnRemoveSystemAbility002, TestSize.Level0)
979 {
980 SLOGI("OnRemoveSystemAbility002 begin!");
981 EXPECT_TRUE(avservice_ != nullptr);
982 int32_t systemAbilityId = 111222;
983 std::string deviceId = "";
984 avservice_->OnRemoveSystemAbility(systemAbilityId, deviceId);
985 SLOGI("OnRemoveSystemAbility002 end!");
986 }
987
988 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptorsFromFile001, TestSize.Level0)
989 {
990 SLOGI("GetHistoricalSessionDescriptorsFromFile001 begin!");
991 std::vector<AVSessionDescriptor> descriptors;
992 int32_t ret = avservice_->GetHistoricalSessionDescriptorsFromFile(descriptors);
993 EXPECT_EQ(ret, AVSESSION_SUCCESS);
994 SLOGI("GetHistoricalSessionDescriptorsFromFile001 end!");
995 }
996
997 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors001, TestSize.Level0)
998 {
999 SLOGI("GetHistoricalSessionDescriptors001 begin!");
1000 int32_t maxSize = -1;
1001 std::vector<AVSessionDescriptor> descriptors;
1002 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
1003 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1004 SLOGI("GetHistoricalSessionDescriptors001 end!");
1005 }
1006
1007 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors002, TestSize.Level0)
1008 {
1009 SLOGI("GetHistoricalSessionDescriptors002 begin!");
1010 int32_t maxSize = 50;
1011 std::vector<AVSessionDescriptor> descriptors;
1012 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
1013 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1014 SLOGI("GetHistoricalSessionDescriptors002 end!");
1015 }
1016
1017 static HWTEST_F(AVSessionServiceTest, GetHistoricalSessionDescriptors003, TestSize.Level0)
1018 {
1019 SLOGI("GetHistoricalSessionDescriptors003 begin!");
1020 int32_t maxSize = 10;
1021 std::vector<AVSessionDescriptor> descriptors;
1022 for (int i = 0; i <= maxSize; i++) {
1023 AVSessionDescriptor aVSessionDescriptor;
1024 descriptors.emplace_back(aVSessionDescriptor);
1025 }
1026 int32_t ret = avservice_->GetHistoricalSessionDescriptors(maxSize, descriptors);
1027 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1028 SLOGI("GetHistoricalSessionDescriptors003 end!");
1029 }
1030
1031 static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean001, TestSize.Level0)
1032 {
1033 SLOGI("DoMetadataImgClean001 begin!");
1034 EXPECT_TRUE(avservice_ != nullptr);
1035 OHOS::AVSession::AVMetaData metaData;
1036
1037 std::shared_ptr<AVSessionPixelMap> avQueuePixelMap = std::make_shared<AVSessionPixelMap>();
1038 std::vector<uint8_t> imgBuffer = {1, 1, 0, 1, 1};
1039 avQueuePixelMap->SetInnerImgBuffer(imgBuffer);
1040 metaData.SetAVQueueImage(avQueuePixelMap);
1041
1042 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
1043 std::vector<uint8_t> imgBuffer2 = {1, 0, 0, 0, 1};
1044 mediaPixelMap->SetInnerImgBuffer(imgBuffer2);
1045 metaData.SetMediaImage(mediaPixelMap);
1046
1047 avservice_->DoMetadataImgClean(metaData);
1048 SLOGI("DoMetadataImgClean001 end!");
1049 }
1050
1051 static HWTEST_F(AVSessionServiceTest, DoMetadataImgClean002, TestSize.Level0)
1052 {
1053 SLOGI("DoMetadataImgClean002 begin!");
1054 EXPECT_TRUE(avservice_ != nullptr);
1055 OHOS::AVSession::AVMetaData metaData;
1056 avservice_->DoMetadataImgClean(metaData);
1057 SLOGI("DoMetadataImgClean002 end!");
1058 }
1059
1060 static HWTEST_F(AVSessionServiceTest, Dump002, TestSize.Level0)
1061 {
1062 SLOGI("Dump002 begin!");
1063 int32_t fd = -1;
1064 std::vector<std::u16string> argsList;
1065 int32_t ret = avservice_->Dump(fd, argsList);
1066 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1067 SLOGI("Dump002 end!");
1068 }
1069
1070 static HWTEST_F(AVSessionServiceTest, GetTrustedDeviceName001, TestSize.Level0)
1071 {
1072 SLOGI("GetTrustedDeviceName001 begin!");
1073 std::string networkId = "";
1074 std::string deviceName = "";
1075 int32_t ret = avservice_->GetTrustedDeviceName(networkId, deviceName);
1076 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1077 SLOGI("GetTrustedDeviceName001 end!");
1078 }
1079
1080 static HWTEST_F(AVSessionServiceTest, HandleFocusSession001, TestSize.Level0)
1081 {
1082 SLOGI("HandleFocusSession001 begin!");
1083 EXPECT_TRUE(avservice_ != nullptr);
1084 int32_t pid = 201;
1085 OHOS::AppExecFwk::ElementName elementName;
1086 elementName.SetBundleName(g_testAnotherBundleName);
1087 elementName.SetAbilityName(g_testAnotherAbilityName);
1088 OHOS::sptr<AVSessionItem> avsessionHere_ =
1089 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1090 avsessionHere_->SetUid(pid);
1091 avservice_->UpdateTopSession(avsessionHere_);
1092 FocusSessionStrategy::FocusSessionChangeInfo info;
1093 info.uid = pid;
1094 avservice_->HandleFocusSession(info, false);
1095 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1096 avsessionHere_->Destroy();
1097 SLOGI("HandleFocusSession001 end!");
1098 }
1099
1100 static HWTEST_F(AVSessionServiceTest, HandleFocusSession002, TestSize.Level0)
1101 {
1102 SLOGI("HandleFocusSession002 begin!");
1103 EXPECT_TRUE(avservice_ != nullptr);
1104 int32_t pid = 202;
1105 OHOS::AppExecFwk::ElementName elementName;
1106 elementName.SetBundleName(g_testAnotherBundleName);
1107 elementName.SetAbilityName(g_testAnotherAbilityName);
1108 OHOS::sptr<AVSessionItem> avsessionHere_ =
1109 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1110 avsessionHere_->SetUid(pid);
1111 avservice_->UpdateTopSession(avsessionHere_);
1112 FocusSessionStrategy::FocusSessionChangeInfo info;
1113 info.uid = 203;
1114 avservice_->HandleFocusSession(info, false);
1115 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1116 avsessionHere_->Destroy();
1117 SLOGI("HandleFocusSession002 end!");
1118 }
1119
1120 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession001, TestSize.Level0)
1121 {
1122 SLOGI("HandleFocusSession001 begin!");
1123 EXPECT_TRUE(avservice_ != nullptr);
1124 int32_t pid = 203;
1125 OHOS::AppExecFwk::ElementName elementName;
1126 elementName.SetBundleName(g_testAnotherBundleName);
1127 elementName.SetAbilityName(g_testAnotherAbilityName);
1128 OHOS::sptr<AVSessionItem> avsessionHere_ =
1129 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1130 avsessionHere_->SetUid(pid);
1131 FocusSessionStrategy::FocusSessionChangeInfo info;
1132 info.uid = pid;
1133 avservice_->HandleFocusSession(info, false);
1134 avservice_->UpdateFrontSession(avsessionHere_, true);
1135 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1136 avsessionHere_->Destroy();
1137 SLOGI("HandleFocusSession001 end!");
1138 }
1139
1140 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession002, TestSize.Level0)
1141 {
1142 SLOGI("UpdateFrontSession002 begin!");
1143 EXPECT_TRUE(avservice_ != nullptr);
1144 int32_t pid = 204;
1145 OHOS::AppExecFwk::ElementName elementName;
1146 elementName.SetBundleName(g_testAnotherBundleName);
1147 elementName.SetAbilityName(g_testAnotherAbilityName);
1148 OHOS::sptr<AVSessionItem> avsessionHere_ =
1149 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1150 avsessionHere_->SetUid(pid);
1151 FocusSessionStrategy::FocusSessionChangeInfo info;
1152 info.uid = 205;
1153 avservice_->HandleFocusSession(info, false);
1154 avservice_->UpdateFrontSession(avsessionHere_, true);
1155 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1156 avsessionHere_->Destroy();
1157 SLOGI("UpdateFrontSession002 end!");
1158 }
1159
1160 static HWTEST_F(AVSessionServiceTest, SelectFocusSession001, TestSize.Level0)
1161 {
1162 SLOGI("SelectFocusSession001 begin!");
1163 int32_t pid = 205;
1164 OHOS::AppExecFwk::ElementName elementName;
1165 elementName.SetBundleName(g_testAnotherBundleName);
1166 elementName.SetAbilityName(g_testAnotherAbilityName);
1167 OHOS::sptr<AVSessionItem> avsessionHere_ =
1168 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1169 avsessionHere_->SetUid(pid);
1170 FocusSessionStrategy::FocusSessionChangeInfo info;
1171 info.pid = avsessionHere_->GetPid();
1172 bool ret = avservice_->SelectFocusSession(info);
1173 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1174 avsessionHere_->Destroy();
1175 EXPECT_EQ(ret, true);
1176 SLOGI("SelectFocusSession001 end!");
1177 }
1178
1179 static HWTEST_F(AVSessionServiceTest, SelectFocusSession002, TestSize.Level0)
1180 {
1181 SLOGI("SelectFocusSession002 begin!");
1182 int32_t pid = 206;
1183 OHOS::AppExecFwk::ElementName elementName;
1184 elementName.SetBundleName(g_testAnotherBundleName);
1185 elementName.SetAbilityName(g_testAnotherAbilityName);
1186 OHOS::sptr<AVSessionItem> avsessionHere_ =
1187 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1188 avsessionHere_->SetUid(pid);
1189 FocusSessionStrategy::FocusSessionChangeInfo info;
1190 info.uid = 207;
1191 bool ret = avservice_->SelectFocusSession(info);
1192 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1193 avsessionHere_->Destroy();
1194 EXPECT_EQ(ret, false);
1195 SLOGI("SelectFocusSession002 end!");
1196 }
1197
1198 static HWTEST_F(AVSessionServiceTest, SelectSessionByUid003, TestSize.Level0)
1199 {
1200 SLOGI("SelectSessionByUid003 begin!");
1201 int32_t pid = 207;
1202 OHOS::AppExecFwk::ElementName elementName;
1203 elementName.SetBundleName(g_testAnotherBundleName);
1204 elementName.SetAbilityName(g_testAnotherAbilityName);
1205 OHOS::sptr<AVSessionItem> avsessionHere_ =
1206 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1207 EXPECT_EQ(avsessionHere_ != nullptr, true);
1208 avsessionHere_->SetUid(pid);
1209 AudioRendererChangeInfo info = {};
1210 info.clientUID = 208;
1211 auto ret = avservice_->SelectSessionByUid(info);
1212 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1213 avsessionHere_->Destroy();
1214 EXPECT_EQ(ret, nullptr);
1215 SLOGI("SelectSessionByUid003 end!");
1216 }
1217
1218 static HWTEST_F(AVSessionServiceTest, GetSessionDescriptorsBySessionId001, TestSize.Level0)
1219 {
1220 SLOGI("GetSessionDescriptorsBySessionId001 begin!");
1221 int32_t pid = 206;
1222 OHOS::AppExecFwk::ElementName elementName;
1223 elementName.SetBundleName(g_testAnotherBundleName);
1224 elementName.SetAbilityName(g_testAnotherAbilityName);
1225 OHOS::sptr<AVSessionItem> avsessionHere_ =
1226 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1227 avsessionHere_->SetUid(pid);
1228 std::string sessionId = "";
1229 AVSessionDescriptor descriptor;
1230 int32_t ret = avservice_->GetSessionDescriptorsBySessionId(sessionId, descriptor);
1231 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1232 avsessionHere_->Destroy();
1233 EXPECT_EQ(ret, AVSESSION_ERROR);
1234 SLOGI("GetSessionDescriptorsBySessionId001 end!");
1235 }
1236
1237 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent007, TestSize.Level0)
1238 {
1239 SLOGI("SendSystemAVKeyEvent007 begin!");
1240 OHOS::AppExecFwk::ElementName elementName;
1241 elementName.SetBundleName(g_testAnotherBundleName);
1242 elementName.SetAbilityName(g_testAnotherAbilityName);
1243 OHOS::sptr<AVSessionItem> avsessionHere_ =
1244 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1245 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1246 ASSERT_NE(keyEvent, nullptr);
1247 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
1248 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1249 avsessionHere_->Destroy();
1250 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1251 SLOGI("SendSystemAVKeyEvent007 end!");
1252 }
1253
1254
1255 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent008, TestSize.Level0)
1256 {
1257 SLOGI("SendSystemAVKeyEvent008 begin!");
1258 OHOS::AppExecFwk::ElementName elementName;
1259 elementName.SetBundleName(g_testAnotherBundleName);
1260 elementName.SetAbilityName(g_testAnotherAbilityName);
1261 OHOS::sptr<AVSessionItem> avsessionHere_ =
1262 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1263 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1264 ASSERT_NE(keyEvent, nullptr);
1265 avservice_->UpdateTopSession(avsessionHere_);
1266 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent);
1267 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1268 avsessionHere_->Destroy();
1269 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1270 SLOGI("SendSystemAVKeyEvent008 end!");
1271 }
1272
1273 static HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent009, TestSize.Level0)
1274 {
1275 SLOGI("SendSystemAVKeyEvent009 begin!");
1276 OHOS::AppExecFwk::ElementName elementName;
1277 elementName.SetBundleName(g_testAnotherBundleName);
1278 elementName.SetAbilityName(g_testAnotherAbilityName);
1279 OHOS::sptr<AVSessionItem> avsessionHere_ =
1280 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1281 auto keyEvent = OHOS::MMI::KeyEvent::Create();
1282 ASSERT_NE(keyEvent, nullptr);
1283 OHOS::AAFwk::Want bluetoothWant;
1284 std::string activeAddress = "00:00:00:00:00:00";
1285 bluetoothWant.SetParam("deviceId", activeAddress);
1286 bool ret = avservice_->SendSystemAVKeyEvent(*keyEvent, bluetoothWant);
1287 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1288 avsessionHere_->Destroy();
1289 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1290 SLOGI("SendSystemAVKeyEvent009 end!");
1291 }
1292
1293 static HWTEST_F(AVSessionServiceTest, PullMigrateStub001, TestSize.Level0)
1294 {
1295 SLOGI("PullMigrateStub001 begin!");
1296 EXPECT_TRUE(avservice_ != nullptr);
1297 avservice_->PullMigrateStub();
1298 SLOGI("PullMigrateStub001 end!");
1299 }
1300
1301 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession003, TestSize.Level0)
1302 {
1303 SLOGI("UpdateFrontSession003 begin!");
1304 EXPECT_TRUE(avservice_ != nullptr);
1305 int32_t pid = 304;
1306 OHOS::AppExecFwk::ElementName elementName;
1307 elementName.SetBundleName(g_testAnotherBundleName);
1308 elementName.SetAbilityName(g_testAnotherAbilityName);
1309 OHOS::sptr<AVSessionItem> avsessionHere_ =
1310 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1311 avsessionHere_->SetUid(pid);
1312 avservice_->UpdateFrontSession(avsessionHere_, true);
1313 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1314 avsessionHere_->Destroy();
1315 SLOGI("UpdateFrontSession003 end!");
1316 }
1317
1318 static HWTEST_F(AVSessionServiceTest, CreateSessionInner001, TestSize.Level0)
1319 {
1320 SLOGI("CreateSessionInner001 begin!");
1321 OHOS::sptr<AVSessionItem> sessionItem = nullptr;
1322 OHOS::AppExecFwk::ElementName elementName;
1323 elementName.SetBundleName("######");
1324 elementName.SetAbilityName(g_testAnotherAbilityName);
1325 int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
1326 false, elementName, sessionItem);
1327 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1328 SLOGI("CreateSessionInner001 end!");
1329 }
1330
1331 static HWTEST_F(AVSessionServiceTest, CreateSessionInner002, TestSize.Level0)
1332 {
1333 SLOGI("CreateSessionInner001 begin!");
1334 OHOS::sptr<AVSessionItem> sessionItem = nullptr;
1335 OHOS::AppExecFwk::ElementName elementName;
1336 elementName.SetBundleName(g_testAnotherBundleName);
1337 elementName.SetAbilityName("######");
1338 int32_t ret = avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
1339 false, elementName, sessionItem);
1340 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1341 SLOGI("CreateSessionInner001 end!");
1342 }
1343
1344 static HWTEST_F(AVSessionServiceTest, ReportSessionInfo001, TestSize.Level0)
1345 {
1346 SLOGI("ReportSessionInfo001 begin!");
1347 EXPECT_TRUE(avservice_ != nullptr);
1348 OHOS::sptr<AVSessionItem> avsessionHere_ = nullptr;
1349 avservice_->ReportSessionInfo(avsessionHere_, true);
1350 SLOGI("ReportSessionInfo001 end!");
1351 }
1352
1353 static HWTEST_F(AVSessionServiceTest, CreateNewControllerForSession001, TestSize.Level0)
1354 {
1355 SLOGI("CreateNewControllerForSession001 begin!");
1356 OHOS::AppExecFwk::ElementName elementName;
1357 elementName.SetBundleName(g_testAnotherBundleName);
1358 elementName.SetAbilityName(g_testAnotherAbilityName);
1359 OHOS::sptr<AVSessionItem> avsessionHere_ =
1360 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1361 pid_t pid = 2222;
1362 auto ret = avservice_->CreateNewControllerForSession(pid, avsessionHere_);
1363 EXPECT_NE(ret, nullptr);
1364 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1365 avsessionHere_->Destroy();
1366 SLOGI("CreateNewControllerForSession001 end!");
1367 }
1368
1369 static HWTEST_F(AVSessionServiceTest, IsHistoricalSession001, TestSize.Level0)
1370 {
1371 SLOGI("IsHistoricalSession001 begin!");
1372 OHOS::AppExecFwk::ElementName elementName;
1373 elementName.SetBundleName(g_testAnotherBundleName);
1374 elementName.SetAbilityName(g_testAnotherAbilityName);
1375 OHOS::sptr<AVSessionItem> avsessionHere_ =
1376 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1377 std::string sessionId = avsessionHere_->GetSessionId();
1378 bool ret = avservice_->IsHistoricalSession(sessionId);
1379 EXPECT_EQ(ret, false);
1380 avservice_->HandleSessionRelease(sessionId);
1381 avsessionHere_->Destroy();
1382 SLOGI("IsHistoricalSession001 end!");
1383 }
1384
1385 static HWTEST_F(AVSessionServiceTest, StartDefaultAbilityByCall001, TestSize.Level0)
1386 {
1387 SLOGI("StartDefaultAbilityByCall001 begin!");
1388 OHOS::AppExecFwk::ElementName elementName;
1389 elementName.SetBundleName(g_testAnotherBundleName);
1390 elementName.SetAbilityName(g_testAnotherAbilityName);
1391 OHOS::sptr<AVSessionItem> avsessionHere_ =
1392 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1393 std::string sessionId = avsessionHere_->GetSessionId();
1394 int32_t ret = avservice_->StartDefaultAbilityByCall(sessionId);
1395 // startability may go with mediaintent, will return AVSESSION_ERROR
1396 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS || ret == AVSESSION_ERROR||
1397 ret == ERR_START_ABILITY_TIMEOUT, true);
1398 avservice_->HandleSessionRelease(sessionId);
1399 avsessionHere_->Destroy();
1400 SLOGI("StartDefaultAbilityByCall001 end!");
1401 }
1402
1403 static HWTEST_F(AVSessionServiceTest, StartAbilityByCall001, TestSize.Level0)
1404 {
1405 SLOGI("StartAbilityByCall001 begin!");
1406 OHOS::AppExecFwk::ElementName elementName;
1407 elementName.SetBundleName(g_testAnotherBundleName);
1408 elementName.SetAbilityName(g_testAnotherAbilityName);
1409 OHOS::sptr<AVSessionItem> avsessionHere_ =
1410 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1411 std::string sessionIdNeeded = "";
1412 std::string sessionId = "";
1413 int32_t ret = avservice_->StartAbilityByCall(sessionIdNeeded, sessionId);
1414 EXPECT_EQ(ret, AVSESSION_ERROR);
1415 avsessionHere_->Destroy();
1416 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1417 SLOGI("StartAbilityByCall001 end!");
1418 }
1419
1420 static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand001, TestSize.Level0)
1421 {
1422 SLOGI("SendSystemControlCommand001 begin!");
1423 OHOS::AppExecFwk::ElementName elementName;
1424 elementName.SetBundleName(g_testAnotherBundleName);
1425 elementName.SetAbilityName(g_testAnotherAbilityName);
1426 OHOS::sptr<AVSessionItem> avsessionHere_ =
1427 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1428 avservice_->UpdateFrontSession(avsessionHere_, true);
1429 AVControlCommand command;
1430 command.SetCommand(1000);
1431 int32_t ret = avservice_->SendSystemControlCommand(command);
1432 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1433 avsessionHere_->Destroy();
1434 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1435 SLOGI("SendSystemControlCommand001 end!");
1436 }
1437
1438 static HWTEST_F(AVSessionServiceTest, HandleControllerRelease001, TestSize.Level0)
1439 {
1440 SLOGI("HandleControllerRelease001 begin!");
1441 EXPECT_TRUE(avservice_ != nullptr);
1442 OHOS::AppExecFwk::ElementName elementName;
1443 elementName.SetBundleName(g_testAnotherBundleName);
1444 elementName.SetAbilityName(g_testAnotherAbilityName);
1445 OHOS::sptr<AVSessionItem> avsessionHere_ =
1446 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1447 OHOS::sptr<AVControllerItem> avcontrollerHere_ =
1448 avservice_->CreateNewControllerForSession(avsessionHere_->GetPid(), avsessionHere_);
1449 avservice_->HandleControllerRelease(*avcontrollerHere_);
1450 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1451 avsessionHere_->Destroy();
1452 SLOGI("HandleControllerRelease001 end!");
1453 }
1454
1455 static HWTEST_F(AVSessionServiceTest, GetDeviceInfo001, TestSize.Level0)
1456 {
1457 SLOGI("GetDeviceInfo001 begin!");
1458 EXPECT_TRUE(avservice_ != nullptr);
1459 OHOS::AppExecFwk::ElementName elementName;
1460 elementName.SetBundleName(g_testAnotherBundleName);
1461 elementName.SetAbilityName(g_testAnotherAbilityName);
1462 OHOS::sptr<AVSessionItem> avsessionHere_ =
1463 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1464 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
1465 avservice_->GetDeviceInfo(avsessionHere_, descriptors, descriptors, descriptors);
1466 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1467 avsessionHere_->Destroy();
1468 SLOGI("GetDeviceInfo001 end!");
1469 }
1470
1471 static HWTEST_F(AVSessionServiceTest, CreateControllerInner001, TestSize.Level0)
1472 {
1473 SLOGI("CreateControllerInner001 begin!");
1474 std::string sessionId = "default";
1475 OHOS::sptr<IRemoteObject> object = nullptr;
1476 int32_t ret = avservice_->CreateControllerInner(sessionId, object);
1477 // startability may go with mediaintent, will return AVSESSION_ERROR
1478 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS
1479 || ret == AVSESSION_ERROR || ret == ERR_SESSION_NOT_EXIST, true);
1480 SLOGI("CreateControllerInner001 end!");
1481 }
1482
1483 static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock001, TestSize.Level0)
1484 {
1485 SLOGI("ClearControllerForClientDiedNoLock001 begin!");
1486 EXPECT_TRUE(avservice_ != nullptr);
1487 OHOS::AppExecFwk::ElementName elementName;
1488 elementName.SetBundleName(g_testAnotherBundleName);
1489 elementName.SetAbilityName(g_testAnotherAbilityName);
1490 OHOS::sptr<AVSessionItem> avsessionHere_ =
1491 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1492 std::string sessionId = avsessionHere_->GetSessionId();
1493 OHOS::sptr<IRemoteObject> object = nullptr;
1494 int32_t ret = avservice_->CreateControllerInner(sessionId, object);
1495 ASSERT_EQ(ret, AVSESSION_SUCCESS);
1496 avservice_->ClearControllerForClientDiedNoLock(avsessionHere_->GetPid());
1497 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1498 avsessionHere_->Destroy();
1499 SLOGI("ClearControllerForClientDiedNoLock001 end!");
1500 }
1501
1502 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx001, TestSize.Level0)
1503 {
1504 SLOGI("LoadStringFromFileEx001 begin!");
1505 OHOS::AppExecFwk::ElementName elementName;
1506 elementName.SetBundleName(g_testAnotherBundleName);
1507 elementName.SetAbilityName(g_testAnotherAbilityName);
1508 OHOS::sptr<AVSessionItem> avsessionHere_ =
1509 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1510 EXPECT_EQ(avsessionHere_ != nullptr, true);
1511
1512 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test1.txt";
1513 std::string content;
1514 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1515 EXPECT_EQ(ret, true);
1516 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1517 avsessionHere_->Destroy();
1518 SLOGI("LoadStringFromFileEx001 end!");
1519 }
1520
1521 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx002, TestSize.Level0)
1522 {
1523 SLOGI("LoadStringFromFileEx002 begin!");
1524 OHOS::AppExecFwk::ElementName elementName;
1525 elementName.SetBundleName(g_testAnotherBundleName);
1526 elementName.SetAbilityName(g_testAnotherAbilityName);
1527 OHOS::sptr<AVSessionItem> avsessionHere_ =
1528 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1529 EXPECT_EQ(avsessionHere_ != nullptr, true);
1530 int32_t maxFileLength = 32 * 1024 * 1024;
1531 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test2.txt";
1532 std::ofstream ofs;
1533 ofs.open(filePath, std::ios::out);
1534 for (int32_t i = 0; i <= maxFileLength; i++) {
1535 ofs << "A";
1536 }
1537 ofs.close();
1538 std::string content;
1539 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1540 EXPECT_EQ(ret, false);
1541 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1542 avsessionHere_->Destroy();
1543 SLOGI("LoadStringFromFileEx002 end!");
1544 }
1545
1546 static HWTEST_F(AVSessionServiceTest, LoadStringFromFileEx003, TestSize.Level0)
1547 {
1548 SLOGI("LoadStringFromFileEx003 begin!");
1549 OHOS::AppExecFwk::ElementName elementName;
1550 elementName.SetBundleName(g_testAnotherBundleName);
1551 elementName.SetAbilityName(g_testAnotherAbilityName);
1552 OHOS::sptr<AVSessionItem> avsessionHere_ =
1553 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1554 EXPECT_EQ(avsessionHere_ != nullptr, true);
1555
1556 std::string filePath = "/test3.txt";
1557 std::string content;
1558 std::ifstream file(filePath, std::ios_base::in);
1559 bool ret = avservice_->LoadStringFromFileEx(filePath, content);
1560 file.close();
1561 EXPECT_EQ(ret, false);
1562 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1563 avsessionHere_->Destroy();
1564 SLOGI("LoadStringFromFileEx003 end!");
1565 }
1566
1567 static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile001, TestSize.Level0)
1568 {
1569 SLOGI("CheckStringAndCleanFile001 begin!");
1570 OHOS::AppExecFwk::ElementName elementName;
1571 elementName.SetBundleName(g_testAnotherBundleName);
1572 elementName.SetAbilityName(g_testAnotherAbilityName);
1573 OHOS::sptr<AVSessionItem> avsessionHere_ =
1574 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1575 EXPECT_EQ(avsessionHere_ != nullptr, true);
1576
1577 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "test6.txt";
1578 bool ret = avservice_->CheckStringAndCleanFile(filePath);
1579 EXPECT_EQ(ret, true);
1580 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1581 avsessionHere_->Destroy();
1582 SLOGI("CheckStringAndCleanFile001 end!");
1583 }
1584
1585 static HWTEST_F(AVSessionServiceTest, CheckStringAndCleanFile002, TestSize.Level0)
1586 {
1587 SLOGI("CheckStringAndCleanFile002 begin!");
1588 OHOS::AppExecFwk::ElementName elementName;
1589 elementName.SetBundleName(g_testAnotherBundleName);
1590 elementName.SetAbilityName(g_testAnotherAbilityName);
1591 OHOS::sptr<AVSessionItem> avsessionHere_ =
1592 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1593 EXPECT_EQ(avsessionHere_ != nullptr, true);
1594
1595 std::string filePath = avservice_->GetUsersManager().GetDirForCurrentUser() + "adcdXYZ123/test7.txt";
1596 std::ifstream file(filePath, std::ios_base::in);
1597 bool ret = avservice_->CheckStringAndCleanFile(filePath);
1598 file.close();
1599 // file not exist for ifstream file can not create file in non-existent folder
1600 EXPECT_EQ(ret, false);
1601 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1602 avsessionHere_->Destroy();
1603 SLOGI("CheckStringAndCleanFile002 end!");
1604 }
1605
1606 static HWTEST_F(AVSessionServiceTest, ReportStartCastEnd001, TestSize.Level0)
1607 {
1608 SLOGI("NotifyDeviceAvailable001 begin!");
1609 OHOS::AppExecFwk::ElementName elementName;
1610 elementName.SetBundleName(g_testAnotherBundleName);
1611 elementName.SetAbilityName(g_testAnotherAbilityName);
1612 OHOS::sptr<AVSessionItem> avsessionHere_ =
1613 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1614 EXPECT_EQ(avsessionHere_ != nullptr, true);
1615 std::string func = "";
1616 int32_t uid = avsessionHere_->GetUid();
1617 int ret = 1;
1618 OutputDeviceInfo outputDeviceInfo;
1619 OHOS::AVSession::DeviceInfo deviceInfo;
1620 deviceInfo.castCategory_ = 1;
1621 deviceInfo.deviceId_ = "deviceId";
1622 avservice_->ReportStartCastEnd(func, outputDeviceInfo, uid, ret);
1623 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1624 avsessionHere_->Destroy();
1625 SLOGI("NotifyDeviceAvailable001 end!");
1626 }
1627
1628 #ifdef BLUETOOTH_ENABLE
1629 static HWTEST_F(AVSessionServiceTest, OnReceiveEvent003, TestSize.Level0)
1630 {
1631 SLOGD("OnReceiveEvent003 begin!");
1632 OHOS::EventFwk::CommonEventData eventData;
1633 string action = OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED;
1634 OHOS::AAFwk::Want want = eventData.GetWant();
1635 want.SetAction(action);
1636 eventData.SetWant(want);
1637 OHOS::EventFwk::MatchingSkills matchingSkills;
1638 OHOS::EventFwk::CommonEventSubscribeInfo subscriberInfo(matchingSkills);
1639 EventSubscriber eventSubscriber(subscriberInfo, avservice_);
1640 eventSubscriber.OnReceiveEvent(eventData);
1641 int32_t ret = action.compare(OHOS::EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED);
1642 EXPECT_EQ(ret, 0);
1643 SLOGD("OnReceiveEvent003 end!");
1644 }
1645
1646 static HWTEST_F(AVSessionServiceTest, UpdateFrontSession004, TestSize.Level0)
1647 {
1648 SLOGD("UpdateFrontSession004 begin!");
1649 OHOS::AppExecFwk::ElementName elementName;
1650 elementName.SetBundleName(g_testAnotherBundleName);
1651 elementName.SetAbilityName(g_testAnotherAbilityName);
1652 OHOS::sptr<AVSessionItem> avsessionHere =
1653 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1654 EXPECT_EQ(avsessionHere != nullptr, true);
1655 avservice_->UpdateTopSession(avsessionHere);
1656 avservice_->UpdateFrontSession(avsessionHere, false);
1657 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1658 avsessionHere->Destroy();
1659 SLOGD("UpdateFrontSession004 end!");
1660 }
1661
1662 static HWTEST_F(AVSessionServiceTest, CheckAncoAudio001, TestSize.Level0)
1663 {
1664 SLOGD("CheckAncoAudio001 begin!");
1665 OHOS::AppExecFwk::ElementName elementName;
1666 elementName.SetBundleName(g_testAnotherBundleName);
1667 elementName.SetAbilityName(g_testAnotherAbilityName);
1668 OHOS::sptr<AVSessionItem> avsessionHere =
1669 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1670 bool ret = avservice_->CheckAncoAudio();
1671 EXPECT_EQ(ret, false);
1672 avsessionHere->Destroy();
1673 SLOGD("CheckAncoAudio001 end!");
1674 }
1675
1676 static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand002, TestSize.Level0)
1677 {
1678 SLOGD("SendSystemControlCommand002 begin!");
1679 OHOS::AppExecFwk::ElementName elementName;
1680 elementName.SetBundleName(g_testAnotherBundleName);
1681 elementName.SetAbilityName(g_testAnotherAbilityName);
1682 OHOS::sptr<AVSessionItem> avsessionHere =
1683 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1684 avservice_->UpdateTopSession(avsessionHere);
1685 AVControlCommand command;
1686 command.SetCommand(1000);
1687 int32_t ret = avservice_->SendSystemControlCommand(command);
1688 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1689 avsessionHere->Destroy();
1690 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1691 SLOGD("SendSystemControlCommand002 end!");
1692 }
1693
1694 /**
1695 * @tc.name: SendSystemControlCommand003
1696 * @tc.desc: Verifying the SendSystemControlCommand method with valid parameters.
1697 * @tc.type: FUNC
1698 * @tc.require: #I5Y4MZ
1699 */
1700 static HWTEST_F(AVSessionServiceTest, SendSystemControlCommand003, TestSize.Level0)
1701 {
1702 SLOGI("SendSystemControlCommand003 begin!");
1703 ASSERT_TRUE(avservice_ != nullptr);
1704 std::vector<int> tempAudioPlayingUids {1, 2};
1705 OHOS::AppExecFwk::ElementName elementName;
1706 elementName.SetBundleName(g_testAnotherBundleName);
1707 elementName.SetAbilityName(g_testAnotherAbilityName);
1708 OHOS::sptr<AVSessionItem> avsessionHere =
1709 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1710 ASSERT_TRUE(avsessionHere != nullptr);
1711 tempAudioPlayingUids.push_back(avsessionHere->GetUid());
1712 avservice_->focusSessionStrategy_.SetAudioPlayingUids(tempAudioPlayingUids);
1713
1714 AVControlCommand command;
1715 command.SetCommand(1000);
1716 int32_t ret = avservice_->SendSystemControlCommand(command);
1717 EXPECT_EQ(ret, AVSESSION_SUCCESS);
1718 avservice_->HandleSessionRelease(avsessionHere->GetSessionId());
1719 avsessionHere->Destroy();
1720 SLOGI("SendSystemControlCommand003 end!");
1721 }
1722
1723 static HWTEST_F(AVSessionServiceTest, CreateWantAgent001, TestSize.Level0)
1724 {
1725 SLOGD("CreateWantAgent001 begin!");
1726 std::shared_ptr<AVSessionDescriptor> histroyDescriptor(nullptr);
1727 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1728 EXPECT_EQ(ret, nullptr);
1729 SLOGD("CreateWantAgent001 end!");
1730 }
1731
1732 static HWTEST_F(AVSessionServiceTest, CreateWantAgent002, TestSize.Level0)
1733 {
1734 SLOGD("CreateWantAgent001 begin!");
1735 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1736 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1737 EXPECT_EQ(ret, nullptr);
1738 SLOGD("CreateWantAgent001 end!");
1739 }
1740
1741 static HWTEST_F(AVSessionServiceTest, CreateWantAgent003, TestSize.Level0)
1742 {
1743 SLOGD("CreateWantAgent003 begin!");
1744 OHOS::AppExecFwk::ElementName elementName;
1745 elementName.SetBundleName(g_testAnotherBundleName);
1746 elementName.SetAbilityName(g_testAnotherAbilityName);
1747 OHOS::sptr<AVSessionItem> avsessionHere =
1748 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1749 avservice_->UpdateTopSession(avsessionHere);
1750 std::shared_ptr<AVSessionDescriptor> histroyDescriptor(nullptr);
1751 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1752 avsessionHere->Destroy();
1753 EXPECT_EQ(ret, nullptr);
1754 SLOGD("CreateWantAgent003 end!");
1755 }
1756
1757 static HWTEST_F(AVSessionServiceTest, CreateWantAgent004, TestSize.Level0)
1758 {
1759 SLOGD("CreateWantAgent004 begin!");
1760 OHOS::AppExecFwk::ElementName elementName;
1761 elementName.SetBundleName(g_testAnotherBundleName);
1762 elementName.SetAbilityName(g_testAnotherAbilityName);
1763 OHOS::sptr<AVSessionItem> avsessionHere =
1764 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1765 avservice_->UpdateTopSession(avsessionHere);
1766 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
1767 auto ret = avservice_->CreateWantAgent(histroyDescriptor.get());
1768 avsessionHere->Destroy();
1769 EXPECT_EQ(ret, nullptr);
1770 SLOGD("CreateWantAgent004 end!");
1771 }
1772 #endif
1773
1774 /**
1775 * @tc.name: UpdateOrder001
1776 * @tc.desc: Verifying the UpdateOrder.
1777 * @tc.type: FUNC
1778 * @tc.require: #I5Y4MZ
1779 */
1780 static HWTEST_F(AVSessionServiceTest, UpdateOrder001, TestSize.Level1)
1781 {
1782 SLOGI("UpdateOrder001 begin!");
1783 OHOS::AppExecFwk::ElementName elementName;
1784 elementName.SetBundleName(g_testAnotherBundleName);
1785 elementName.SetAbilityName(g_testAnotherAbilityName);
1786 OHOS::sptr<AVSessionItem> avsessionHere_ =
1787 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1788 bool ret = avservice_->UpdateOrder(avsessionHere_);
1789 EXPECT_EQ(ret, true);
1790 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1791 avsessionHere_->Destroy();
1792 SLOGI("UpdateOrder001 end!");
1793 }
1794
1795 /**
1796 * @tc.name: UpdateOrder002
1797 * @tc.desc: Verifying the UpdateOrder.
1798 * @tc.type: FUNC
1799 * @tc.require: #I5Y4MZ
1800 */
1801 static HWTEST_F(AVSessionServiceTest, UpdateOrder002, TestSize.Level1)
1802 {
1803 SLOGI("UpdateOrder002 begin!");
1804 OHOS::AppExecFwk::ElementName elementName;
1805 elementName.SetBundleName(g_testAnotherBundleName);
1806 elementName.SetAbilityName(g_testAnotherAbilityName);
1807 OHOS::sptr<AVSessionItem> avsessionHere_ =
1808 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1809 avservice_->UpdateFrontSession(avsessionHere_, true);
1810 bool ret = avservice_->UpdateOrder(avsessionHere_);
1811 EXPECT_EQ(ret, true);
1812 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1813 avsessionHere_->Destroy();
1814 SLOGI("UpdateOrder002 end!");
1815 }
1816
1817 /**
1818 * @tc.name: HandleOtherSessionPlaying001
1819 * @tc.desc: Verifying the HandleOtherSessionPlaying.
1820 * @tc.type: FUNC
1821 * @tc.require: #I5Y4MZ
1822 */
1823 static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying001, TestSize.Level1)
1824 {
1825 SLOGI("HandleOtherSessionPlaying001 begin!");
1826 OHOS::AppExecFwk::ElementName elementName;
1827 elementName.SetBundleName(g_testAnotherBundleName);
1828 elementName.SetAbilityName(g_testAnotherAbilityName);
1829 OHOS::sptr<AVSessionItem> avsessionHere_ =
1830 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1831 avservice_->HandleOtherSessionPlaying(avsessionHere_);
1832 EXPECT_EQ(avsessionHere_ != nullptr, true);
1833 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1834 avsessionHere_->Destroy();
1835 SLOGI("HandleOtherSessionPlaying001 end!");
1836 }
1837
1838 /**
1839 * @tc.name: HandleOtherSessionPlaying002
1840 * @tc.desc: Verifying the HandleOtherSessionPlaying.
1841 * @tc.type: FUNC
1842 * @tc.require: #I5Y4MZ
1843 */
1844 static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying002, TestSize.Level1)
1845 {
1846 SLOGI("HandleOtherSessionPlaying002 begin!");
1847 OHOS::AppExecFwk::ElementName elementName;
1848 elementName.SetBundleName(g_testAnotherBundleName);
1849 elementName.SetAbilityName(g_testAnotherAbilityName);
1850 OHOS::sptr<AVSessionItem> avsessionHere_ =
1851 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1852 int32_t ancoUid = 1041;
1853 avsessionHere_->SetUid(ancoUid);
1854 avservice_->HandleOtherSessionPlaying(avsessionHere_);
1855 bool check = avsessionHere_->GetUid() == ancoUid;
1856 EXPECT_EQ(check, true);
1857 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1858 avsessionHere_->Destroy();
1859 SLOGI("HandleOtherSessionPlaying002 end!");
1860 }
1861
1862 /**
1863 * @tc.name: HandleOtherSessionPlaying003
1864 * @tc.desc: Verifying the HandleOtherSessionPlaying.
1865 * @tc.type: FUNC
1866 * @tc.require: #I5Y4MZ
1867 */
1868 static HWTEST_F(AVSessionServiceTest, HandleOtherSessionPlaying003, TestSize.Level1)
1869 {
1870 SLOGI("HandleOtherSessionPlaying003 begin!");
1871 OHOS::AppExecFwk::ElementName elementName;
1872 elementName.SetBundleName(g_testAnotherBundleName);
1873 elementName.SetAbilityName(g_testAnotherAbilityName);
1874 OHOS::sptr<AVSessionItem> avsessionHere_ =
1875 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
1876 avservice_->HandleOtherSessionPlaying(avsessionHere_);
1877 EXPECT_EQ(avsessionHere_ != nullptr, true);
1878 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1879 avsessionHere_->Destroy();
1880 SLOGI("HandleOtherSessionPlaying003 end!");
1881 }
1882
1883 /**
1884 * @tc.name: GetOtherPlayingSession001
1885 * @tc.desc: Verifying the GetOtherPlayingSession.
1886 * @tc.type: FUNC
1887 * @tc.require: #I5Y4MZ
1888 */
1889 static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession001, TestSize.Level1)
1890 {
1891 SLOGI("GetOtherPlayingSession001 begin!");
1892 OHOS::AppExecFwk::ElementName elementName;
1893 elementName.SetBundleName(g_testAnotherBundleName);
1894 elementName.SetAbilityName(g_testAnotherAbilityName);
1895 OHOS::sptr<AVSessionItem> avsessionHere_ =
1896 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1897 std::string bundleName = "test";
1898 int32_t userId = 0;
1899 bool ret = avservice_->GetOtherPlayingSession(userId, bundleName) == nullptr;
1900 EXPECT_EQ(ret, true);
1901 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1902 avsessionHere_->Destroy();
1903 SLOGI("GetOtherPlayingSession001 end!");
1904 }
1905
1906 /**
1907 * @tc.name: GetOtherPlayingSession002
1908 * @tc.desc: Verifying the GetOtherPlayingSession.
1909 * @tc.type: FUNC
1910 * @tc.require: #I5Y4MZ
1911 */
1912 static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession002, TestSize.Level1)
1913 {
1914 SLOGI("GetOtherPlayingSession002 begin!");
1915 int32_t userId = 0;
1916 static char gTestFrontBundleName[] = "testFront.ohos.avsession";
1917 OHOS::AppExecFwk::ElementName elementName;
1918 elementName.SetBundleName(g_testAnotherBundleName);
1919 elementName.SetAbilityName(g_testAnotherAbilityName);
1920 OHOS::sptr<AVSessionItem> avsessionFront_ =
1921 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1922 avservice_->UpdateFrontSession(avsessionFront_, true);
1923 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
1924 avsessionFront_->SetAVPlaybackState(g_playbackState);
1925 bool ret = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName) == nullptr;
1926 EXPECT_EQ(ret, true);
1927 avservice_->HandleSessionRelease(avsessionFront_->GetSessionId());
1928 avsessionFront_->Destroy();
1929 SLOGI("GetOtherPlayingSession002 end!");
1930 }
1931
1932 /**
1933 * @tc.name: GetOtherPlayingSession003
1934 * @tc.desc: Verifying the GetOtherPlayingSession.
1935 * @tc.type: FUNC
1936 * @tc.require: #I5Y4MZ
1937 */
1938 static HWTEST_F(AVSessionServiceTest, GetOtherPlayingSession003, TestSize.Level1)
1939 {
1940 SLOGI("GetOtherPlayingSession003 begin!");
1941 int32_t userId = 0;
1942 static char gTestFrontBundleName[] = "testFront.ohos.avsession";
1943 OHOS::AppExecFwk::ElementName elementName;
1944 elementName.SetBundleName(g_testAnotherBundleName);
1945 elementName.SetAbilityName(g_testAnotherAbilityName);
1946 OHOS::sptr<AVSessionItem> avsessionFront_ =
1947 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1948 avservice_->UpdateFrontSession(avsessionFront_, true);
1949 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
1950 avsessionFront_->SetAVPlaybackState(g_playbackState);
1951 avsessionFront_->castHandle_ = 1;
1952 bool ret = avservice_->GetOtherPlayingSession(userId, gTestFrontBundleName) == nullptr;
1953 EXPECT_EQ(ret, true);
1954 avservice_->HandleSessionRelease(avsessionFront_->GetSessionId());
1955 avsessionFront_->Destroy();
1956 SLOGI("GetOtherPlayingSession003 end!");
1957 }
1958
1959 /**
1960 * @tc.name: OnIdleWithSessions001
1961 * @tc.desc: Verifying the OnIdle method with a valid idle reason.
1962 * @tc.type: FUNC
1963 * @tc.require: #I5Y4MZ
1964 */
1965 static HWTEST_F(AVSessionServiceTest, OnIdleWithSessions001, TestSize.Level0)
1966 {
1967 SLOGD("OnIdleWithSessions001 begin!");
1968 const OHOS::SystemAbilityOnDemandReason idleReason(
1969 OHOS::OnDemandReasonId::INTERFACE_CALL, "INTERFACE_CALL", "TestValue", 12345);
1970 int32_t result = avservice_->OnIdle(idleReason);
1971 EXPECT_EQ(result, 0);
1972 SLOGD("OnIdleWithSessions001 end!");
1973 }
1974
1975 /**
1976 * @tc.name: CheckAndUpdateAncoMediaSession001
1977 * @tc.desc: update anco media session without anco uid.
1978 * @tc.type: FUNC
1979 * @tc.require: #I5Y4MZ
1980 */
1981 static HWTEST_F(AVSessionServiceTest, CheckAndUpdateAncoMediaSession001, TestSize.Level1)
1982 {
1983 SLOGD("CheckAndUpdateAncoMediaSession001 begin!");
1984 EXPECT_TRUE(avservice_ != nullptr);
1985 OHOS::AppExecFwk::ElementName elementName;
1986 elementName.SetBundleName(g_testAnotherBundleName);
1987 elementName.SetAbilityName(g_testAnotherAbilityName);
1988 OHOS::sptr<AVSessionItem> avsessionHere_ =
1989 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1990 EXPECT_EQ(avsessionHere_ != nullptr, true);
1991 OHOS::AppExecFwk::ElementName newElementName;
1992 newElementName.SetBundleName("bundleName");
1993 newElementName.SetAbilityName("AbilityName");
1994 avservice_->CheckAndUpdateAncoMediaSession(newElementName);
1995 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
1996 avsessionHere_->Destroy();
1997 SLOGD("CheckAndUpdateAncoMediaSession001 end!");
1998 }
1999
2000 /**
2001 * @tc.name: CheckSessionHandleKeyEvent001
2002 * @tc.desc: check which session handle key event.
2003 * @tc.type: FUNC
2004 * @tc.require: #I5Y4MZ
2005 */
2006 static HWTEST_F(AVSessionServiceTest, CheckSessionHandleKeyEvent001, TestSize.Level1)
2007 {
2008 SLOGD("CheckSessionHandleKeyEvent001 begin!");
2009 ASSERT_TRUE(avservice_ != nullptr);
2010 OHOS::AppExecFwk::ElementName elementName;
2011 elementName.SetBundleName(g_testAnotherBundleName);
2012 elementName.SetAbilityName(g_testAnotherAbilityName);
2013 OHOS::sptr<AVSessionItem> avsessionHere_ =
2014 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2015 EXPECT_NE(avsessionHere_, nullptr);
2016 AVControlCommand cmd;
2017 cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
2018 auto keyEvent = OHOS::MMI::KeyEvent::Create();
2019 ASSERT_NE(keyEvent, nullptr);
2020 auto ret = avservice_->CheckSessionHandleKeyEvent(true, cmd, *keyEvent, avsessionHere_);
2021 EXPECT_EQ(ret, true);
2022 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
2023 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
2024 ret = avservice_->CheckSessionHandleKeyEvent(false, cmd, *keyEvent, avsessionHere_);
2025 EXPECT_EQ(ret, true);
2026 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
2027 avsessionHere_->Destroy();
2028 SLOGD("CheckSessionHandleKeyEvent001 end!");
2029 }
2030
2031 /**
2032 * @tc.name: CheckSessionHandleKeyEvent002
2033 * @tc.desc: check which session handle key event.
2034 * @tc.type: FUNC
2035 * @tc.require: #I5Y4MZ
2036 */
2037 static HWTEST_F(AVSessionServiceTest, CheckSessionHandleKeyEvent002, TestSize.Level1)
2038 {
2039 SLOGD("CheckSessionHandleKeyEvent002 begin!");
2040 ASSERT_TRUE(avservice_ != nullptr);
2041 OHOS::AppExecFwk::ElementName elementName;
2042 elementName.SetBundleName(g_testAnotherBundleName);
2043 elementName.SetAbilityName(g_testAnotherAbilityName);
2044 OHOS::sptr<AVSessionItem> avsessionHere_ =
2045 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2046 EXPECT_NE(avsessionHere_, nullptr);
2047 FocusSessionStrategy::FocusSessionChangeInfo info;
2048 info.uid = 1041;
2049 info.pid = 1041;
2050 avservice_->HandleFocusSession(info, true);
2051 AVControlCommand cmd;
2052 cmd.SetCommand(AVControlCommand::SESSION_CMD_PLAY);
2053 auto keyEvent = OHOS::MMI::KeyEvent::Create();
2054 ASSERT_NE(keyEvent, nullptr);
2055 auto ret = avservice_->CheckSessionHandleKeyEvent(true, cmd, *keyEvent, avsessionHere_);
2056 EXPECT_EQ(ret, true);
2057 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_MEDIA_PLAY);
2058 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
2059 ret = avservice_->CheckSessionHandleKeyEvent(false, cmd, *keyEvent, avsessionHere_);
2060 EXPECT_EQ(ret, true);
2061 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
2062 avsessionHere_->Destroy();
2063 SLOGD("CheckSessionHandleKeyEvent002 end!");
2064 }
2065
2066 /**
2067 * @tc.name: UpdateSessionTimestamp001
2068 * @tc.desc: update timestamp for session item.
2069 * @tc.type: FUNC
2070 * @tc.require: #I5Y4MZ
2071 */
2072 static HWTEST_F(AVSessionServiceTest, UpdateSessionTimestamp001, TestSize.Level1)
2073 {
2074 SLOGD("UpdateSessionTimestamp001 begin!");
2075 EXPECT_TRUE(avservice_ != nullptr);
2076 OHOS::AppExecFwk::ElementName elementName;
2077 elementName.SetBundleName(g_testAnotherBundleName);
2078 elementName.SetAbilityName(g_testAnotherAbilityName);
2079 OHOS::sptr<AVSessionItem> avsessionHere_ =
2080 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2081 EXPECT_EQ(avsessionHere_ != nullptr, true);
2082 avservice_->UpdateSessionTimestamp(avsessionHere_);
2083 EXPECT_NE(avsessionHere_->GetPlayingTime(), 0);
2084 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
2085 avsessionHere_->Destroy();
2086 SLOGD("UpdateSessionTimestamp001 end!");
2087 }
2088
2089 /**
2090 * @tc.name: GetLocalTitle001
2091 * @tc.desc: get local title.
2092 * @tc.type: FUNC
2093 * @tc.require: #I5Y4MZ
2094 */
2095 static HWTEST_F(AVSessionServiceTest, GetLocalTitle001, TestSize.Level1)
2096 {
2097 SLOGD("GetLocalTitle001 begin!");
2098 ASSERT_TRUE(avservice_ != nullptr);
2099 OHOS::AppExecFwk::ElementName elementName;
2100 elementName.SetBundleName(g_testAnotherBundleName);
2101 elementName.SetAbilityName(g_testAnotherAbilityName);
2102 OHOS::sptr<AVSessionItem> avsessionHere_ =
2103 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2104 EXPECT_NE(avsessionHere_, nullptr);
2105 avservice_->UpdateTopSession(avsessionHere_);
2106 EXPECT_NE(avservice_->topSession_, nullptr);
2107 AVMetaData metadata;
2108 metadata.SetAssetId("mediaId");
2109 metadata.SetDescription("title;artist");
2110 avsessionHere_->SetAVMetaData(g_metaData);
2111 std::string songName = avservice_->GetLocalTitle();
2112 EXPECT_EQ(songName, "title");
2113 avsessionHere_->Destroy();
2114 SLOGD("GetLocalTitle001 end!");
2115 }
2116
2117 /**
2118 * @tc.name: GetLocalTitle002
2119 * @tc.desc: get local title.
2120 * @tc.type: FUNC
2121 * @tc.require: #I5Y4MZ
2122 */
2123 static HWTEST_F(AVSessionServiceTest, GetLocalTitle002, TestSize.Level1)
2124 {
2125 SLOGD("GetLocalTitle002 begin!");
2126 ASSERT_TRUE(avservice_ != nullptr);
2127 OHOS::AppExecFwk::ElementName elementName;
2128 elementName.SetBundleName(g_testAnotherBundleName);
2129 elementName.SetAbilityName(g_testAnotherAbilityName);
2130 OHOS::sptr<AVSessionItem> avsessionHere_ =
2131 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2132 EXPECT_NE(avsessionHere_, nullptr);
2133 avservice_->UpdateTopSession(avsessionHere_);
2134 EXPECT_NE(avservice_->topSession_, nullptr);
2135 avsessionHere_->SetUid(5557);
2136 AVMetaData metadata;
2137 metadata.SetAssetId("mediaId");
2138 metadata.SetDescription("title-artist");
2139 avsessionHere_->SetAVMetaData(g_metaData);
2140 std::string songName = avservice_->GetLocalTitle();
2141 EXPECT_EQ(songName, "title");
2142 avsessionHere_->Destroy();
2143 SLOGD("GetLocalTitle002 end!");
2144 }
2145
2146 /**
2147 * @tc.name: HandleRemoveMediaCardEvent001
2148 * @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a valid session.
2149 * @tc.type: FUNC
2150 * @tc.require: #I5Y4MZ
2151 */
2152 static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent001, TestSize.Level0)
2153 {
2154 SLOGD("HandleRemoveMediaCardEvent001 begin!");
2155 const int32_t uid = 5557;
2156 OHOS::AppExecFwk::ElementName elementName;
2157 elementName.SetBundleName(g_testAnotherBundleName);
2158 elementName.SetAbilityName(g_testAnotherAbilityName);
2159 OHOS::sptr<AVSessionItem> avsessionHere_ =
2160 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2161 EXPECT_NE(avsessionHere_, nullptr);
2162 avservice_->UpdateTopSession(avsessionHere_);
2163 EXPECT_NE(avservice_->topSession_, nullptr);
2164 avsessionHere_->SetUid(uid);
2165 AVPlaybackState playbackState;
2166 playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
2167 avservice_->HandleRemoveMediaCardEvent();
2168 playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
2169 avservice_->HandleRemoveMediaCardEvent();
2170 avservice_->HandleSessionRelease(avsessionHere_->GetSessionId());
2171 avsessionHere_->Destroy();
2172 EXPECT_EQ(avservice_->topSession_, nullptr);
2173 SLOGD("HandleRemoveMediaCardEvent001 end!");
2174 }
2175
2176 /**
2177 * @tc.name: HandleRemoveMediaCardEvent002
2178 * @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a valid session.
2179 * @tc.type: FUNC
2180 * @tc.require: #I5Y4MZ
2181 */
2182 static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent002, TestSize.Level0)
2183 {
2184 SLOGD("HandleRemoveMediaCardEvent002 begin!");
2185 OHOS::AppExecFwk::ElementName elementName;
2186 elementName.SetBundleName(g_testAnotherBundleName);
2187 elementName.SetAbilityName(g_testAnotherAbilityName);
2188 avservice_->topSession_ =
2189 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2190 bool ret = avservice_->topSession_->IsCasting();
2191 avservice_->HandleRemoveMediaCardEvent();
2192 EXPECT_EQ(ret, false);
2193 SLOGD("HandleRemoveMediaCardEvent002 end!");
2194 }
2195
2196 /**
2197 * @tc.name: HandleRemoveMediaCardEvent003
2198 * @tc.desc: Verifying the HandleRemoveMediaCardEvent method with a null session.
2199 * @tc.type: FUNC
2200 * @tc.require: #I5Y4MZ
2201 */
2202 static HWTEST_F(AVSessionServiceTest, HandleRemoveMediaCardEvent003, TestSize.Level0)
2203 {
2204 SLOGD("HandleRemoveMediaCardEvent003 begin!");
2205 avservice_->topSession_ = nullptr;
2206 avservice_->HandleRemoveMediaCardEvent();
2207 EXPECT_EQ(avservice_->topSession_, nullptr);
2208 SLOGD("HandleRemoveMediaCardEvent003 end!");
2209 }
2210
2211 /**
2212 * @tc.name: IsTopSessionPlaying001
2213 * @tc.desc: Verifying the IsTopSessionPlaying method with a null top session.
2214 * @tc.type: FUNC
2215 * @tc.require: #I5Y4MZ
2216 */
2217 static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying001, TestSize.Level0)
2218 {
2219 SLOGD("IsTopSessionPlaying001 begin!");
2220 avservice_->topSession_ = nullptr;
2221 bool ret = avservice_->IsTopSessionPlaying();
2222 EXPECT_EQ(ret, false);
2223 SLOGD("IsTopSessionPlaying001 end!");
2224 }
2225
2226 /**
2227 * @tc.name: IsTopSessionPlaying002
2228 * @tc.desc: Verifying the IsTopSessionPlaying method with a valid top session.
2229 * @tc.type: FUNC
2230 * @tc.require: #I5Y4MZ
2231 */
2232 static HWTEST_F(AVSessionServiceTest, IsTopSessionPlaying002, TestSize.Level0)
2233 {
2234 SLOGD("IsTopSessionPlaying002 begin!");
2235 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2236 avservice_->topSession_ = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2237 EXPECT_NE(avservice_->topSession_, nullptr);
2238 bool ret = avservice_->IsTopSessionPlaying();
2239 EXPECT_EQ(ret, false);
2240 SLOGD("IsTopSessionPlaying002 end!");
2241 }
2242
2243 /**
2244 * @tc.name: HandleMediaCardStateChangeEvent001
2245 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "APPEAR" state.
2246 * @tc.type: FUNC
2247 * @tc.require: #I5Y4MZ
2248 */
2249 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent001, TestSize.Level0)
2250 {
2251 SLOGD("HandleMediaCardStateChangeEvent001 begin!");
2252 std::string isAppear = "APPEAR";
2253 avservice_->HandleMediaCardStateChangeEvent(isAppear);
2254 EXPECT_NE(avservice_->topSession_, nullptr);
2255 SLOGD("HandleMediaCardStateChangeEvent001 end!");
2256 }
2257
2258 /**
2259 * @tc.name: HandleMediaCardStateChangeEvent002
2260 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with "DISAPPEAR" state.
2261 * @tc.type: FUNC
2262 * @tc.require: #I5Y4MZ
2263 */
2264 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent002, TestSize.Level0)
2265 {
2266 SLOGD("HandleMediaCardStateChangeEvent002 begin!");
2267 std::string isAppear = "DISAPPEAR";
2268 avservice_->HandleMediaCardStateChangeEvent(isAppear);
2269 EXPECT_NE(avservice_->topSession_, nullptr);
2270 SLOGD("HandleMediaCardStateChangeEvent002 end!");
2271 }
2272
2273 /**
2274 * @tc.name: HandleMediaCardStateChangeEvent003
2275 * @tc.desc: Verifying the HandleMediaCardStateChangeEvent method with an invalid state.
2276 * @tc.type: FUNC
2277 * @tc.require: #I5Y4MZ
2278 */
2279 static HWTEST_F(AVSessionServiceTest, HandleMediaCardStateChangeEvent003, TestSize.Level0)
2280 {
2281 SLOGD("HandleMediaCardStateChangeEvent003 begin!");
2282 std::string isAppear = "ISDISAPPEAR";
2283 avservice_->HandleMediaCardStateChangeEvent(isAppear);
2284 EXPECT_NE(avservice_->topSession_, nullptr);
2285 SLOGD("HandleMediaCardStateChangeEvent003 end!");
2286 }
2287
2288 /**
2289 * @tc.name: OnAddSystemAbility001
2290 * @tc.desc: Verifying the OnAddSystemAbility method with valid system ability ID and device ID.
2291 * @tc.type: FUNC
2292 * @tc.require: #I5Y4MZ
2293 */
2294 static HWTEST_F(AVSessionServiceTest, OnAddSystemAbility001, TestSize.Level0)
2295 {
2296 SLOGD("OnAddSystemAbility001 begin!");
2297 int32_t systemAbilityId = OHOS::XPOWER_MANAGER_SYSTEM_ABILITY_ID;
2298 const std::string deviceId = "AUDIO";
2299 avservice_->OnAddSystemAbility(systemAbilityId, deviceId);
2300 EXPECT_NE(avservice_->topSession_, nullptr);
2301 SLOGD("OnAddSystemAbility001 end!");
2302 }
2303
2304 /**
2305 * @tc.name: UpdateTopSession001
2306 * @tc.desc: Verifying the UpdateTopSession method with a valid new top session.
2307 * @tc.type: FUNC
2308 * @tc.require: #I5Y4MZ
2309 */
2310 static HWTEST_F(AVSessionServiceTest, UpdateTopSession001, TestSize.Level0)
2311 {
2312 SLOGD("UpdateTopSession001 begin!");
2313 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2314 const OHOS::sptr<AVSessionItem> newTopSession = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2315 avservice_->UpdateTopSession(newTopSession);
2316 EXPECT_NE(avservice_->topSession_, nullptr);
2317 SLOGD("UpdateTopSession001 end!");
2318 }
2319
2320 /**
2321 * @tc.name: LowQualityCheck001
2322 * @tc.desc: Verifying the LowQualityCheck method with valid parameters.
2323 * @tc.type: FUNC
2324 * @tc.require: #I5Y4MZ
2325 */
2326 static HWTEST_F(AVSessionServiceTest, LowQualityCheck001, TestSize.Level0)
2327 {
2328 SLOGD("LowQualityCheck001 begin!");
2329 int32_t uid = g_playOnCall;
2330 int32_t pid = g_pauseOnCall;
2331 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
2332 RendererState rendererState = RendererState::RENDERER_PAUSED;
2333 avservice_->LowQualityCheck(uid, pid, streamUsage, rendererState);
2334 EXPECT_NE(avservice_->topSession_, nullptr);
2335 SLOGD("LowQualityCheck001 end!");
2336 }
2337
2338 /**
2339 * @tc.name: PlayStateCheck001
2340 * @tc.desc: Verifying the PlayStateCheck method with valid parameters.
2341 * @tc.type: FUNC
2342 * @tc.require: #I5Y4MZ
2343 */
2344 static HWTEST_F(AVSessionServiceTest, PlayStateCheck001, TestSize.Level0)
2345 {
2346 SLOGD("PlayStateCheck001 begin!");
2347 int32_t uid = AVSESSION_ERROR_BASE;
2348 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
2349 RendererState rendererState = RendererState::RENDERER_PAUSED;
2350 avservice_->PlayStateCheck(uid, streamUsage, rendererState);
2351 EXPECT_NE(avservice_->topSession_, nullptr);
2352 SLOGD("PlayStateCheck001 end!");
2353 }
2354
2355 /**
2356 * @tc.name: NotifyBackgroundReportCheck001
2357 * @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_RUNNING state.
2358 * @tc.type: FUNC
2359 * @tc.require: #I5Y4MZ
2360 */
2361 static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck001, TestSize.Level0)
2362 {
2363 SLOGD("NotifyBackgroundReportCheck001 begin!");
2364 int32_t uid = g_playOnCall;
2365 int32_t pid = g_pauseOnCall;
2366 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
2367 RendererState rendererState = RendererState::RENDERER_RUNNING;
2368 avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
2369 EXPECT_NE(avservice_->topSession_, nullptr);
2370 SLOGD("NotifyBackgroundReportCheck001 end!");
2371 }
2372
2373 /**
2374 * @tc.name: NotifyBackgroundReportCheck002
2375 * @tc.desc: Verifying NotifyBackgroundReportCheck with RENDERER_PAUSED state.
2376 * @tc.type: FUNC
2377 * @tc.require: #I5Y4MZ
2378 */
2379 static HWTEST_F(AVSessionServiceTest, NotifyBackgroundReportCheck002, TestSize.Level0)
2380 {
2381 SLOGD("NotifyBackgroundReportCheck002 begin!");
2382 int32_t uid = g_playOnCall;
2383 int32_t pid = g_pauseOnCall;
2384 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
2385 RendererState rendererState = RendererState::RENDERER_PAUSED;
2386 avservice_->NotifyBackgroundReportCheck(uid, pid, streamUsage, rendererState);
2387 EXPECT_NE(avservice_->topSession_, nullptr);
2388 SLOGD("NotifyBackgroundReportCheck002 end!");
2389 }
2390
2391 /**
2392 * @tc.name: ServiceCallback001
2393 * @tc.desc: Verifying ServiceCallback with a null session item.
2394 * @tc.type: FUNC
2395 * @tc.require: #I5Y4MZ
2396 */
2397 static HWTEST_F(AVSessionServiceTest, ServiceCallback001, TestSize.Level0)
2398 {
2399 SLOGD("ServiceCallback001 begin!");
2400 OHOS::AppExecFwk::ElementName elementName;
2401 elementName.SetBundleName(g_testAnotherBundleName);
2402 elementName.SetAbilityName(g_testAnotherAbilityName);
2403 auto sessionItem =
2404 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2405 EXPECT_EQ(sessionItem, nullptr);
2406 avservice_->ServiceCallback(sessionItem);
2407 SLOGD("ServiceCallback001 end!");
2408 }
2409
2410 /**
2411 * @tc.name: IsParamInvalid001
2412 * @tc.desc: Verifying IsParamInvalid with an empty tag.
2413 * @tc.type: FUNC
2414 * @tc.require: #I5Y4MZ
2415 */
2416 static HWTEST_F(AVSessionServiceTest, IsParamInvalid001, TestSize.Level0)
2417 {
2418 SLOGD("IsParamInvalid001 begin!");
2419 std::string tag = "";
2420 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2421 OHOS::AppExecFwk::ElementName elementName;
2422 elementName.SetBundleName(g_testAnotherBundleName);
2423 elementName.SetAbilityName(g_testAnotherAbilityName);
2424 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2425 EXPECT_FALSE(result);
2426 SLOGD("IsParamInvalid001 end!");
2427 }
2428
2429 /**
2430 * @tc.name: IsParamInvalid002
2431 * @tc.desc: Verifying IsParamInvalid with an invalid session type.
2432 * @tc.type: FUNC
2433 * @tc.require: #I5Y4MZ
2434 */
2435 static HWTEST_F(AVSessionServiceTest, IsParamInvalid002, TestSize.Level0)
2436 {
2437 SLOGD("IsParamInvalid002 begin!");
2438 std::string tag = "testTag";
2439 int32_t type = AVSession::SESSION_TYPE_INVALID;
2440 OHOS::AppExecFwk::ElementName elementName;
2441 elementName.SetBundleName("com.example.bundle");
2442 elementName.SetAbilityName("com.example.ability");
2443 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2444 EXPECT_FALSE(result);
2445 SLOGD("IsParamInvalid002 end!");
2446 }
2447
2448 /**
2449 * @tc.name: IsParamInvalid003
2450 * @tc.desc: Verifying IsParamInvalid with an empty bundle name.
2451 * @tc.type: FUNC
2452 * @tc.require: #I5Y4MZ
2453 */
2454 static HWTEST_F(AVSessionServiceTest, IsParamInvalid003, TestSize.Level0)
2455 {
2456 SLOGD("IsParamInvalid003 begin!");
2457 std::string tag = "testTag";
2458 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2459 OHOS::AppExecFwk::ElementName elementName;
2460 elementName.SetBundleName("");
2461 elementName.SetAbilityName(g_testAnotherAbilityName);
2462 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2463 EXPECT_FALSE(result);
2464 SLOGD("IsParamInvalid003 end!");
2465 }
2466
2467 /**
2468 * @tc.name: IsParamInvalid004
2469 * @tc.desc: Verifying IsParamInvalid with an empty ability name.
2470 * @tc.type: FUNC
2471 * @tc.require: #I5Y4MZ
2472 */
2473 static HWTEST_F(AVSessionServiceTest, IsParamInvalid004, TestSize.Level0)
2474 {
2475 SLOGD("IsParamInvalid004 begin!");
2476 std::string tag = "testTag";
2477 int32_t type = AVSession::SESSION_TYPE_AUDIO;
2478 OHOS::AppExecFwk::ElementName elementName;
2479 elementName.SetBundleName(g_testAnotherBundleName);
2480 elementName.SetAbilityName("");
2481 bool result = avservice_->IsParamInvalid(tag, type, elementName);
2482 EXPECT_FALSE(result);
2483 SLOGD("IsParamInvalid004 end!");
2484 }
2485
2486 /**
2487 * @tc.name: IsLocalDevice001
2488 * @tc.desc: Verifying IsLocalDevice with a valid local network ID.
2489 * @tc.type: FUNC
2490 * @tc.require: #I5Y4MZ
2491 */
2492 static HWTEST_F(AVSessionServiceTest, IsLocalDevice001, TestSize.Level0)
2493 {
2494 SLOGD("IsLocalDevice001 begin!");
2495 const std::string networkId = "LocalDevice";
2496 bool result = avservice_->IsLocalDevice(networkId);
2497 EXPECT_TRUE(result);
2498 SLOGD("IsLocalDevice001 end!");
2499 }
2500
2501 /**
2502 * @tc.name: GetDeviceInfo002
2503 * @tc.desc: Verifying GetDeviceInfo with a valid session item and descriptors.
2504 * @tc.type: FUNC
2505 * @tc.require: #I5Y4MZ
2506 */
2507 static HWTEST_F(AVSessionServiceTest, GetDeviceInfo002, TestSize.Level0)
2508 {
2509 SLOGI("GetDeviceInfo002 begin!");
2510 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2511 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2512 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2513 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2514 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2515 };
2516 avservice_->SetDeviceInfo(descriptors, avsessionHere);
2517 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2518 EXPECT_NE(avsessionHere, nullptr);
2519 SLOGI("GetDeviceInfo002 end!");
2520 }
2521
2522 /**
2523 * @tc.name: CastAudioProcess001
2524 * @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
2525 * @tc.type: FUNC
2526 * @tc.require: #I5Y4MZ
2527 */
2528 static HWTEST_F(AVSessionServiceTest, CastAudioProcess001, TestSize.Level0)
2529 {
2530 SLOGI("CastAudioProcess001 begin!");
2531 EXPECT_TRUE(avservice_ != nullptr);
2532 OHOS::AppExecFwk::ElementName elementName;
2533 elementName.SetBundleName(g_testAnotherBundleName);
2534 elementName.SetAbilityName(g_testAnotherAbilityName);
2535 OHOS::sptr<AVSessionItem> avsessionHere =
2536 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
2537 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors;
2538 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2539 const std::string sourceSessionInfo = "123443";
2540 auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
2541 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2542 SLOGI("CastAudioProcess001 end!");
2543 }
2544
2545 /**
2546 * @tc.name: CastAudioProcess002
2547 * @tc.desc: Verifying CastAudioProcess with a valid session item and descriptors.
2548 * @tc.type: FUNC
2549 * @tc.require: #I5Y4MZ
2550 */
2551 static HWTEST_F(AVSessionServiceTest, CastAudioProcess002, TestSize.Level0)
2552 {
2553 SLOGI("CastAudioProcess002 begin!");
2554 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2555 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2556 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2557 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2558 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2559 };
2560 avservice_->SetDeviceInfo(descriptors, avsessionHere);
2561 avservice_->GetDeviceInfo(avsessionHere, descriptors, descriptors, descriptors);
2562 EXPECT_NE(avsessionHere, nullptr);
2563 const std::string sourceSessionInfo = "123443";
2564 auto ret = avservice_->CastAudioProcess(descriptors, sourceSessionInfo, avsessionHere);
2565 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2566 SLOGI("CastAudioProcess002 end!");
2567 }
2568
2569 /**
2570 * @tc.name: CastAudioInner001
2571 * @tc.desc: Verifying CastAudioInner with a valid session item and descriptors.
2572 * @tc.type: FUNC
2573 * @tc.require: #I5Y4MZ
2574 */
2575 static HWTEST_F(AVSessionServiceTest, CastAudioInner001, TestSize.Level0)
2576 {
2577 SLOGI("CastAudioInner001 begin!");
2578 EXPECT_TRUE(avservice_ != nullptr);
2579 std::shared_ptr<AVSessionDescriptor> histroyDescriptor = std::make_shared<AVSessionDescriptor>();
2580 auto avsessionHere = OHOS::sptr<AVSessionItem>::MakeSptr(*histroyDescriptor);
2581 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2582 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2583 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2584 };
2585 const std::string sourceSessionInfo = "123443";
2586 auto ret = avservice_->CastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
2587 EXPECT_EQ(ret, AVSESSION_ERROR);
2588 SLOGI("CastAudioInner001 end!");
2589 }
2590
2591 /**
2592 * @tc.name: CancelCastAudioInner001
2593 * @tc.desc: Verifying CancelCastAudioInner with a valid session item and descriptors.
2594 * @tc.type: FUNC
2595 * @tc.require: #I5Y4MZ
2596 */
2597 static HWTEST_F(AVSessionServiceTest, CancelCastAudioInner001, TestSize.Level0)
2598 {
2599 SLOGI("CancelCastAudioInner001 begin!");
2600 EXPECT_TRUE(avservice_ != nullptr);
2601 OHOS::AppExecFwk::ElementName elementName;
2602 elementName.SetBundleName(g_testAnotherBundleName);
2603 elementName.SetAbilityName(g_testAnotherAbilityName);
2604 OHOS::sptr<AVSessionItem> avsessionHere =
2605 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
2606 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2607 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2608 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2609 };
2610 const std::string sourceSessionInfo = "123443";
2611 auto ret = avservice_->CancelCastAudioInner(descriptors, sourceSessionInfo, avsessionHere);
2612 EXPECT_EQ(ret, AVSESSION_SUCCESS);
2613 SLOGI("CancelCastAudioInner001 end!");
2614 }
2615
2616 /**
2617 * @tc.name: CastAudioForAll001
2618 * @tc.desc: Verifying CastAudioForAll with valid descriptors.
2619 * @tc.type: FUNC
2620 * @tc.require: #I5Y4MZ
2621 */
2622 static HWTEST_F(AVSessionServiceTest, CastAudioForAll001, TestSize.Level0)
2623 {
2624 SLOGI("CastAudioForAll001 begin!");
2625 EXPECT_TRUE(avservice_ != nullptr);
2626 std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> descriptors = {
2627 OHOS::AudioStandard::AudioDeviceDescriptor(OHOS::AudioStandard::DeviceType::DEVICE_TYPE_EARPIECE,
2628 OHOS::AudioStandard::DeviceRole::INPUT_DEVICE, 1, 1, "LocalDevice")
2629 };
2630 auto ret = avservice_->CastAudioForAll(descriptors);
2631 EXPECT_EQ(ret, AVSESSION_ERROR);
2632 SLOGI("CastAudioForAll001 end!");
2633 }
2634
2635 /**
2636 * @tc.name: ClearControllerForClientDiedNoLock002
2637 * @tc.desc: Verifying ClearControllerForClientDiedNoLock with a valid PID.
2638 * @tc.type: FUNC
2639 * @tc.require: #I5Y4MZ
2640 */
2641 static HWTEST_F(AVSessionServiceTest, ClearControllerForClientDiedNoLock002, TestSize.Level0)
2642 {
2643 SLOGI("ClearControllerForClientDiedNoLock002 begin!");
2644 EXPECT_TRUE(avservice_ != nullptr);
2645 pid_t pid = 1234;
2646 avservice_->ClearControllerForClientDiedNoLock(pid);
2647 EXPECT_TRUE(avservice_ != nullptr);
2648 SLOGI("ClearControllerForClientDiedNoLock002 end!");
2649 }
2650
2651 /**
2652 * @tc.name: CheckAndCreateDir001
2653 * @tc.desc: Verifying CheckAndCreateDir with a valid file path.
2654 * @tc.type: FUNC
2655 * @tc.require: #I5Y4MZ
2656 */
2657 static HWTEST_F(AVSessionServiceTest, CheckAndCreateDir001, TestSize.Level0)
2658 {
2659 SLOGI("CheckAndCreateDir001 begin!");
2660 EXPECT_TRUE(avservice_ != nullptr);
2661 const string filePath = "/data/path";
2662 bool ret = avservice_->CheckAndCreateDir(filePath);
2663 EXPECT_TRUE(ret);
2664 SLOGI("CheckAndCreateDir001 end!");
2665 }
2666
2667 /**
2668 * @tc.name: SaveStringToFileEx001
2669 * @tc.desc: Verifying SaveStringToFileEx with a valid file path and content.
2670 * @tc.type: FUNC
2671 * @tc.require: #I5Y4MZ
2672 */
2673 static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx001, TestSize.Level0)
2674 {
2675 SLOGI("SaveStringToFileEx001 begin!");
2676 std::string filePath = "uripath";
2677 std::string content = "123456";
2678 bool ret = avservice_->SaveStringToFileEx(filePath, content);
2679 EXPECT_EQ(ret, true);
2680 SLOGI("SaveStringToFileEx001 end!");
2681 }
2682
2683 /**
2684 * @tc.name: SaveStringToFileEx002
2685 * @tc.desc: Verifying SaveStringToFileEx with an empty content.
2686 * @tc.type: FUNC
2687 * @tc.require: #I5Y4MZ
2688 */
2689 static HWTEST_F(AVSessionServiceTest, SaveStringToFileEx002, TestSize.Level0)
2690 {
2691 SLOGI("SaveStringToFileEx002 begin!");
2692 OHOS::AppExecFwk::ElementName elementName;
2693 elementName.SetBundleName(g_testAnotherBundleName);
2694 elementName.SetAbilityName(g_testAnotherAbilityName);
2695 OHOS::sptr<AVSessionItem> avsessionItem =
2696 avservice_->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
2697
2698 std::string filePath = avservice_->GetAVSortDir();
2699 std::string content = "";
2700 bool ret = avservice_->SaveStringToFileEx(filePath, content);
2701 EXPECT_EQ(ret, false);
2702 SLOGI("SaveStringToFileEx002 end!");
2703 }
2704
2705 /**
2706 * @tc.name: RemoveExpired001
2707 * @tc.desc: Verifying RemoveExpired with an expired time point.
2708 * @tc.type: FUNC
2709 * @tc.require: #I5Y4MZ
2710 */
2711 static HWTEST_F(AVSessionServiceTest, RemoveExpired001, TestSize.Level0)
2712 {
2713 SLOGD("RemoveExpired001 begin!");
2714 std::list<std::chrono::system_clock::time_point> timeList;
2715 auto now = std::chrono::system_clock::now();
2716 int32_t timeThreshold = 5;
2717 timeList.push_back(now - std::chrono::seconds(10));
2718 avservice_->RemoveExpired(timeList, now, timeThreshold);
2719
2720 EXPECT_TRUE(timeList.empty());
2721 SLOGD("RemoveExpired001 end!");
2722 }
2723
2724 /**
2725 * @tc.name: RemoveExpired002
2726 * @tc.desc: Verifying RemoveExpired with a non-expired time point.
2727 * @tc.type: FUNC
2728 * @tc.require: #I5Y4MZ
2729 */
2730 static HWTEST_F(AVSessionServiceTest, RemoveExpired002, TestSize.Level0)
2731 {
2732 SLOGD("RemoveExpired002 begin!");
2733 std::list<std::chrono::system_clock::time_point> timeList;
2734 auto now = std::chrono::system_clock::now();
2735 int32_t timeThreshold = 5;
2736 timeList.push_back(now - std::chrono::seconds(3));
2737
2738 avservice_->RemoveExpired(timeList, now, timeThreshold);
2739 EXPECT_EQ(timeList.size(), 1);
2740 SLOGD("RemoveExpired002 end!");
2741 }
2742
2743 /**
2744 * @tc.name: RemoveExpired003
2745 * @tc.desc: Verifying RemoveExpired with an empty time list.
2746 * @tc.type: FUNC
2747 * @tc.require: #I5Y4MZ
2748 */
2749 static HWTEST_F(AVSessionServiceTest, RemoveExpired003, TestSize.Level0)
2750 {
2751 SLOGD("RemoveExpired003 begin!");
2752 std::list<std::chrono::system_clock::time_point> timeList;
2753 auto now = std::chrono::system_clock::now();
2754 int32_t timeThreshold = 5;
2755 avservice_->RemoveExpired(timeList, now, timeThreshold);
2756 EXPECT_TRUE(timeList.empty());
2757 SLOGD("RemoveExpired003 end!");
2758 }
2759
2760 /**
2761 * @tc.name: NotifyFlowControl001
2762 * @tc.desc: Verifying NotifyFlowControl with a full flow control list.
2763 * @tc.type: FUNC
2764 * @tc.require: #I5Y4MZ
2765 */
2766 static HWTEST_F(AVSessionServiceTest, NotifyFlowControl001, TestSize.Level0)
2767 {
2768 SLOGD("NotifyFlowControl001 begin!");
2769 avservice_->flowControlPublishTimestampList_.clear();
2770 const size_t count = 3;
2771 for (size_t i = 0; i < count; ++i) {
2772 avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
2773 }
2774 bool result = avservice_->NotifyFlowControl();
2775 EXPECT_TRUE(result);
2776 EXPECT_EQ(avservice_->flowControlPublishTimestampList_.size(), count);
2777 SLOGD("NotifyFlowControl001 end!");
2778 }
2779
2780 /**
2781 * @tc.name: NotifyFlowControl002
2782 * @tc.desc: Verifying NotifyFlowControl with a non-full flow control list.
2783 * @tc.type: FUNC
2784 * @tc.require: #I5Y4MZ
2785 */
2786 static HWTEST_F(AVSessionServiceTest, NotifyFlowControl002, TestSize.Level0)
2787 {
2788 SLOGD("NotifyFlowControl002 begin!");
2789 const size_t count = 3;
2790 avservice_->flowControlPublishTimestampList_.clear();
2791 for (size_t i = 0; i < count - 1; ++i) {
2792 avservice_->flowControlPublishTimestampList_.push_back(std::chrono::system_clock::now());
2793 }
2794 bool result = avservice_->NotifyFlowControl();
2795 EXPECT_FALSE(result);
2796 SLOGD("NotifyFlowControl002 end!");
2797 }
2798
2799 /**
2800 * @tc.name: NotifyRemoteDistributedSessionControllersChanged001
2801 * @tc.desc: Verifying NotifyRemoteDistributedSessionControllersChanged with a valid session controller.
2802 * @tc.type: FUNC
2803 * @tc.require: #I5Y4MZ
2804 */
2805 static HWTEST_F(AVSessionServiceTest, NotifyRemoteDistributedSessionControllersChanged001, TestSize.Level0)
2806 {
2807 SLOGD("NotifyRemoteDistributedSessionControllersChanged001 begin!");
2808 std::vector<OHOS::sptr<IRemoteObject>> sessionControllers;
2809 avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
2810 OHOS::sptr<OHOS::ISystemAbilityManager> mgr =
2811 OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2812 EXPECT_TRUE(mgr != nullptr);
2813 OHOS::sptr<IRemoteObject> obj = mgr->GetSystemAbility(OHOS::AVSESSION_SERVICE_ID);
2814 sessionControllers.push_back(obj);
2815 avservice_->NotifyRemoteDistributedSessionControllersChanged(sessionControllers);
2816 EXPECT_TRUE(avservice_ != nullptr);
2817 SLOGD("NotifyRemoteDistributedSessionControllersChanged001 end!");
2818 }
2819
2820 /**
2821 * @tc.name: SuperLauncher001
2822 * @tc.desc: Verifying SuperLauncher with init state
2823 * @tc.type: FUNC
2824 * @tc.require: #I5Y4MZ
2825 */
2826 static HWTEST_F(AVSessionServiceTest, SuperLauncher001, TestSize.Level0)
2827 {
2828 SLOGD("SuperLauncher001 begin!");
2829 avservice_->SuperLauncher("adcdef", "SuperLauncher-Dual", "", "CONNECT_SUCC");
2830 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2831 SLOGD("SuperLauncher001 end!");
2832 }
2833
2834 /**
2835 * @tc.name: ReleaseSuperLauncher001
2836 * @tc.desc: Verifying ReleaseSuperLauncher with SupportCrossMediaPlay state
2837 * @tc.type: FUNC
2838 * @tc.require: #I5Y4MZ
2839 */
2840 static HWTEST_F(AVSessionServiceTest, ReleaseSuperLauncher001, TestSize.Level0)
2841 {
2842 SLOGD("ReleaseSuperLauncher001 begin!");
2843 avservice_->ReleaseSuperLauncher("SuperLauncher-Dual");
2844 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2845 SLOGD("ReleaseSuperLauncher001 end!");
2846 }
2847
2848 /**
2849 * @tc.name: ConnectSuperLauncher001
2850 * @tc.desc: Verifying ConnectSuperLauncher001 with init state
2851 * @tc.type: FUNC
2852 * @tc.require: #I5Y4MZ
2853 */
2854 static HWTEST_F(AVSessionServiceTest, ConnectSuperLauncher001, TestSize.Level0)
2855 {
2856 SLOGD("ConnectSuperLauncher001 begin!");
2857 avservice_->ConnectSuperLauncher("adcdef", "SuperLauncher-Dual");
2858 EXPECT_NE(avservice_->migrateAVSession_->servicePtr_, nullptr);
2859 SLOGD("ConnectSuperLauncher001 end!");
2860 }
2861
2862 /**
2863 * @tc.name: SucceedSuperLauncher001
2864 * @tc.desc: Verifying SucceedSuperLauncher001 with init state
2865 * @tc.type: FUNC
2866 * @tc.require: #I5Y4MZ
2867 */
2868 static HWTEST_F(AVSessionServiceTest, SucceedSuperLauncher001, TestSize.Level0)
2869 {
2870 SLOGD("SucceedSuperLauncher001 begin!");
2871 avservice_->SucceedSuperLauncher("adcdef", "SuperLauncher-Dual");
2872 EXPECT_EQ(avservice_->migrateAVSession_->supportCrossMediaPlay_, false);
2873 SLOGD("SucceedSuperLauncher001 end!");
2874 }
2875
2876 static HWTEST_F(AVSessionServiceTest, IsCapsuleNeeded001, TestSize.Level0)
2877 {
2878 SLOGD("IsCapsuleNeeded001 begin!");
2879 avservice_->topSession_ = nullptr;
2880 bool result = avservice_->IsCapsuleNeeded();
2881 EXPECT_EQ(result, false);
2882 SLOGD("IsCapsuleNeeded001 end!");
2883 }
2884
2885 static HWTEST_F(AVSessionServiceTest, SetForwardTime001, TestSize.Level0)
2886 {
2887 SLOGD("SetForwardTime001 begin!");
2888 int64_t test = -1;
2889 int32_t ret = avcommand_->SetForwardTime(test);
2890 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2891 SLOGD("SetForwardTime001 end!");
2892 }
2893
2894 static HWTEST_F(AVSessionServiceTest, SetRewindTime001, TestSize.Level0)
2895 {
2896 SLOGD("SetRewindTime001 begin!");
2897 int64_t test = -1;
2898 int32_t ret = avcommand_->SetRewindTime(test);
2899 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2900 SLOGD("SetRewindTime001 end!");
2901 }
2902
2903 static HWTEST_F(AVSessionServiceTest, SetSeekTime001, TestSize.Level0)
2904 {
2905 SLOGD("SetSeekTime001 begin!");
2906 int64_t test = -1;
2907 int32_t ret = avcommand_->SetSeekTime(test);
2908 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2909 SLOGD("SetSeekTime001 end!");
2910 }
2911
2912 static HWTEST_F(AVSessionServiceTest, SetPlayWithAssetId001, TestSize.Level0)
2913 {
2914 SLOGD("SetPlayWithAssetId001 begin!");
2915 std::string test = "";
2916 int32_t ret = avcommand_->SetPlayWithAssetId(test);
2917 EXPECT_EQ(ret, ERR_INVALID_PARAM);
2918 SLOGD("SetPlayWithAssetId001 end!");
2919 }