1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <memory>
18
19 #include "avsession_log.h"
20 #include "input_manager.h"
21 #include "key_event.h"
22 #include "avsession_manager.h"
23 #include "avsession_errors.h"
24 #include "avmeta_data.h"
25 #include "avplayback_state.h"
26 #include "avsession_log.h"
27 #include "nativetoken_kit.h"
28 #include "token_setproc.h"
29 #include "accesstoken_kit.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::AVSession;
33 using namespace OHOS::Security::AccessToken;
34
35
36 static AVMetaData g_metaData;
37 static AVPlaybackState g_playbackState;
38 static char g_testSessionTag[] = "test";
39 static char g_testBundleName[] = "test.ohos.avsession";
40 static char g_testAbilityName[] = "test.ability";
41 static int32_t g_playOnCall = AVSESSION_ERROR;
42 static int32_t g_pauseOnCall = AVSESSION_ERROR;
43 static int32_t g_nextOnCall = AVSESSION_ERROR;
44 static int32_t g_previousOnCall = AVSESSION_ERROR;
45
46 class AVSessionServiceTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp() override;
51 void TearDown() override;
52
53 std::shared_ptr<AVSession> avsession_ = nullptr;
54 };
55
SetUpTestCase()56 void AVSessionServiceTest::SetUpTestCase()
57 {
58 }
59
TearDownTestCase()60 void AVSessionServiceTest::TearDownTestCase()
61 {
62 }
63
SetUp()64 void AVSessionServiceTest::SetUp()
65 {
66 OHOS::AppExecFwk::ElementName elementName;
67 elementName.SetBundleName(g_testBundleName);
68 elementName.SetAbilityName(g_testAbilityName);
69 avsession_ = AVSessionManager::GetInstance().CreateSession(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO,
70 elementName);
71 ASSERT_NE(avsession_, nullptr);
72 avsession_->Activate();
73 }
74
TearDown()75 void AVSessionServiceTest::TearDown()
76 {
77 int32_t ret = AVSESSION_ERROR;
78 if (avsession_ != nullptr) {
79 ret = avsession_->Destroy();
80 avsession_ = nullptr;
81 }
82 }
83
84 class AVSessionCallbackImpl : public AVSessionCallback {
85 public:
86 void OnPlay() override;
87 void OnPause() override;
OnStop()88 void OnStop() override {};
89 void OnPlayNext() override;
90 void OnPlayPrevious() override;
OnFastForward()91 void OnFastForward() override {};
OnRewind()92 void OnRewind() override {};
OnSeek(int64_t time)93 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)94 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)95 void OnSetLoopMode(int32_t loopMode) override {};
OnToggleFavorite(const std::string & mediaId)96 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)97 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)98 void OnOutputDeviceChange(const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override {};
99
100 ~AVSessionCallbackImpl() override;
101 };
102
OnPlay()103 void AVSessionCallbackImpl::OnPlay()
104 {
105 g_playOnCall = AVSESSION_SUCCESS;
106 SLOGI("OnPlay %{public}d", g_playOnCall);
107 }
108
OnPause()109 void AVSessionCallbackImpl::OnPause()
110 {
111 g_pauseOnCall = AVSESSION_SUCCESS;
112 SLOGI("OnPause %{public}d", g_pauseOnCall);
113 }
114
OnPlayNext()115 void AVSessionCallbackImpl::OnPlayNext()
116 {
117 g_nextOnCall = AVSESSION_SUCCESS;
118 SLOGI("OnPlayNext %{public}d", g_nextOnCall);
119 }
120
OnPlayPrevious()121 void AVSessionCallbackImpl::OnPlayPrevious()
122 {
123 g_previousOnCall = AVSESSION_SUCCESS;
124 SLOGI("OnPlayPrevious %{public}d", g_previousOnCall);
125 }
126
~AVSessionCallbackImpl()127 AVSessionCallbackImpl::~AVSessionCallbackImpl()
128 {
129 }
130
131 /**
132 * @tc.name: SendSystemAVKeyEvent001
133 * @tc.desc: verifying send system keyEvent
134 * @tc.type: FUNC
135 * @tc.require: #I5Y4MZ
136 */
137 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent001, TestSize.Level1)
138 {
139 SLOGI("SendSystemAVKeyEvent001 begin!");
140
141 g_metaData.Reset();
142 g_metaData.SetAssetId("123");
143 g_metaData.SetTitle("Black Humor");
144 g_metaData.SetArtist("zhoujielun");
145 g_metaData.SetAuthor("zhoujielun");
146 g_metaData.SetAlbum("Jay");
147 g_metaData.SetWriter("zhoujielun");
148 g_metaData.SetComposer("zhoujielun");
149 g_metaData.SetDuration(40000);
150 g_metaData.SetMediaImageUri("xxxxx");
151 g_metaData.SetSubTitle("fac");
152 g_metaData.SetDescription("for friends");
153 g_metaData.SetLyric("xxxxx");
154 avsession_->SetAVMetaData(g_metaData);
155
156 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAYING);
157 g_playbackState.SetSpeed(1.5);
158 g_playbackState.SetPosition({80000, 0});
159 g_playbackState.SetBufferedTime(60000);
160 g_playbackState.SetLoopMode(2);
161 g_playbackState.SetFavorite(true);
162 avsession_->SetAVPlaybackState(g_playbackState);
163
164 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
165 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
166
167 auto keyEvent = OHOS::MMI::KeyEvent::Create();
168 ASSERT_NE(keyEvent, nullptr);
169 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
170 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
171 OHOS::MMI::KeyEvent::KeyItem item;
172 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
173 item.SetDownTime(0);
174 item.SetPressed(true);
175 keyEvent->AddPressedKeyItems(item);
176 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
177 sleep(1);
178 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
179 g_pauseOnCall = false;
180 SLOGI("SendSystemAVKeyEvent001 end!");
181 }
182
183 /**
184 * @tc.name: SendSystemAVKeyEvent002
185 * @tc.desc: verifying send system keyEvent
186 * @tc.type: FUNC
187 * @tc.require: #I5Y4MZ
188 */
189
190 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent002, TestSize.Level1)
191 {
192 SLOGI("SendSystemAVKeyEvent002 begin!");
193
194 g_metaData.Reset();
195 g_metaData.SetAssetId("123");
196 g_metaData.SetTitle("Black Humor");
197 g_metaData.SetArtist("zhoujielun");
198 g_metaData.SetAuthor("zhoujielun");
199 g_metaData.SetAlbum("Jay");
200 g_metaData.SetWriter("zhoujielun");
201 g_metaData.SetComposer("zhoujielun");
202 g_metaData.SetDuration(40000);
203 g_metaData.SetMediaImageUri("xxxxx");
204 g_metaData.SetSubTitle("fac");
205 g_metaData.SetDescription("for friends");
206 g_metaData.SetLyric("xxxxx");
207 avsession_->SetAVMetaData(g_metaData);
208
209 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSED);
210 g_playbackState.SetSpeed(1.5);
211 g_playbackState.SetPosition({80000, 0});
212 g_playbackState.SetBufferedTime(60000);
213 g_playbackState.SetLoopMode(2);
214 g_playbackState.SetFavorite(true);
215 avsession_->SetAVPlaybackState(g_playbackState);
216
217 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
218 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
219
220 auto keyEvent = OHOS::MMI::KeyEvent::Create();
221 ASSERT_NE(keyEvent, nullptr);
222 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
223 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
224 OHOS::MMI::KeyEvent::KeyItem item;
225 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
226 item.SetDownTime(0);
227 item.SetPressed(true);
228 keyEvent->AddPressedKeyItems(item);
229 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
230 sleep(1);
231 EXPECT_EQ(g_playOnCall, AVSESSION_SUCCESS);
232 g_playOnCall = false;
233 SLOGI("SendSystemAVKeyEvent002 end!");
234 }
235
236 /**
237 * @tc.name: SendSystemAVKeyEvent003
238 * @tc.desc: verifying send system keyEvent
239 * @tc.type: FUNC
240 * @tc.require: #I5Y4MZ
241 */
242 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent003, TestSize.Level1)
243 {
244 SLOGI("SendSystemAVKeyEvent003 begin!");
245
246 g_metaData.Reset();
247 g_metaData.SetAssetId("123");
248 g_metaData.SetTitle("Black Humor");
249 g_metaData.SetArtist("zhoujielun");
250 g_metaData.SetAuthor("zhoujielun");
251 g_metaData.SetAlbum("Jay");
252 g_metaData.SetWriter("zhoujielun");
253 g_metaData.SetComposer("zhoujielun");
254 g_metaData.SetDuration(40000);
255 g_metaData.SetMediaImageUri("xxxxx");
256 g_metaData.SetSubTitle("fac");
257 g_metaData.SetDescription("for friends");
258 g_metaData.SetLyric("xxxxx");
259 avsession_->SetAVMetaData(g_metaData);
260
261 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAYING);
262 g_playbackState.SetSpeed(1.5);
263 g_playbackState.SetPosition({80000, 0});
264 g_playbackState.SetBufferedTime(60000);
265 g_playbackState.SetLoopMode(2);
266 g_playbackState.SetFavorite(true);
267 avsession_->SetAVPlaybackState(g_playbackState);
268
269 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
270 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
271
272 auto keyEvent = OHOS::MMI::KeyEvent::Create();
273 ASSERT_NE(keyEvent, nullptr);
274 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
275 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
276 OHOS::MMI::KeyEvent::KeyItem item;
277 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
278 item.SetDownTime(0);
279 item.SetPressed(true);
280 keyEvent->AddPressedKeyItems(item);
281 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
282 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
283 sleep(1);
284 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
285 g_nextOnCall = false;
286 SLOGI("SendSystemAVKeyEvent003 end!");
287 }
288
289 /**
290 * @tc.name: SendSystemAVKeyEvent004
291 * @tc.desc: verifying send system keyEvent
292 * @tc.type: FUNC
293 * @tc.require: #I5Y4MZ
294 */
295 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent004, TestSize.Level1)
296 {
297 SLOGI("SendSystemAVKeyEvent004 begin!");
298
299 g_metaData.Reset();
300 g_metaData.SetAssetId("123");
301 g_metaData.SetTitle("Black Humor");
302 g_metaData.SetArtist("zhoujielun");
303 g_metaData.SetAuthor("zhoujielun");
304 g_metaData.SetAlbum("Jay");
305 g_metaData.SetWriter("zhoujielun");
306 g_metaData.SetComposer("zhoujielun");
307 g_metaData.SetDuration(40000);
308 g_metaData.SetMediaImageUri("xxxxx");
309 g_metaData.SetSubTitle("fac");
310 g_metaData.SetDescription("for friends");
311 g_metaData.SetLyric("xxxxx");
312 avsession_->SetAVMetaData(g_metaData);
313
314 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAYING);
315 g_playbackState.SetSpeed(1.5);
316 g_playbackState.SetPosition({80000, 0});
317 g_playbackState.SetBufferedTime(60000);
318 g_playbackState.SetLoopMode(2);
319 g_playbackState.SetFavorite(true);
320 avsession_->SetAVPlaybackState(g_playbackState);
321
322 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
323 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
324
325 auto keyEvent = OHOS::MMI::KeyEvent::Create();
326 ASSERT_NE(keyEvent, nullptr);
327 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
328 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
329 OHOS::MMI::KeyEvent::KeyItem item;
330 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
331 item.SetDownTime(0);
332 item.SetPressed(true);
333 keyEvent->AddPressedKeyItems(item);
334 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
335 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
336 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
337 sleep(1);
338 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
339 g_previousOnCall = false;
340 SLOGI("SendSystemAVKeyEvent004 end!");
341 }
342
343 /**
344 * @tc.name: SendSystemAVKeyEvent005
345 * @tc.desc: verifying send system keyEvent
346 * @tc.type: FUNC
347 * @tc.require: #I5Y4MZ
348 */
349 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent005, TestSize.Level1)
350 {
351 SLOGI("SendSystemAVKeyEvent005 begin!");
352
353 g_metaData.Reset();
354 g_metaData.SetAssetId("123");
355 g_metaData.SetTitle("Black Humor");
356 g_metaData.SetArtist("zhoujielun");
357 g_metaData.SetAuthor("zhoujielun");
358 g_metaData.SetAlbum("Jay");
359 g_metaData.SetWriter("zhoujielun");
360 g_metaData.SetComposer("zhoujielun");
361 g_metaData.SetDuration(40000);
362 g_metaData.SetMediaImageUri("xxxxx");
363 g_metaData.SetSubTitle("fac");
364 g_metaData.SetDescription("for friends");
365 g_metaData.SetLyric("xxxxx");
366 avsession_->SetAVMetaData(g_metaData);
367
368 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAYING);
369 g_playbackState.SetSpeed(1.5);
370 g_playbackState.SetPosition({80000, 0});
371 g_playbackState.SetBufferedTime(60000);
372 g_playbackState.SetLoopMode(2);
373 g_playbackState.SetFavorite(true);
374 avsession_->SetAVPlaybackState(g_playbackState);
375
376 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
377 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
378
379 auto keyEvent = OHOS::MMI::KeyEvent::Create();
380 ASSERT_NE(keyEvent, nullptr);
381 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
382 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
383 OHOS::MMI::KeyEvent::KeyItem item;
384 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
385 item.SetDownTime(0);
386 item.SetPressed(true);
387 keyEvent->AddPressedKeyItems(item);
388 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
389 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
390 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
391 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
392 sleep(1);
393 EXPECT_EQ(g_previousOnCall, AVSESSION_SUCCESS);
394 g_previousOnCall = false;
395 SLOGI("SendSystemAVKeyEvent005 end!");
396 }
397
398 /**
399 * @tc.name: SendSystemAVKeyEvent006
400 * @tc.desc: verifying send system keyEvent
401 * @tc.type: FUNC
402 * @tc.require: #I5Y4MZ
403 */
404 HWTEST_F(AVSessionServiceTest, SendSystemAVKeyEvent006, TestSize.Level1)
405 {
406 SLOGI("SendSystemAVKeyEvent006 begin!");
407
408 g_metaData.Reset();
409 g_metaData.SetAssetId("123");
410 g_metaData.SetTitle("Black Humor");
411 g_metaData.SetArtist("zhoujielun");
412 g_metaData.SetAuthor("zhoujielun");
413 g_metaData.SetAlbum("Jay");
414 g_metaData.SetWriter("zhoujielun");
415 g_metaData.SetComposer("zhoujielun");
416 g_metaData.SetDuration(40000);
417 g_metaData.SetMediaImageUri("xxxxx");
418 g_metaData.SetSubTitle("fac");
419 g_metaData.SetDescription("for friends");
420 g_metaData.SetLyric("xxxxx");
421 avsession_->SetAVMetaData(g_metaData);
422
423 g_playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAYING);
424 g_playbackState.SetSpeed(1.5);
425 g_playbackState.SetPosition({80000, 0});
426 g_playbackState.SetBufferedTime(60000);
427 g_playbackState.SetLoopMode(2);
428 g_playbackState.SetFavorite(true);
429 avsession_->SetAVPlaybackState(g_playbackState);
430
431 std::shared_ptr<AVSessionCallback> callback = std::make_shared<AVSessionCallbackImpl>();
432 EXPECT_EQ(avsession_->RegisterCallback(callback), AVSESSION_SUCCESS);
433
434 auto keyEvent = OHOS::MMI::KeyEvent::Create();
435 ASSERT_NE(keyEvent, nullptr);
436 keyEvent->SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
437 keyEvent->SetKeyAction(OHOS::MMI::KeyEvent::KEY_ACTION_DOWN);
438 OHOS::MMI::KeyEvent::KeyItem item;
439 item.SetKeyCode(OHOS::MMI::KeyEvent::KEYCODE_HEADSETHOOK);
440 item.SetDownTime(0);
441 item.SetPressed(true);
442 keyEvent->AddPressedKeyItems(item);
443 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
444 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
445 sleep(1);
446 EXPECT_EQ(g_nextOnCall, AVSESSION_SUCCESS);
447 g_nextOnCall = false;
448 OHOS::MMI::InputManager::GetInstance()->SimulateInputEvent(keyEvent);
449 sleep(1);
450 EXPECT_EQ(g_pauseOnCall, AVSESSION_SUCCESS);
451 g_pauseOnCall = false;
452 SLOGI("SendSystemAVKeyEvent006 end!");
453 }