1 /*
2 * Copyright (c) 2024-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 "avsession_callback_client.h"
18 #include "avsession_log.h"
19 #include "avsession_errors.h"
20 #include "iservice_registry.h"
21 #include "avmedia_description.h"
22 #include "av_file_descriptor.h"
23 #include "system_ability_definition.h"
24 #include "av_session_callback_proxy.h"
25 #include "avsession_controller_proxy.h"
26 #include "avsession_proxy.h"
27 #include "avsession_service.h"
28
29
30 namespace OHOS::AVSession {
31
32 static std::shared_ptr<AVSessionService> g_AVSessionService;
33 static sptr<AVSessionProxy> g_AVSessionProxy;
34
35 class AVSessionProxyTest : public testing::Test {
36 public:
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase()43 void AVSessionProxyTest::SetUpTestCase()
44 {
45 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
46 std::string deviceId = "deviceId";
47 std::string bundleName = "testItem.ohos.avsession";
48 std::string abilityName = "testItem.ability";
49 std::string moduleName = "moduleName";
50 AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
51 sptr<IRemoteObject> obj = g_AVSessionService->CreateSessionInner("test",
52 AVSession::SESSION_TYPE_AUDIO, elementName);
53 g_AVSessionProxy = iface_cast<AVSessionProxy>(obj);
54 g_AVSessionProxy->Activate();
55 }
56
TearDownTestCase()57 void AVSessionProxyTest::TearDownTestCase()
58 {
59 g_AVSessionProxy->Deactivate();
60 g_AVSessionService->Close();
61 }
62
SetUp()63 void AVSessionProxyTest::SetUp()
64 {
65 }
66
TearDown()67 void AVSessionProxyTest::TearDown()
68 {
69 }
70
71 class AVSessionCallbackImpl : public AVSessionCallback {
72 public:
OnPlay()73 void OnPlay() override {};
OnPause()74 void OnPause() override {};
OnStop()75 void OnStop() override {};
OnPlayNext()76 void OnPlayNext() override {};
OnPlayPrevious()77 void OnPlayPrevious() override {};
OnFastForward(int64_t time)78 void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)79 void OnRewind(int64_t time) override {};
OnSeek(int64_t time)80 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)81 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)82 void OnSetLoopMode(int32_t loopMode) override {};
OnSetTargetLoopMode(int32_t targetLoopMode)83 void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
OnToggleFavorite(const std::string & mediaId)84 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)85 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)86 void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)87 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)88 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()89 void OnAVCallAnswer() override {};
OnAVCallHangUp()90 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()91 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)92 void OnPlayFromAssetId(int64_t assetId) override {};
OnPlayWithAssetId(const std::string & assetId)93 void OnPlayWithAssetId(const std::string& assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)94 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
95
~AVSessionCallbackImpl()96 ~AVSessionCallbackImpl() override {};
97 };
98
99
100 /**
101 * @tc.name: GetSessionId001
102 * @tc.desc: Test GetSessionId
103 * @tc.type: FUNC
104 */
105 static HWTEST_F(AVSessionProxyTest, GetSessionId001, testing::ext::TestSize.Level1)
106 {
107 SLOGI("GetSessionId001, start");
108 std::string sessionId = g_AVSessionProxy->GetSessionId();
109 EXPECT_NE(sessionId, "");
110 SLOGI("GetSessionId001, end");
111 }
112
113 /**
114 * @tc.name: GetSessionType001
115 * @tc.desc: Test GetSessionType
116 * @tc.type: FUNC
117 */
118 static HWTEST_F(AVSessionProxyTest, GetSessionType001, testing::ext::TestSize.Level1)
119 {
120 SLOGI("GetSessionType001, start");
121 std::string typeStr = g_AVSessionProxy->GetSessionType();
122 EXPECT_NE(typeStr, "");
123 SLOGI("GetSessionType001, end");
124 }
125
126 /**
127 * @tc.name: SetAVCallMetaData001
128 * @tc.desc: Test SetAVCallMetaData
129 * @tc.type: FUNC
130 */
131 static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData001, testing::ext::TestSize.Level1)
132 {
133 SLOGI("SetAVCallMetaData001, start");
134 AVCallMetaData avCallMetaData;
135 int32_t ret = g_AVSessionProxy->SetAVCallMetaData(avCallMetaData);
136 EXPECT_EQ(ret, AVSESSION_ERROR);
137 SLOGI("SetAVCallMetaData001, end");
138 }
139
140 /**
141 * @tc.name: SetAVCallMetaData002
142 * @tc.desc: Test SetAVCallMetaData
143 * @tc.type: FUNC
144 */
145 static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData002, testing::ext::TestSize.Level1)
146 {
147 SLOGI("SetAVCallMetaData002, start");
148 AVCallMetaData avCallMetaData;
149 avCallMetaData.SetName("name");
150 avCallMetaData.SetPhoneNumber("number");
151 int32_t ret = g_AVSessionProxy->SetAVCallMetaData(avCallMetaData);
152 EXPECT_EQ(ret, AVSESSION_SUCCESS);
153 g_AVSessionService->OnStop();
154 SLOGI("SetAVCallMetaData002, end");
155 }
156
157 /**
158 * @tc.name: SetAVCallState001
159 * @tc.desc: Test SetAVCallState
160 * @tc.type: FUNC
161 */
162 static HWTEST_F(AVSessionProxyTest, SetAVCallState001, testing::ext::TestSize.Level1)
163 {
164 SLOGI("SetAVCallState001, start");
165 AVCallState avCallState;
166 avCallState.SetAVCallState(AVCallState::AVCALL_STATE_IDLE);
167 int32_t ret = g_AVSessionProxy->SetAVCallState(avCallState);
168 EXPECT_EQ(ret, AVSESSION_SUCCESS);
169 SLOGI("SetAVCallState001, end");
170 }
171
172 /**
173 * @tc.name: SetAVCallState002
174 * @tc.desc: Test SetAVCallState
175 * @tc.type: FUNC
176 */
177 static HWTEST_F(AVSessionProxyTest, SetAVCallState002, testing::ext::TestSize.Level1)
178 {
179 SLOGI("SetAVCallState002, start");
180 AVCallState avCallState;
181 avCallState.SetAVCallState(-1);
182 int32_t ret = g_AVSessionProxy->SetAVCallState(avCallState);
183 EXPECT_EQ(ret, AVSESSION_SUCCESS);
184 SLOGI("SetAVCallState002, end");
185 }
186
187 /**
188 * @tc.name: SetAVMetaData001
189 * @tc.desc: Test SetAVMetaData
190 * @tc.type: FUNC
191 */
192 static HWTEST_F(AVSessionProxyTest, SetAVMetaData001, testing::ext::TestSize.Level1)
193 {
194 SLOGI("SetAVMetaData001, start");
195 AVMetaData meta;
196 std::string assetId = "assetId";
197 meta.SetAssetId(assetId);
198 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
199 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
200 mediaImage->SetInnerImgBuffer(imgBuffer);
201 meta.SetMediaImage(mediaImage);
202 int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
203 EXPECT_EQ(ret, AVSESSION_SUCCESS);
204 SLOGI("SetAVMetaData001, end");
205 }
206
207 /**
208 * @tc.name: GetAVMetaData001
209 * @tc.desc: Test GetAVMetaData
210 * @tc.type: FUNC
211 */
212 static HWTEST_F(AVSessionProxyTest, GetAVMetaData001, testing::ext::TestSize.Level1)
213 {
214 SLOGI("GetAVMetaData001, start");
215 AVMetaData meta;
216 int32_t ret = g_AVSessionProxy->GetAVMetaData(meta);
217 EXPECT_EQ(ret, AVSESSION_SUCCESS);
218 SLOGI("GetAVMetaData001, end");
219 }
220
221 /**
222 * @tc.name: GetAVPlaybackState001
223 * @tc.desc: Test GetAVPlaybackState
224 * @tc.type: FUNC
225 */
226 static HWTEST_F(AVSessionProxyTest, GetAVPlaybackState001, testing::ext::TestSize.Level1)
227 {
228 SLOGI("GetAVPlaybackState001, start");
229 AVPlaybackState state;
230 int32_t ret = g_AVSessionProxy->GetAVPlaybackState(state);
231 EXPECT_EQ(ret, AVSESSION_SUCCESS);
232 SLOGI("GetAVPlaybackState001, end");
233 }
234
235 /**
236 * @tc.name: SetAVPlaybackState001
237 * @tc.desc: Test SetAVPlaybackState
238 * @tc.type: FUNC
239 */
240 static HWTEST_F(AVSessionProxyTest, SetAVPlaybackState001, testing::ext::TestSize.Level1)
241 {
242 SLOGI("SetAVPlaybackState001, start");
243 AVPlaybackState avPlaybackState;
244 AVPlaybackState::Position position;
245 position.elapsedTime_ = 1;
246 position.updateTime_ = 1;
247 avPlaybackState.SetState(1);
248 avPlaybackState.SetSpeed(1);
249 avPlaybackState.SetPosition(position);
250 avPlaybackState.SetBufferedTime(1);
251 avPlaybackState.SetLoopMode(1);
252 avPlaybackState.SetFavorite(1);
253 avPlaybackState.SetActiveItemId(1);
254 avPlaybackState.SetVolume(1);
255 avPlaybackState.SetMaxVolume(1);
256 avPlaybackState.SetMuted(1);
257 avPlaybackState.SetDuration(1);
258 avPlaybackState.SetVideoWidth(1);
259 avPlaybackState.SetVideoHeight(1);
260 int32_t ret = g_AVSessionProxy->SetAVPlaybackState(avPlaybackState);
261 EXPECT_EQ(ret, AVSESSION_SUCCESS);
262 SLOGI("SetAVPlaybackState001, end");
263 }
264
265 /**
266 * @tc.name: GetAVQueueItems001
267 * @tc.desc: Test GetAVQueueItems
268 * @tc.type: FUNC
269 */
270 static HWTEST_F(AVSessionProxyTest, GetAVQueueItems001, testing::ext::TestSize.Level1)
271 {
272 SLOGI("GetAVQueueItems001, start");
273 std::vector<AVQueueItem> items = {};
274 int32_t ret = g_AVSessionProxy->GetAVQueueItems(items);
275 EXPECT_EQ(ret, AVSESSION_SUCCESS);
276 SLOGI("GetAVQueueItems001, end");
277 }
278
279 /**
280 * @tc.name: SetAVQueueItems001
281 * @tc.desc: Test SetAVQueueItems
282 * @tc.type: FUNC
283 */
284 static HWTEST_F(AVSessionProxyTest, SetAVQueueItems001, testing::ext::TestSize.Level1)
285 {
286 SLOGI("SetAVQueueItems001, start");
287 std::vector<AVQueueItem> items = {};
288 int32_t ret = g_AVSessionProxy->SetAVQueueItems(items);
289 EXPECT_EQ(ret, AVSESSION_SUCCESS);
290 SLOGI("SetAVQueueItems001, end");
291 }
292
293 /**
294 * @tc.name: GetAVQueueTitle001
295 * @tc.desc: Test GetAVQueueTitle
296 * @tc.type: FUNC
297 */
298 static HWTEST_F(AVSessionProxyTest, GetAVQueueTitle001, testing::ext::TestSize.Level1)
299 {
300 SLOGI("GetAVQueueTitle001, start");
301 std::string title = "title";
302 int32_t ret = g_AVSessionProxy->GetAVQueueTitle(title);
303 EXPECT_EQ(ret, AVSESSION_SUCCESS);
304 SLOGI("GetAVQueueTitle001, end");
305 }
306
307 /**
308 * @tc.name: SetAVQueueTitle001
309 * @tc.desc: Test SetAVQueueTitle
310 * @tc.type: FUNC
311 */
312 static HWTEST_F(AVSessionProxyTest, SetAVQueueTitle001, testing::ext::TestSize.Level1)
313 {
314 SLOGI("SetAVQueueTitle001, start");
315 std::string title = "title";
316 int32_t ret = g_AVSessionProxy->SetAVQueueTitle(title);
317 EXPECT_EQ(ret, AVSESSION_SUCCESS);
318 SLOGI("SetAVQueueTitle001, end");
319 }
320
321 /**
322 * @tc.name: SetLaunchAbility001
323 * @tc.desc: Test SetLaunchAbility
324 * @tc.type: FUNC
325 */
326 static HWTEST_F(AVSessionProxyTest, SetLaunchAbility001, testing::ext::TestSize.Level1)
327 {
328 SLOGI("SetLaunchAbility001, start");
329 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
330 int32_t ret = g_AVSessionProxy->SetLaunchAbility(ability);
331 EXPECT_EQ(ret, AVSESSION_SUCCESS);
332 SLOGI("SetLaunchAbility001, end");
333 }
334
335 /**
336 * @tc.name: GetExtras001
337 * @tc.desc: Test GetExtras
338 * @tc.type: FUNC
339 */
340 static HWTEST_F(AVSessionProxyTest, GetExtras001, testing::ext::TestSize.Level1)
341 {
342 SLOGI("GetExtras001, start");
343 OHOS::AAFwk::WantParams extras;
344 int32_t ret = g_AVSessionProxy->GetExtras(extras);
345 EXPECT_EQ(ret, AVSESSION_SUCCESS);
346 SLOGI("GetExtras001, end");
347 }
348
349 /**
350 * @tc.name: SetExtras001
351 * @tc.desc: Test SetExtras
352 * @tc.type: FUNC
353 */
354 static HWTEST_F(AVSessionProxyTest, SetExtras001, testing::ext::TestSize.Level1)
355 {
356 SLOGI("SetExtras001, start");
357 OHOS::AAFwk::WantParams extras;
358 int32_t ret = g_AVSessionProxy->SetExtras(extras);
359 EXPECT_EQ(ret, AVSESSION_SUCCESS);
360 SLOGI("SetExtras001, end");
361 }
362
363 /**
364 * @tc.name: isActivate001
365 * @tc.desc: Test Deactivate
366 * @tc.type: FUNC
367 */
368 static HWTEST_F(AVSessionProxyTest, isActivate001, testing::ext::TestSize.Level1)
369 {
370 SLOGI("isActivate001, start");
371 int32_t ret = g_AVSessionProxy->IsActive();
372 EXPECT_EQ(ret, true);
373 SLOGI("isActivate001, end");
374 }
375
376 /**
377 * @tc.name: SetSessionEvent001
378 * @tc.desc: Test SetSessionEvent
379 * @tc.type: FUNC
380 */
381 static HWTEST_F(AVSessionProxyTest, SetSessionEvent001, testing::ext::TestSize.Level1)
382 {
383 SLOGI("SetSessionEvent001, start");
384 std::string event = "AVSessionCallback";
385 OHOS::AAFwk::WantParams args;
386 int32_t ret = g_AVSessionProxy->SetSessionEvent(event, args);
387 EXPECT_EQ(ret, AVSESSION_SUCCESS);
388 SLOGI("SetSessionEvent001, end");
389 }
390
391 /**
392 * @tc.name: AddSupportCommand001
393 * @tc.desc: Test AddSupportCommand
394 * @tc.type: FUNC
395 */
396 static HWTEST_F(AVSessionProxyTest, AddSupportCommand001, testing::ext::TestSize.Level1)
397 {
398 SLOGI("AddSupportCommand001, start");
399 int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
400 int32_t ret = g_AVSessionProxy->AddSupportCommand(cmd);
401 EXPECT_EQ(ret, AVSESSION_SUCCESS);
402 SLOGI("AddSupportCommand001, end");
403 }
404
405 /**
406 * @tc.name: DeleteSupportCommand001
407 * @tc.desc: Test DeleteSupportCommand
408 * @tc.type: FUNC
409 */
410 static HWTEST_F(AVSessionProxyTest, DeleteSupportCommand001, testing::ext::TestSize.Level1)
411 {
412 SLOGI("DeleteSupportCommand001, start");
413 int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
414 int32_t ret = g_AVSessionProxy->AddSupportCommand(cmd);
415 EXPECT_EQ(ret, AVSESSION_SUCCESS);
416 ret = g_AVSessionProxy->DeleteSupportCommand(cmd);
417 EXPECT_EQ(ret, AVSESSION_SUCCESS);
418 SLOGI("DeleteSupportCommand001, end");
419 }
420
421 /**
422
423 * @tc.name: GetController001
424 * @tc.desc: Test GetController
425 * @tc.type: FUNC
426 */
427 static HWTEST_F(AVSessionProxyTest, GetController001, testing::ext::TestSize.Level1)
428 {
429 SLOGI("GetController001, start");
430 std::string sessionId = g_AVSessionProxy->GetSessionId();
431 sptr<IRemoteObject> controllerInner;
432 int32_t ret = g_AVSessionService->CreateControllerInner(sessionId, controllerInner);
433 EXPECT_EQ(ret, AVSESSION_SUCCESS);
434
435 std::shared_ptr<AVSessionController> avSessionController = g_AVSessionProxy->GetController();
436 EXPECT_EQ(avSessionController, nullptr);
437 SLOGI("GetController001, end");
438 }
439
440 /**
441 * @tc.name: RegisterCallback001
442 * @tc.desc: Test RegisterCallback
443 * @tc.type: FUNC
444 */
445 static HWTEST_F(AVSessionProxyTest, RegisterCallback001, testing::ext::TestSize.Level1)
446 {
447 SLOGI("RegisterCallback001, start");
448 std::shared_ptr<AVSessionCallback> avSessionCallbackImpl = std::make_shared<AVSessionCallbackImpl>();
449 int32_t ret = g_AVSessionProxy->RegisterCallback(avSessionCallbackImpl);
450 EXPECT_EQ(ret, AVSESSION_SUCCESS);
451 SLOGI("RegisterCallback001, end");
452 }
453
454
455 /**
456 * @tc.name: SetAVMetaData002
457 * @tc.desc: Test SetAVMetaData
458 * @tc.type: FUNC
459 */
460 static HWTEST_F(AVSessionProxyTest, SetAVMetaData002, testing::ext::TestSize.Level1)
461 {
462 SLOGI("SetAVMetaData002, start");
463 AVMetaData meta;
464 std::string assetId = "assetId";
465 meta.SetAssetId(assetId);
466
467 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
468 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4};
469 mediaImage->SetInnerImgBuffer(imgBuffer);
470 meta.SetMediaImage(mediaImage);
471
472 std::shared_ptr<AVSessionPixelMap> avQueuePixel = std::make_shared<AVSessionPixelMap>();
473 std::vector<uint8_t> pixelBuffer = {1, 2, 3, 4};
474 avQueuePixel->SetInnerImgBuffer(pixelBuffer);
475 meta.SetAVQueueImage(avQueuePixel);
476
477 int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
478 EXPECT_EQ(ret, AVSESSION_SUCCESS);
479 SLOGI("SetAVMetaData002, end");
480 }
481
482 /**
483 * @tc.name: SetAVMetaData003
484 * @tc.desc: Test SetAVMetaData
485 * @tc.type: FUNC
486 */
487 static HWTEST_F(AVSessionProxyTest, SetAVMetaData003, testing::ext::TestSize.Level1)
488 {
489 SLOGI("SetAVMetaData003, start");
490 AVMetaData meta;
491 std::string assetId = "assetId";
492 meta.SetAssetId(assetId);
493 int32_t ret = g_AVSessionProxy->SetAVMetaData(meta);
494 EXPECT_EQ(ret, AVSESSION_SUCCESS);
495 SLOGI("SetAVMetaData003, end");
496 }
497
498 /**
499 * @tc.name: GetAVQueueItems002
500 * @tc.desc: Test GetAVQueueItems
501 * @tc.type: FUNC
502 */
503 static HWTEST_F(AVSessionProxyTest, GetAVQueueItems002, testing::ext::TestSize.Level1)
504 {
505 SLOGI("GetAVQueueItems002, start");
506 std::vector<AVQueueItem> setItems;
507 AVQueueItem item;
508 setItems.push_back(item);
509 g_AVSessionProxy->SetAVQueueItems(setItems);
510
511 std::vector<AVQueueItem> getItems;
512 int32_t ret = g_AVSessionProxy->GetAVQueueItems(getItems);
513 EXPECT_EQ(ret, AVSESSION_SUCCESS);
514 SLOGI("GetAVQueueItems002, end");
515 }
516
517 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
518 /**
519 * @tc.name: GetAVCastController001
520 * @tc.desc: Test GetAVCastController
521 * @tc.type: FUNC
522 */
523 static HWTEST_F(AVSessionProxyTest, GetAVCastController001, testing::ext::TestSize.Level1)
524 {
525 SLOGI("GetAVCastController001, start");
526 auto ret = g_AVSessionProxy->GetAVCastController();
527 EXPECT_EQ(ret, nullptr);
528 SLOGI("GetAVCastController001, end");
529 }
530
531 /**
532 * @tc.name: GetAllCastDisplays001
533 * @tc.desc: Test GetAllCastDisplays
534 * @tc.type: FUNC
535 */
536 static HWTEST_F(AVSessionProxyTest, GetAllCastDisplays001, testing::ext::TestSize.Level1)
537 {
538 SLOGI("GetAllCastDisplays001, start");
539 std::vector<CastDisplayInfo> castDisplays;
540 auto ret = g_AVSessionProxy->GetAllCastDisplays(castDisplays);
541 EXPECT_EQ(ret, AVSESSION_SUCCESS);
542 SLOGI("GetAllCastDisplays001, end");
543 }
544 #endif
545
546 } //OHOS::AVSESSION