1 /*
2 * Copyright (c) 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 #include <cstring>
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 "avsession_service.h"
42 #include "avsession_service_proxy.h"
43
44 using namespace testing::ext;
45 using namespace OHOS::AVSession;
46 using namespace OHOS::Security::AccessToken;
47 using namespace OHOS::AudioStandard;
48
49 static char g_testSessionTag[] = "test";
50 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
51 static char g_testAnotherAbilityName[] = "testAnother.ability";
52 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
53
54 class AVSessionServiceAddedTest : public testing::Test {
55 public:
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp() override;
59 void TearDown() override;
60 };
61
SetUpTestCase()62 void AVSessionServiceAddedTest::SetUpTestCase() {}
63
TearDownTestCase()64 void AVSessionServiceAddedTest::TearDownTestCase() {}
65
SetUp()66 void AVSessionServiceAddedTest::SetUp()
67 {
68 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
69 g_AVSessionService->InitKeyEvent();
70 }
71
TearDown()72 void AVSessionServiceAddedTest::TearDown()
73 {
74 if (g_AVSessionService != nullptr) {
75 g_AVSessionService->Close();
76 }
77 }
78
79 class AVSessionListenerMock : public SessionListener {
80 public:
OnSessionCreate(const AVSessionDescriptor & descriptor)81 void OnSessionCreate(const AVSessionDescriptor& descriptor) override {}
OnSessionRelease(const AVSessionDescriptor & descriptor)82 void OnSessionRelease(const AVSessionDescriptor& descriptor) override {}
OnTopSessionChange(const AVSessionDescriptor & descriptor)83 void OnTopSessionChange(const AVSessionDescriptor& descriptor) override {}
OnAudioSessionChecked(const int32_t uid)84 void OnAudioSessionChecked(const int32_t uid) override {}
OnDeviceAvailable(const OutputDeviceInfo & castOutputDeviceInfo)85 void OnDeviceAvailable(const OutputDeviceInfo& castOutputDeviceInfo) override {}
OnDeviceOffline(const std::string & deviceId)86 void OnDeviceOffline(const std::string& deviceId) override {}
~AVSessionListenerMock()87 ~AVSessionListenerMock() override {}
88 };
89
90 /**
91 * @tc.name: SuperLauncher001
92 * @tc.desc: Verifying NotifyFlowControl with a non-full flow control list.
93 * @tc.type: FUNC
94 * @tc.require: #I5Y4MZ
95 */
96 static HWTEST_F(AVSessionServiceAddedTest, SuperLauncher001, TestSize.Level0)
97 {
98 SLOGD("SuperLauncher001 begin!");
99 std::string deviceId = "IDLE";
100 std::string serviceName = "SuperLauncher-Dual";
101 std::string extraInfo = "extra";
102 const std::string& state = "CONNECTING";
103 g_AVSessionService->migrateAVSession_ = nullptr;
104 g_AVSessionService->SuperLauncher(deviceId, serviceName, extraInfo, state);
105 ASSERT_TRUE(g_AVSessionService != nullptr);
106 SLOGD("SuperLauncher001 end!");
107 }
108
109 /**
110 * @tc.name: SuperLauncher002
111 * @tc.desc: Verifying NotifyFlowControl with a non-full flow control list.
112 * @tc.type: FUNC
113 * @tc.require: #I5Y4MZ
114 */
115 static HWTEST_F(AVSessionServiceAddedTest, SuperLauncher002, TestSize.Level0)
116 {
117 SLOGD("SuperLauncher002 begin!");
118 std::string deviceId = "NOTIDLE";
119 std::string serviceName = "SuperLauncher-Dual";
120 std::string extraInfo = "extra";
121 const std::string& state = "CONNECTING";
122 g_AVSessionService->SuperLauncher(deviceId, serviceName, extraInfo, state);
123 g_AVSessionService->migrateAVSession_ = std::make_shared<MigrateAVSessionServer>();
124 ASSERT_TRUE(g_AVSessionService != nullptr);
125 SLOGD("SuperLauncher002 end!");
126 }
127
128
129 /**
130 * @tc.name: SuperLauncherTest003
131 * @tc.desc: Verifies the behavior of SuperLauncher for HuaweiCast service.
132 * @tc.type: FUNC
133 * @tc.require: #I5Y4MZ
134 */
135 static HWTEST_F(AVSessionServiceAddedTest, SuperLauncherTest003, TestSize.Level0)
136 {
137 SLOGD("SuperLauncherTest003 begin!");
138 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
139 std::string deviceId = "NOTIDLE";
140 std::string serviceName = "HuaweiCast";
141 std::string extraInfo = "extra";
142 const std::string& state = "IDLE";
143 g_AVSessionService->SuperLauncher(deviceId, serviceName, extraInfo, state);
144 g_AVSessionService->migrateAVSession_ = std::make_shared<MigrateAVSessionServer>();
145 #endif
146 ASSERT_TRUE(g_AVSessionService != nullptr);
147 SLOGD("SuperLauncherTest003 end!");
148 }
149
150 /**
151 * @tc.name: SuperLauncherTest004
152 * @tc.desc: Verifies the behavior of SuperLauncher for HuaweiCast service.
153 * @tc.type: FUNC
154 * @tc.require: #I5Y4MZ
155 */
156 static HWTEST_F(AVSessionServiceAddedTest, SuperLauncherTest004, TestSize.Level0)
157 {
158 SLOGD("SuperLauncherTest004 begin!");
159 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
160 SLOGD("SuperLauncherTest005 begin!");
161 std::string deviceId = "NOTIDLE";
162 std::string serviceName = "HuaweiCast";
163 std::string extraInfo = "extra";
164 const std::string& state = "CONNECT_SUCC";
165 g_AVSessionService->SuperLauncher(deviceId, serviceName, extraInfo, state);
166 g_AVSessionService->migrateAVSession_ = std::make_shared<MigrateAVSessionServer>();
167 g_AVSessionService->is2in1_ = true;
168 #endif
169 ASSERT_TRUE(g_AVSessionService != nullptr);
170 SLOGD("SuperLauncherTest004 end!");
171 }
172
173 /**
174 * @tc.name: SuperLauncherTest005
175 * @tc.desc: test SplitExtraInfo
176 * @tc.type: FUNC
177 * @tc.require: #I5Y4MZ
178 */
179 static HWTEST_F(AVSessionServiceAddedTest, SuperLauncherTest005, TestSize.Level0)
180 {
181 SLOGD("SuperLauncherTest005 begin!");
182 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
183 SLOGD("SuperLauncherTest006 begin!");
184 std::string deviceId = "test_device_id";
185 std::string serviceName = "HuaweiCast";
186 std::string extraInfo = "SUPPORT_MIRROR_TO_STREAM=true;deviceId:1001;deviceName:TestDevice;deviceType:5";
187 const std::string& state = "CONNECT_SUCC";
188 g_AVSessionService->SuperLauncher(deviceId, serviceName, extraInfo, state);
189 #endif
190 ASSERT_TRUE(g_AVSessionService != nullptr);
191 SLOGD("SuperLauncherTest005 end!");
192 }
193
194 /**
195 * @tc.name: checkEnableCast001
196 * @tc.desc: test checkEnableCast
197 * @tc.type: FUNC
198 * @tc.require: #I5Y4MZ
199 */
200 static HWTEST_F(AVSessionServiceAddedTest, checkEnableCast001, TestSize.Level0)
201 {
202 SLOGD("checkEnableCast001 begin!");
203 bool enable = true;
204 g_AVSessionService->isInCast_ = false;
205 auto ret = g_AVSessionService->checkEnableCast(enable);
206 EXPECT_EQ(ret, AVSESSION_SUCCESS);
207 SLOGD("checkEnableCast001 end!");
208 }
209
210 /**
211 * @tc.name: checkEnableCast002
212 * @tc.desc: test checkEnableCast
213 * @tc.type: FUNC
214 * @tc.require: #I5Y4MZ
215 */
216 static HWTEST_F(AVSessionServiceAddedTest, checkEnableCast002, TestSize.Level0)
217 {
218 SLOGD("checkEnableCast002 begin!");
219 bool enable = false;
220 g_AVSessionService->isInCast_ = true;
221 auto ret = g_AVSessionService->checkEnableCast(enable);
222 EXPECT_EQ(ret, AVSESSION_SUCCESS);
223 SLOGD("checkEnableCast002 end!");
224 }
225
226 /**
227 * @tc.name: StopCast001
228 * @tc.desc: test StopCast
229 * @tc.type: FUNC
230 * @tc.require: #I5Y4MZ
231 */
232 static HWTEST_F(AVSessionServiceAddedTest, StopCast001, TestSize.Level0)
233 {
234 SLOGD("StopCast001 begin!");
235 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
236 OHOS::AVSession::SessionToken sessionToken;
237 sessionToken.sessionId = "success";
238 sessionToken.pid = 1234;
239 sessionToken.uid = 5678;
240 auto ret = g_AVSessionService->StopCast(sessionToken);
241 EXPECT_EQ(ret, AVSESSION_SUCCESS);
242 #endif
243 SLOGD("StopCast001 end!");
244 }
245
246 /**
247 * @tc.name: ProcessTargetMigrateTest001
248 * @tc.desc: Test for deviceTypeId mismatch.
249 * @tc.type: FUNC
250 * @tc.require: #I5Y4MZ
251 */
252 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest001, TestSize.Level0)
253 {
254 SLOGD("ProcessTargetMigrateTest001 begin!");
255 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
256 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
257 bool isOnline = true;
258 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
259 EXPECT_FALSE(result);
260 SLOGD("ProcessTargetMigrateTest001 end!");
261 }
262
263 /**
264 * @tc.name: ProcessTargetMigrateTest002
265 * @tc.desc: Test when CheckWhetherTargetDevIsNext returns false.
266 * @tc.type: FUNC
267 * @tc.require: #I5Y4MZ
268 */
269 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest002, TestSize.Level0)
270 {
271 SLOGD("ProcessTargetMigrateTest002 begin!");
272 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
273 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
274 std::string name = "test";
275 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
276 deviceInfo.deviceName[name.size()] = '\0';
277 bool isOnline = true;
278 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
279 EXPECT_FALSE(result);
280 SLOGD("ProcessTargetMigrateTest002 end!");
281 }
282
283 /**
284 * @tc.name: ProcessTargetMigrateTest003
285 * @tc.desc: Test when both conditions fail.
286 * @tc.type: FUNC
287 * @tc.require: #I5Y4MZ
288 */
289 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest003, TestSize.Level0)
290 {
291 SLOGD("ProcessTargetMigrateTest003 begin!");
292 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
293 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
294 std::string name = "test";
295 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
296 deviceInfo.deviceName[name.size()] = '\0';
297 bool isOnline = true;
298 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
299 EXPECT_FALSE(result);
300 SLOGD("ProcessTargetMigrateTest003 end!");
301 }
302
303 /**
304 * @tc.name: ProcessTargetMigrateTest004
305 * @tc.desc: Test entering the else branch.
306 * @tc.type: FUNC
307 * @tc.require: #I5Y4MZ
308 */
309 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest004, TestSize.Level0)
310 {
311 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
312 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
313 std::string name = "valid";
314 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
315 deviceInfo.deviceName[name.size()] = '\0';
316 std::string extraData = "{\"OS_TYPE\":1}";
317 deviceInfo.extraData = extraData;
318 bool isOnline = true;
319 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
320 EXPECT_TRUE(result);
321 }
322
323 /**
324 * @tc.name: ProcessTargetMigrateTest005
325 * @tc.desc: Test entering the else branch.
326 * @tc.type: FUNC
327 * @tc.require: #I5Y4MZ
328 */
329 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest005, TestSize.Level0)
330 {
331 SLOGD("ProcessTargetMigrateTest005 begin!");
332 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
333 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
334 std::string name = "valid";
335 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
336 deviceInfo.deviceName[name.size()] = '\0';
337 std::string extraData = "{\"OS_TYPE\":1}";
338 deviceInfo.extraData = extraData;
339 bool isOnline = true;
340 g_AVSessionService->localDeviceType_ = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
341 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
342 EXPECT_TRUE(result);
343 SLOGD("ProcessTargetMigrateTest005 end!");
344 }
345
346 /**
347 * @tc.name: ProcessTargetMigrateTest006
348 * @tc.desc: Test entering the else branch.
349 * @tc.type: FUNC
350 * @tc.require: #I5Y4MZ
351 */
352 static HWTEST_F(AVSessionServiceAddedTest, ProcessTargetMigrateTest006, TestSize.Level0)
353 {
354 SLOGD("ProcessTargetMigrateTest006 begin!");
355 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
356 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
357 std::string name = "valid";
358 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
359 deviceInfo.deviceName[name.size()] = '\0';
360 std::string extraData = "{\"OS_TYPE\":1}";
361 deviceInfo.extraData = extraData;
362 bool isOnline = false;
363 bool result = g_AVSessionService->ProcessTargetMigrate(isOnline, deviceInfo);
364 EXPECT_TRUE(result);
365 SLOGD("ProcessTargetMigrateTest006 end!");
366 }
367
368 /**
369 * @tc.name: CheckWhetherTargetDevIsNextTest001
370 * @tc.desc: Test entering the second if branch but not the first inner branch.
371 * @tc.type: FUNC
372 * @tc.require: #I5Y4MZ
373 */
374 static HWTEST_F(AVSessionServiceAddedTest, CheckWhetherTargetDevIsNextTest001, TestSize.Level0)
375 {
376 SLOGD("CheckWhetherTargetDevIsNextTest001 begin!");
377 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
378 std::string extraData = "{\"OS_TYPE\":\"string_value\"}";
379 deviceInfo.extraData = extraData;
380 bool result = g_AVSessionService->CheckWhetherTargetDevIsNext(deviceInfo);
381 EXPECT_FALSE(result);
382 SLOGD("CheckWhetherTargetDevIsNextTest001 end!");
383 }
384
385 /**
386 * @tc.name: CheckWhetherTargetDevIsNextTest002
387 * @tc.desc: Test entering the first inner branch but not the second inner branch.
388 * @tc.type: FUNC
389 * @tc.require: #I5Y4MZ
390 */
391 static HWTEST_F(AVSessionServiceAddedTest, CheckWhetherTargetDevIsNextTest002, TestSize.Level0)
392 {
393 SLOGD("CheckWhetherTargetDevIsNextTest002 begin!");
394 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
395 std::string extraData = "{\"OS_TYPE\":-1}";
396 deviceInfo.extraData = extraData;
397 bool result = g_AVSessionService->CheckWhetherTargetDevIsNext(deviceInfo);
398 EXPECT_FALSE(result);
399 SLOGD("CheckWhetherTargetDevIsNextTest002 end!");
400 }
401
402 /**
403 * @tc.name: AVSessionDeviceStateCallbackTest_OnDeviceReady_001
404 * @tc.desc: Test entering the if branch of OnDeviceReady.
405 * @tc.type: FUNC
406 * @tc.require: #I5Y4MZ
407 */
408 static HWTEST_F(AVSessionServiceAddedTest, AVSessionDeviceStateCallbackTest_OnDeviceReady_001, TestSize.Level0)
409 {
410 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceReady_001 begin!");
411 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
412 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
413 std::string name = "valid";
414 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
415 deviceInfo.deviceName[name.size()] = '\0';
416 std::string extraData = "{\"OS_TYPE\":1}";
417 deviceInfo.extraData = extraData;
418 AVSessionDeviceStateCallback callback(g_AVSessionService.get());
419 callback.OnDeviceReady(deviceInfo);
420 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceReady_001 end!");
421 }
422
423 /**
424 * @tc.name: AVSessionDeviceStateCallbackTest_OnDeviceReady_002
425 * @tc.desc: Test not entering the if branch of OnDeviceReady.
426 * @tc.type: FUNC
427 * @tc.require: #I5Y4MZ
428 */
429 static HWTEST_F(AVSessionServiceAddedTest, AVSessionDeviceStateCallbackTest_OnDeviceReady_002, TestSize.Level0)
430 {
431 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceReady_002 begin!");
432 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
433 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
434 AVSessionDeviceStateCallback callback(g_AVSessionService.get());
435 callback.OnDeviceReady(deviceInfo);
436 ASSERT_TRUE(callback.servicePtr_ != nullptr);
437 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceReady_002 end!");
438 }
439
440 /**
441 * @tc.name: AVSessionDeviceStateCallbackTest_OnDeviceOffline_001
442 * @tc.desc: Test entering the if branch of OnDeviceOffline.
443 * @tc.type: FUNC
444 * @tc.require: #I5Y4MZ
445 */
446 static HWTEST_F(AVSessionServiceAddedTest, AVSessionDeviceStateCallbackTest_OnDeviceOffline_001, TestSize.Level0)
447 {
448 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceOffline_001 begin!");
449 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
450 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
451 std::string name = "valid";
452 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
453 deviceInfo.deviceName[name.size()] = '\0';
454 std::string extraData = "{\"OS_TYPE\":1}";
455 deviceInfo.extraData = extraData;
456 AVSessionDeviceStateCallback callback(g_AVSessionService.get());
457 callback.OnDeviceOffline(deviceInfo);
458 ASSERT_TRUE(callback.servicePtr_ != nullptr);
459 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceOffline_001 end!");
460 }
461
462 /**
463 * @tc.name: AVSessionDeviceStateCallbackTest_OnDeviceOffline_002
464 * @tc.desc: Test not entering the if branch of OnDeviceOffline.
465 * @tc.type: FUNC
466 * @tc.require: #I5Y4MZ
467 */
468 static HWTEST_F(AVSessionServiceAddedTest, AVSessionDeviceStateCallbackTest_OnDeviceOffline_002, TestSize.Level0)
469 {
470 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceOffline_002 begin!");
471 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
472 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
473 std::string name = "test";
474 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
475 deviceInfo.deviceName[name.size()] = '\0';
476 std::string extraData = "{\"OS_TYPE\":-1}";
477 deviceInfo.extraData = extraData;
478 AVSessionDeviceStateCallback callback(g_AVSessionService.get());
479 callback.OnDeviceOffline(deviceInfo);
480 ASSERT_TRUE(callback.servicePtr_ != nullptr);
481 SLOGD("AVSessionDeviceStateCallbackTest_OnDeviceOffline_002 end!");
482 }
483
484 /**
485 * @tc.name: DoRemoteAVSessionLoad_001
486 * @tc.desc: Test DoRemoteAVSessionLoad.
487 * @tc.type: FUNC
488 * @tc.require: #I5Y4MZ
489 */
490 static HWTEST_F(AVSessionServiceAddedTest, DoRemoteAVSessionLoad_001, TestSize.Level0)
491 {
492 SLOGD("DoRemoteAVSessionLoad_001 begin!");
493 std::string remoteDeviceId = "device";
494 g_AVSessionService->DoRemoteAVSessionLoad(remoteDeviceId);
495 ASSERT_TRUE(g_AVSessionService != nullptr);
496 SLOGD("DoRemoteAVSessionLoad_001 end!");
497 }
498
499 /**
500 * @tc.name: AVSessionServiceAddedTest_DoConnectProcessWithMigrate_001
501 * @tc.desc: Test entering the if branch of DoConnectProcessWithMigrate.
502 * @tc.type: FUNC
503 * @tc.require: #I5Y4MZ
504 */
505 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_DoConnectProcessWithMigrate_001, TestSize.Level0)
506 {
507 SLOGD("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_001 begin!");
508 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
509 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
510 std::string name = "valid";
511 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
512 deviceInfo.deviceName[name.size()] = '\0';
513 g_AVSessionService->localDeviceType_ = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
514 g_AVSessionService->DoConnectProcessWithMigrate(deviceInfo);
515 ASSERT_TRUE(g_AVSessionService != nullptr);
516 SLOGD("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_001 end!");
517 }
518
519 /**
520 * @tc.name: AVSessionServiceAddedTest_DoConnectProcessWithMigrate_002
521 * @tc.desc: Test not entering the if branch of DoConnectProcessWithMigrate.
522 * @tc.type: FUNC
523 * @tc.require: #I5Y4MZ
524 */
525 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_DoConnectProcessWithMigrate_002, TestSize.Level0)
526 {
527 SLOGD("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_002 begin!");
528 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
529 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
530 std::string name = "valid";
531 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
532 deviceInfo.deviceName[name.size()] = '\0';
533 g_AVSessionService->localDeviceType_ = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PAD;
534 g_AVSessionService->DoConnectProcessWithMigrate(deviceInfo);
535 ASSERT_TRUE(g_AVSessionService != nullptr);
536 SLOGD("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_002 end!");
537 }
538
539 /**
540 * @tc.name: AVSessionServiceAddedTest_DoConnectProcessWithMigrate_003
541 * @tc.desc: Test not entering the if branch of DoConnectProcessWithMigrate.
542 * @tc.type: FUNC
543 * @tc.require: #I5Y4MZ
544 */
545 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_DoConnectProcessWithMigrate_003, TestSize.Level0)
546 {
547 SLOGI("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_003 begin!");
548 ASSERT_TRUE(g_AVSessionService != nullptr);
549 OHOS::DistributedHardware::DmDeviceInfo deviceInfo;
550 deviceInfo.deviceTypeId = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_WATCH;
551 std::string name = "valid";
552 strcpy_s(deviceInfo.deviceName, name.size(), name.c_str());
553 deviceInfo.deviceName[name.size()] = '\0';
554 std::string networkId = "DEFAULT_NETWORKID";
555 strcpy_s(deviceInfo.networkId, networkId.size(), networkId.c_str());
556 deviceInfo.networkId[networkId.size()] = '\0';
557 g_AVSessionService->localDeviceType_ = OHOS::DistributedHardware::DmDeviceType::DEVICE_TYPE_PHONE;
558 std::shared_ptr<MigrateAVSessionServer> migrateAVSessionServer =
559 std::make_shared<MigrateAVSessionServer>(MIGRATE_MODE_NEXT, "DEFAULT_NETWORKID");
560 g_AVSessionService->migrateAVSessionServerMap_.insert({"DEFAULT_NETWORKID", migrateAVSessionServer});
561 int ret = g_AVSessionService->DoHisMigrateServerTransform("DEFAULT_NETWORKID");
562 EXPECT_EQ(ret, AVSESSION_SUCCESS);
563 g_AVSessionService->migrateAVSessionServerMap_.clear();
564 ret = g_AVSessionService->DoHisMigrateServerTransform("DEFAULT_NETWORKID");
565 EXPECT_EQ(ret, ERR_SESSION_NOT_EXIST);
566 g_AVSessionService->DoConnectProcessWithMigrate(deviceInfo);
567 SLOGI("AVSessionServiceAddedTest_DoConnectProcessWithMigrate_003 end!");
568 }
569
570 /**
571 * @tc.name: AVSessionServiceAddedTest_HandleUserEvent_001
572 * @tc.desc: set type to accountEventSwitched
573 * @tc.type: FUNC
574 * @tc.require: #I5Y4MZ
575 */
576 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleUserEvent_001, TestSize.Level0)
577 {
578 SLOGD("AVSessionServiceAddedTest_HandleUserEvent_001 begin!");
579 std::string type = "SWITCHED";
580 int userId = 1;
581 g_AVSessionService->HandleUserEvent(type, userId);
582 ASSERT_TRUE(g_AVSessionService != nullptr);
583 SLOGD("AVSessionServiceAddedTest_HandleUserEvent_001 end!");
584 }
585
586 /**
587 * @tc.name: AVSessionServiceAddedTest_HandleUserEvent_002
588 * @tc.desc: set type to accountEventRemoved
589 * @tc.type: FUNC
590 * @tc.require: #I5Y4MZ
591 */
592 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleUserEvent_002, TestSize.Level0)
593 {
594 SLOGD("AVSessionServiceAddedTest_HandleUserEvent_002 begin!");
595 std::string type = "REMOVED";
596 int userId = 1;
597 g_AVSessionService->HandleUserEvent(type, userId);
598 EXPECT_TRUE(g_AVSessionService != nullptr);
599 SLOGD("AVSessionServiceAddedTest_HandleUserEvent_002 end!");
600 }
601
602
603 /**
604 * @tc.name: AVSessionServiceAddedTest_GetPresentController_001
605 * @tc.desc: success to read data from file
606 * @tc.type: FUNC
607 * @tc.require: #I5Y4MZ
608 */
609 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_GetPresentController_001, TestSize.Level0)
610 {
611 SLOGD("AVSessionServiceAddedTest_GetPresentController_001 begin!");
612 pid_t pid = 2220;
613 std::string sessionId = "1234567890";
614 std::list<OHOS::sptr<AVControllerItem>> itemList;
615 itemList.push_back(nullptr);
616 g_AVSessionService->controllers_.insert({pid, itemList});
617 auto ret = g_AVSessionService->GetPresentController(pid, sessionId);
618 EXPECT_TRUE(ret == nullptr);
619 SLOGD("AVSessionServiceAddedTest_GetPresentController_001 end!");
620 }
621
622 /**
623 * @tc.name: AVSessionServiceAddedTest_NotifySessionRelease_001
624 * @tc.desc: success to read data from file
625 * @tc.type: FUNC
626 * @tc.require: #I5Y4MZ
627 */
628 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_NotifySessionRelease_001, TestSize.Level0)
629 {
630 SLOGD("AVSessionServiceAddedTest_NotifySessionRelease_001 begin!");
631 AVSessionDescriptor descriptor;
632 descriptor.userId_ = 1001;
633 descriptor.pid_ = 2001;
634
635 std::map<pid_t, OHOS::sptr<ISessionListener>> listenerMap =
636 g_AVSessionService->GetUsersManager().GetSessionListener(descriptor.userId_);
637 listenerMap.insert({descriptor.pid_, nullptr});
638
639 std::map<pid_t, OHOS::sptr<ISessionListener>> listenerMapForAll =
640 g_AVSessionService->GetUsersManager().GetSessionListenerForAllUsers();
641 listenerMapForAll.insert({descriptor.pid_, nullptr});
642
643 g_AVSessionService->innerSessionListeners_.push_back(nullptr);
644 g_AVSessionService->NotifySessionRelease(descriptor);
645 EXPECT_TRUE(g_AVSessionService->innerSessionListeners_.size() > 0);
646 SLOGD("AVSessionServiceAddedTest_NotifySessionRelease_001 end!");
647 }
648
649 /**
650 * @tc.name: AVSessionServiceAddedTest_NotifyTopSessionChanged_001
651 * @tc.desc: success to read data from file
652 * @tc.type: FUNC
653 * @tc.require: #I5Y4MZ
654 */
655 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_NotifyTopSessionChanged_001, TestSize.Level0)
656 {
657 SLOGD("AVSessionServiceAddedTest_NotifyTopSessionChanged_001 begin!");
658 AVSessionDescriptor descriptor;
659 descriptor.userId_ = 1002;
660 descriptor.pid_ = 2002;
661
662 std::map<pid_t, OHOS::sptr<ISessionListener>> listenerMap =
663 g_AVSessionService->GetUsersManager().GetSessionListener(descriptor.userId_);
664 listenerMap.insert({descriptor.pid_, nullptr});
665
666 std::map<pid_t, OHOS::sptr<ISessionListener>> listenerMapForAll =
667 g_AVSessionService->GetUsersManager().GetSessionListenerForAllUsers();
668 listenerMapForAll.insert({descriptor.pid_, nullptr});
669
670 auto listener = std::make_shared<AVSessionListenerMock>();
671 g_AVSessionService->innerSessionListeners_.push_back(listener.get());
672 g_AVSessionService->innerSessionListeners_.push_back(nullptr);
673 g_AVSessionService->NotifyTopSessionChanged(descriptor);
674 EXPECT_TRUE(g_AVSessionService->innerSessionListeners_.size() > 0);
675 SLOGD("AVSessionServiceAddedTest_NotifyTopSessionChanged_001 end!");
676 }
677
678 /**
679 * @tc.name: AVSessionServiceAddedTest_HandleRemoveMediaCardEvent_001
680 * @tc.desc: set IsCasting to true
681 * @tc.type: FUNC
682 * @tc.require: #I5Y4MZ
683 */
684 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleRemoveMediaCardEvent_001, TestSize.Level0)
685 {
686 SLOGD("AVSessionServiceAddedTest_HandleRemoveMediaCardEvent_001 begin!");
687 OHOS::AppExecFwk::ElementName elementName;
688 elementName.SetBundleName(g_testAnotherBundleName);
689 elementName.SetAbilityName(g_testAnotherAbilityName);
690 OHOS::sptr<AVSessionItem> avsessionItem =
691 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
692 avsessionItem->descriptor_.sessionTag_ = "test";
693 avsessionItem->castHandle_ = 1;
694 g_AVSessionService->UpdateTopSession(avsessionItem);
695 bool ret = g_AVSessionService->topSession_->IsCasting();
696 EXPECT_EQ(ret, true);
697 g_AVSessionService->HandleRemoveMediaCardEvent();
698 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
699 avsessionItem->Destroy();
700 SLOGD("AVSessionServiceAddedTest_HandleRemoveMediaCardEvent_001 end!");
701 }
702
703 /**
704 * @tc.name: AVSessionServiceAddedTest_HandleChangeTopSession_001
705 * @tc.desc: topSession_->GetUid() != ancoUid
706 * @tc.type: FUNC
707 * @tc.require: #I5Y4MZ
708 */
709 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleChangeTopSession_001, TestSize.Level0)
710 {
711 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_001 begin!");
712 OHOS::AppExecFwk::ElementName elementName;
713 elementName.SetBundleName(g_testAnotherBundleName);
714 elementName.SetAbilityName(g_testAnotherAbilityName);
715 OHOS::sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
716 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
717 EXPECT_EQ(avsessionItem != nullptr, true);
718 g_AVSessionService->UpdateTopSession(avsessionItem);
719 int32_t infoUid = 0;
720 int32_t userId = 0;
721 int32_t infoPid = 0;
722 g_AVSessionService->HandleChangeTopSession(infoUid, infoPid, userId);
723 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
724 avsessionItem->Destroy();
725 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_001 end!");
726 }
727
728 /**
729 * @tc.name: AVSessionServiceAddedTest_HandleChangeTopSession_002
730 * @tc.desc: able to pass the fisrt judgement
731 * @tc.type: FUNC
732 * @tc.require: #I5Y4MZ
733 */
734 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleChangeTopSession_002, TestSize.Level0)
735 {
736 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_002 begin!");
737 OHOS::AppExecFwk::ElementName elementName;
738 elementName.SetBundleName(g_testAnotherBundleName);
739 elementName.SetAbilityName(g_testAnotherAbilityName);
740 OHOS::sptr<AVSessionItem> avsessionItem =
741 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
742 EXPECT_EQ(avsessionItem != nullptr, true);
743
744 int32_t infoUid = 0;
745 avsessionItem->SetUid(infoUid);
746 bool check = avsessionItem->GetUid() == infoUid && avsessionItem->GetSessionType() != "voice_call"
747 && avsessionItem->GetSessionType() != "video_call";
748 EXPECT_EQ(check, true);
749 g_AVSessionService->UpdateTopSession(avsessionItem);
750
751 int32_t userId = 0;
752 int32_t infoPid = 0;
753 g_AVSessionService->HandleChangeTopSession(infoUid, infoPid, userId);
754 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
755 avsessionItem->Destroy();
756 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_002 end!");
757 }
758
759 /**
760 * @tc.name: AVSessionServiceAddedTest_HandleChangeTopSession_003
761 * @tc.desc: avsessionItem->GetSessionType() == "voice_call"
762 * @tc.type: FUNC
763 * @tc.require: #I5Y4MZ
764 */
765 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleChangeTopSession_003, TestSize.Level0)
766 {
767 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_003 begin!");
768 OHOS::AppExecFwk::ElementName elementName;
769 elementName.SetBundleName(g_testAnotherBundleName);
770 elementName.SetAbilityName(g_testAnotherAbilityName);
771 OHOS::sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
772 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
773 EXPECT_EQ(avsessionItem != nullptr, true);
774
775 int32_t infoUid = 0;
776 avsessionItem->SetUid(infoUid);
777 bool check = avsessionItem->GetUid() == infoUid && avsessionItem->GetSessionType() != "voice_call"
778 && avsessionItem->GetSessionType() != "video_call";
779 EXPECT_EQ(check, false);
780 g_AVSessionService->UpdateTopSession(avsessionItem);
781
782 int32_t userId = 0;
783 int32_t infoPid = 0;
784 g_AVSessionService->HandleChangeTopSession(infoUid, infoPid, userId);
785 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
786 avsessionItem->Destroy();
787 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_003 end!");
788 }
789
790 /**
791 * @tc.name: AVSessionServiceAddedTest_HandleChangeTopSession_004
792 * @tc.desc: avsessionItem->GetSessionType() == "video_call"
793 * @tc.type: FUNC
794 * @tc.require: #I5Y4MZ
795 */
796 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleChangeTopSession_004, TestSize.Level0)
797 {
798 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_004 begin!");
799 OHOS::AppExecFwk::ElementName elementName;
800 elementName.SetBundleName(g_testAnotherBundleName);
801 elementName.SetAbilityName(g_testAnotherAbilityName);
802 OHOS::sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
803 AVSession::SESSION_TYPE_VIDEO_CALL, false, elementName);
804 EXPECT_EQ(avsessionItem != nullptr, true);
805
806 int32_t infoUid = 0;
807 avsessionItem->SetUid(infoUid);
808 bool check = avsessionItem->GetUid() == infoUid && avsessionItem->GetSessionType() != "voice_call"
809 && avsessionItem->GetSessionType() != "video_call";
810 EXPECT_EQ(check, false);
811 g_AVSessionService->UpdateTopSession(avsessionItem);
812
813 int32_t userId = 0;
814 int32_t infoPid = 0;
815 g_AVSessionService->HandleChangeTopSession(infoUid, infoPid, userId);
816 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
817 avsessionItem->Destroy();
818 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_004 end!");
819 }
820
821 /**
822 * @tc.name: AVSessionServiceAddedTest_HandleChangeTopSession_005
823 * @tc.desc: set infoUid qual to ancoUid
824 * @tc.type: FUNC
825 * @tc.require: #I5Y4MZ
826 */
827 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_HandleChangeTopSession_005, TestSize.Level0)
828 {
829 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_005 begin!");
830 OHOS::AppExecFwk::ElementName elementName;
831 elementName.SetBundleName(g_testAnotherBundleName);
832 elementName.SetAbilityName(g_testAnotherAbilityName);
833 OHOS::sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
834 AVSession::SESSION_TYPE_VIDEO, false, elementName);
835 EXPECT_EQ(avsessionItem != nullptr, true);
836
837 int32_t ancoUid = 1041;
838 avsessionItem->SetUid(ancoUid);
839 bool check = avsessionItem->GetUid() == ancoUid && avsessionItem->GetSessionType() != "voice_call"
840 && avsessionItem->GetSessionType() != "video_call";
841 EXPECT_EQ(check, true);
842 g_AVSessionService->UpdateTopSession(avsessionItem);
843
844 int32_t userId = 0;
845 int32_t infoPid = 0;
846 g_AVSessionService->HandleChangeTopSession(ancoUid, infoPid, userId);
847 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
848 avsessionItem->Destroy();
849 SLOGD("AVSessionServiceAddedTest_HandleChangeTopSession_005 end!");
850 }
851
852 /**
853 * @tc.name: AVSessionServiceAddedTest_RegisterBundleDeleteEventForHistory_001
854 * @tc.desc: success to read data from file
855 * @tc.type: FUNC
856 * @tc.require: #I5Y4MZ
857 */
858 static HWTEST_F(AVSessionServiceAddedTest, RegisterBundleDeleteEventForHistory_001, TestSize.Level0)
859 {
860 SLOGD("AVSessionServiceAddedTest_RegisterBundleDeleteEventForHistory_001 begin!");
861 OHOS::AppExecFwk::ElementName elementName;
862 elementName.SetBundleName(g_testAnotherBundleName);
863 elementName.SetAbilityName(g_testAnotherAbilityName);
864 OHOS::sptr<AVSessionItem> avsessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
865 AVSession::SESSION_TYPE_VIDEO, false, elementName);
866 EXPECT_EQ(avsessionItem != nullptr, true);
867
868 int32_t ancoUid = 1041;
869 avsessionItem->SetUid(ancoUid);
870 std::string filePath = g_AVSessionService->GetAVSortDir(ancoUid);
871 std::ofstream ofs;
872 ofs.open(filePath, std::ios::out);
873 std::string jsonStr = R"(
874 {"bundleName", "test"}
875 )";
876 ofs << jsonStr;
877 ofs.close();
878
879 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
880 avsessionItem->Destroy();
881 SLOGD("AVSessionServiceAddedTest_RegisterBundleDeleteEventForHistory_001 end!");
882 }
883
884 /**
885 * @tc.name: AVSessionServiceAddedTest_LowQualityCheck_001
886 * @tc.desc: (hasTitle || hasImage) is true
887 * @tc.type: FUNC
888 * @tc.require: #I5Y4MZ
889 */
890 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_LowQualityCheck_001, TestSize.Level0)
891 {
892 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_001 begin!");
893 OHOS::AppExecFwk::ElementName elementName;
894 elementName.SetBundleName(g_testAnotherBundleName);
895 elementName.SetAbilityName(g_testAnotherAbilityName);
896 OHOS::sptr<AVSessionItem> avsessionItem =
897 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
898 EXPECT_EQ(avsessionItem != nullptr, true);
899
900 pid_t uid = avsessionItem->GetUid();
901 pid_t pid = avsessionItem->GetPid();
902 AVMetaData meta;
903 meta.SetTitle("test");
904 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
905 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
906 mediaImage->SetInnerImgBuffer(imgBuffer);
907 meta.SetMediaImage(mediaImage);
908 meta.SetMediaImageUri("test");
909 avsessionItem->SetAVMetaData(meta);
910
911 OHOS::AudioStandard::StreamUsage streamUsage = OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MEDIA;
912 OHOS::AudioStandard::RendererState rendererState = OHOS::AudioStandard::RendererState::RENDERER_PAUSED;
913 g_AVSessionService->LowQualityCheck(uid, pid, streamUsage, rendererState);
914 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
915 avsessionItem->Destroy();
916 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_001 end!");
917 }
918
919 /**
920 * @tc.name: AVSessionServiceAddedTest_LowQualityCheck_002
921 * @tc.desc: title is empty
922 * @tc.type: FUNC
923 * @tc.require: #I5Y4MZ
924 */
925 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_LowQualityCheck_002, TestSize.Level0)
926 {
927 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_002 begin!");
928 OHOS::AppExecFwk::ElementName elementName;
929 elementName.SetBundleName(g_testAnotherBundleName);
930 elementName.SetAbilityName(g_testAnotherAbilityName);
931 OHOS::sptr<AVSessionItem> avsessionItem =
932 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
933 EXPECT_EQ(avsessionItem != nullptr, true);
934
935 pid_t uid = avsessionItem->GetUid();
936 pid_t pid = avsessionItem->GetPid();
937 AVMetaData meta;
938 std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
939 std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
940 mediaImage->SetInnerImgBuffer(imgBuffer);
941 meta.SetMediaImage(mediaImage);
942 meta.SetMediaImageUri("test");
943 avsessionItem->SetAVMetaData(meta);
944
945 OHOS::AudioStandard::StreamUsage streamUsage = OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MEDIA;
946 OHOS::AudioStandard::RendererState rendererState = OHOS::AudioStandard::RendererState::RENDERER_PAUSED;
947 g_AVSessionService->LowQualityCheck(uid, pid, streamUsage, rendererState);
948 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
949 avsessionItem->Destroy();
950 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_002 end!");
951 }
952
953 /**
954 * @tc.name: AVSessionServiceAddedTest_LowQualityCheck_003
955 * @tc.desc: MediaImage is empty
956 * @tc.type: FUNC
957 * @tc.require: #I5Y4MZ
958 */
959 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_LowQualityCheck_003, TestSize.Level0)
960 {
961 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_003 begin!");
962 OHOS::AppExecFwk::ElementName elementName;
963 elementName.SetBundleName(g_testAnotherBundleName);
964 elementName.SetAbilityName(g_testAnotherAbilityName);
965 OHOS::sptr<AVSessionItem> avsessionItem =
966 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
967 EXPECT_EQ(avsessionItem != nullptr, true);
968
969 pid_t uid = avsessionItem->GetUid();
970 pid_t pid = avsessionItem->GetPid();
971 AVMetaData meta;
972 meta.SetTitle("test");
973
974 OHOS::AudioStandard::StreamUsage streamUsage = OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MEDIA;
975 OHOS::AudioStandard::RendererState rendererState = OHOS::AudioStandard::RendererState::RENDERER_PAUSED;
976 g_AVSessionService->LowQualityCheck(uid, pid, streamUsage, rendererState);
977 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
978 avsessionItem->Destroy();
979 SLOGD("AVSessionServiceAddedTest_LowQualityCheck_003 end!");
980 }
981
982 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
983 /**
984 * @tc.name: AVSessionServiceAddedTest_AddCapsuleServiceCallback_001
985 * @tc.desc: MediaImage is empty
986 * @tc.type: FUNC
987 * @tc.require: #I5Y4MZ
988 */
989 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_AddCapsuleServiceCallback_001, TestSize.Level0)
990 {
991 SLOGD("AVSessionServiceAddedTest_AddCapsuleServiceCallback_001 begin!");
992 OHOS::AppExecFwk::ElementName elementName;
993 elementName.SetBundleName(g_testAnotherBundleName);
994 elementName.SetAbilityName(g_testAnotherAbilityName);
995 OHOS::sptr<AVSessionItem> avsessionItem =
996 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
997 EXPECT_EQ(avsessionItem != nullptr, true);
998
999 g_AVSessionService->AddCapsuleServiceCallback(avsessionItem);
1000 auto callback = avsessionItem->serviceCallbackForCastNtf_;
1001 std::string sessionId = "test";
1002 bool isPlaying = true;
1003 bool isChange = true;
1004 callback(sessionId, isPlaying, isChange);
1005
1006 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
1007 avsessionItem->Destroy();
1008 SLOGD("AVSessionServiceAddedTest_AddCapsuleServiceCallback_001 end!");
1009 }
1010 #endif // CASTPLUS_CAST_ENGINE_ENABLE
1011
1012 /**
1013 * @tc.name: AVSessionServiceAddedTest_AddKeyEventServiceCallback_001
1014 * @tc.desc: MediaImage is empty
1015 * @tc.type: FUNC
1016 * @tc.require: #I5Y4MZ
1017 */
1018 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_AddKeyEventServiceCallback_001, TestSize.Level0)
1019 {
1020 SLOGD("AVSessionServiceAddedTest_AddKeyEventServiceCallback_001 begin!");
1021 OHOS::AppExecFwk::ElementName elementName;
1022 elementName.SetBundleName(g_testAnotherBundleName);
1023 elementName.SetAbilityName(g_testAnotherAbilityName);
1024 OHOS::sptr<AVSessionItem> avsessionItem =
1025 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
1026 EXPECT_EQ(avsessionItem != nullptr, true);
1027
1028 g_AVSessionService->AddKeyEventServiceCallback(avsessionItem);
1029 auto callback = avsessionItem->serviceCallbackForKeyEvent_;
1030 std::string sessionId = "test";
1031 callback(sessionId);
1032
1033 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
1034 avsessionItem->Destroy();
1035 SLOGD("AVSessionServiceAddedTest_AddKeyEventServiceCallback_001 end!");
1036 }
1037
1038 /**
1039 * @tc.name: AVSessionServiceAddedTest_IsCapsuleNeeded_001
1040 * @tc.desc: MediaImage is empty
1041 * @tc.type: FUNC
1042 * @tc.require: #I5Y4MZ
1043 */
1044 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_IsCapsuleNeeded_001, TestSize.Level0)
1045 {
1046 SLOGD("AVSessionServiceAddedTest_IsCapsuleNeeded_001 begin!");
1047 OHOS::AppExecFwk::ElementName elementName;
1048 elementName.SetBundleName(g_testAnotherBundleName);
1049 elementName.SetAbilityName(g_testAnotherAbilityName);
1050 OHOS::sptr<AVSessionItem> avsessionItem =
1051 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_VIDEO, false, elementName);
1052 EXPECT_EQ(avsessionItem != nullptr, true);
1053 g_AVSessionService->UpdateTopSession(avsessionItem);
1054
1055 bool ret = g_AVSessionService->IsCapsuleNeeded();
1056 EXPECT_EQ(ret, false);
1057 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
1058 avsessionItem->Destroy();
1059 SLOGD("AVSessionServiceAddedTest_IsCapsuleNeeded_001 end!");
1060 }
1061
1062 /**
1063 * @tc.name: StartDefaultAbilityByCall001
1064 * @tc.desc: read data from AVSortDir
1065 * @tc.type: FUNC
1066 * @tc.require: #I5Y4MZ
1067 */
1068 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_StartDefaultAbilityByCall_001, TestSize.Level0)
1069 {
1070 SLOGI("StartDefaultAbilityByCall001 begin!");
1071 OHOS::AppExecFwk::ElementName elementName;
1072 elementName.SetBundleName(g_testAnotherBundleName);
1073 elementName.SetAbilityName(g_testAnotherAbilityName);
1074 OHOS::sptr<AVSessionItem> avsessionItem =
1075 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1076
1077 std::string filePath = g_AVSessionService->GetAVSortDir();
1078 std::ofstream ofs;
1079 ofs.open(filePath, std::ios::out);
1080 std::string jsonStr = R"({
1081 "bundleName": "test",
1082 "sessionId": "12345",
1083 "test": "",
1084 })";
1085 ofs << jsonStr;
1086 ofs.close();
1087
1088 std::string sessionId = avsessionItem->GetSessionId();
1089 int32_t ret = g_AVSessionService->StartDefaultAbilityByCall(sessionId);
1090 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS || ret == AVSESSION_ERROR, true);
1091 g_AVSessionService->HandleSessionRelease(sessionId);
1092 avsessionItem->Destroy();
1093 SLOGI("StartDefaultAbilityByCall001 end!");
1094 }
1095
1096 /**
1097 * @tc.name: StartAbilityByCall001
1098 * @tc.desc: read data from AVSortDir and get sessionIdNeeded
1099 * @tc.type: FUNC
1100 * @tc.require: #I5Y4MZ
1101 */
1102 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_StartAbilityByCall_001, TestSize.Level0)
1103 {
1104 SLOGI("StartAbilityByCall001 begin!");
1105 OHOS::AppExecFwk::ElementName elementName;
1106 elementName.SetBundleName(g_testAnotherBundleName);
1107 elementName.SetAbilityName(g_testAnotherAbilityName);
1108 OHOS::sptr<AVSessionItem> avsessionItem =
1109 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1110
1111 std::string filePath = g_AVSessionService->GetAVSortDir();
1112 std::ofstream ofs;
1113 ofs.open(filePath, std::ios::out);
1114 std::string jsonStr = R"({
1115 "bundleName": "test",
1116 "sessionId": "12345",
1117 "abilityName": "test",
1118 })";
1119 ofs << jsonStr;
1120 ofs.close();
1121
1122 std::string sessionIdNeeded = "12345";
1123 std::string sessionId = avsessionItem->GetSessionId();
1124 int32_t ret = g_AVSessionService->StartAbilityByCall(sessionIdNeeded, sessionId);
1125 EXPECT_EQ(ret == ERR_ABILITY_NOT_AVAILABLE || ret == AVSESSION_SUCCESS || ret == AVSESSION_ERROR, true);
1126 g_AVSessionService->HandleSessionRelease(sessionId);
1127 avsessionItem->Destroy();
1128 SLOGI("StartAbilityByCall001 end!");
1129 }
1130
1131 /**
1132 * @tc.name: AVSessionServiceAddedTest_GetLocalTitle_001
1133 * @tc.desc: success to get title
1134 * @tc.type: FUNC
1135 * @tc.require: #I5Y4MZ
1136 */
1137 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_GetLocalTitle_001, TestSize.Level0)
1138 {
1139 SLOGI("AVSessionServiceAddedTest_GetLocalTitle_001 begin!");
1140 OHOS::AppExecFwk::ElementName elementName;
1141 elementName.SetBundleName(g_testAnotherBundleName);
1142 elementName.SetAbilityName(g_testAnotherAbilityName);
1143 OHOS::sptr<AVSessionItem> avsessionItem =
1144 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1145 EXPECT_TRUE(avsessionItem != nullptr);
1146 g_AVSessionService->UpdateTopSession(avsessionItem);
1147
1148 auto title = g_AVSessionService->GetLocalTitle();
1149 EXPECT_TRUE(title.empty());
1150
1151 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
1152 avsessionItem->Destroy();
1153 SLOGI("AVSessionServiceAddedTest_GetLocalTitle_001 end!");
1154 }
1155
1156 /**
1157 * @tc.name: AVSessionServiceAddedTest_NotifySystemUI_001
1158 * @tc.desc: addCapsule && topSession_ is true
1159 * @tc.type: FUNC
1160 * @tc.require: #I5Y4MZ
1161 */
1162 static HWTEST_F(AVSessionServiceAddedTest, AVSessionServiceAddedTest_NotifySystemUI_001, TestSize.Level0)
1163 {
1164 SLOGI("AVSessionServiceAddedTest_NotifySystemUI_001 begin!");
1165 OHOS::AppExecFwk::ElementName elementName;
1166 elementName.SetBundleName(g_testAnotherBundleName);
1167 elementName.SetAbilityName(g_testAnotherAbilityName);
1168 OHOS::sptr<AVSessionItem> avsessionItem =
1169 g_AVSessionService->CreateSessionInner(g_testSessionTag, AVSession::SESSION_TYPE_AUDIO, false, elementName);
1170 EXPECT_TRUE(avsessionItem != nullptr);
1171 g_AVSessionService->UpdateTopSession(avsessionItem);
1172
1173 auto historyDescriptor = std::make_shared<AVSessionDescriptor>();
1174 bool isActiveSession = true;
1175 bool addCapsule = true;
1176 bool isCapsuleUpdate = true;
1177 g_AVSessionService->NotifySystemUI(historyDescriptor.get(),
1178 isActiveSession, addCapsule, isCapsuleUpdate);
1179 bool ret = addCapsule && g_AVSessionService->topSession_;
1180 EXPECT_EQ(ret, true);
1181
1182 g_AVSessionService->HandleSessionRelease(avsessionItem->GetSessionId());
1183 avsessionItem->Destroy();
1184 SLOGI("AVSessionServiceAddedTest_NotifySystemUI_001 end!");
1185 }