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