1 /*
2 * Copyright (c) 2023 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 <chrono>
18 #include <thread>
19
20 #include "cJSON.h"
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 #include "token_setproc.h"
24 #include "avmeta_data.h"
25 #include "avplayback_state.h"
26 #include "avsession_errors.h"
27 #include "avsession_item.h"
28 #include "avsession_log.h"
29 #include "migrate_avsession_constant.h"
30 #include "system_ability_definition.h"
31 #define private public
32 #define protected public
33 #include "avsession_service.h"
34 #include "migrate_avsession_manager.h"
35 #undef protected
36 #undef private
37 #include "softbus/softbus_session_utils.h"
38
39 using namespace testing::ext;
40 using namespace OHOS::AVSession;
41
42 static const char* g_perms[] = {"ohos.permission.DISTRIBUTED_SOFTBUS_CENTER", "ohos.permission.DISTRIBUTED_DATASYNC",
43 "ohos.permission.ACCESS_SERVICE_DM"};
44 static const int SIZE = 3;
45 static const int64_t TEST_DURATION = 40000;
46 static const double TEST_SPEED = 1.5;
47 static const int64_t TEST_BUFFERED_TIME = 60000;
48 static const int32_t TEST_LOOG_MODE = 2;
49 static std::shared_ptr<MigrateAVSessionServer> server_;
50 static AVSessionService *avservice_ ;
51
52 class MigrateAVSessionTest : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp();
57 void TearDown();
58 void NativeTokenGet(const char *perms[], int size);
59 };
60
SetUpTestCase()61 void MigrateAVSessionTest::SetUpTestCase()
62 {
63 SLOGI("MigrateAVSessionTest SetUpTestCase");
64 server_ = std::make_shared<MigrateAVSessionServer>();
65 avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
66 }
67
TearDownTestCase()68 void MigrateAVSessionTest::TearDownTestCase()
69 {
70 SLOGI("MigrateAVSessionTest TearDownTestCase");
71 server_ = nullptr;
72 avservice_ = nullptr;
73 }
74
SetUp()75 void MigrateAVSessionTest::SetUp()
76 {
77 SLOGI("MigrateAVSessionTest SetUp");
78 NativeTokenGet(g_perms, SIZE);
79 }
80
TearDown()81 void MigrateAVSessionTest::TearDown()
82 {
83 SLOGI("MigrateAVSessionTest TearDown");
84 NativeTokenGet(nullptr, 0);
85 }
86
NativeTokenGet(const char * perms[],int size)87 void MigrateAVSessionTest::NativeTokenGet(const char *perms[], int size)
88 {
89 uint64_t tokenId;
90 NativeTokenInfoParams infoInstance = {
91 .dcapsNum = 0,
92 .permsNum = size,
93 .aclsNum = 0,
94 .dcaps = nullptr,
95 .perms = perms,
96 .acls = nullptr,
97 .aplStr = "system_basic",
98 };
99
100 infoInstance.processName = "migrate_softbus_test";
101 tokenId = GetAccessTokenId(&infoInstance);
102 SetSelfTokenID(tokenId);
103 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
104 }
105
106 /**
107 * @tc.name: GetCharacteristic001
108 * @tc.desc:
109 * @tc.type: FUNC
110 * @tc.require:
111 */
112 static HWTEST_F(MigrateAVSessionTest, GetCharacteristic001, TestSize.Level0)
113 {
114 SLOGI("GetCharacteristic001 begin");
115 int32_t ret = server_->GetCharacteristic();
116 EXPECT_EQ(ret, MSG_HEAD_MODE);
117 SLOGI("GetCharacteristic001 end");
118 }
119
120 /**
121 * @tc.name: ResetSupportCrossMediaPlay001
122 * @tc.desc:
123 * @tc.type: FUNC
124 * @tc.require:
125 */
126 static HWTEST_F(MigrateAVSessionTest, ResetSupportCrossMediaPlay001, TestSize.Level0)
127 {
128 SLOGI("ResetSupportCrossMediaPlay001 begin");
129 server_->ResetSupportCrossMediaPlay("");
130 EXPECT_EQ(server_->supportCrossMediaPlay_, false);
131 SLOGI("ResetSupportCrossMediaPlay001 end");
132 }
133
SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)134 void SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)
135 {
136 SLOGI("MigrateTest001 SetMetaDataAndPlaybackState");
137 AVMetaData metaData;
138 metaData.Reset();
139 metaData.SetAssetId("123");
140 metaData.SetTitle("Black Humor");
141 metaData.SetArtist("zhoujielun");
142 metaData.SetAuthor("zhoujielun");
143 metaData.SetAlbum("Jay");
144 metaData.SetWriter("zhoujielun");
145 metaData.SetComposer("zhoujielun");
146 metaData.SetDuration(TEST_DURATION);
147 metaData.SetMediaImageUri("xxxxx");
148 metaData.SetSubTitle("fac");
149 metaData.SetDescription("for friends");
150 metaData.SetLyric("xxxxx");
151 avsession_->SetAVMetaData(metaData);
152
153 AVPlaybackState playbackState;
154 playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
155 playbackState.SetSpeed(TEST_SPEED);
156 playbackState.SetPosition({ 80000, 0 });
157 playbackState.SetBufferedTime(TEST_BUFFERED_TIME);
158 playbackState.SetLoopMode(TEST_LOOG_MODE);
159 playbackState.SetFavorite(true);
160 avsession_->SetAVPlaybackState(playbackState);
161 }
162
TestMigrateConnect(AVSessionService * avservice_,std::shared_ptr<MigrateAVSessionServer> server_,std::shared_ptr<MigrateAVSessionManager> migrateManager_,int32_t sessionId,std::string deviceId)163 void TestMigrateConnect(AVSessionService *avservice_, std::shared_ptr<MigrateAVSessionServer> server_,
164 std::shared_ptr<MigrateAVSessionManager> migrateManager_, int32_t sessionId, std::string deviceId)
165 {
166 SLOGI("MigrateTest001 TestMigrateConnect");
167 avservice_->SuperLauncher("", "SuperLauncher-Dual", "", "CONNECTING");
168 avservice_->AddInnerSessionListener(server_.get());
169
170 server_->Init(avservice_);
171 migrateManager_->CreateLocalSessionStub("SuperLauncher-Dual", server_);
172 EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher-Dual") != migrateManager_->serverMap_.end(), true);
173
174 char infoName[] = "Media_Session_RemoteCtrl";
175 char infoNetworkId[] = "testInfoNetworkId";
176 char infoPkgName[] = "testInfoPkgName";
177 PeerSocketInfo info = {
178 .name = infoName,
179 .networkId = infoNetworkId,
180 .pkgName = infoPkgName,
181 .dataType = DATA_TYPE_BYTES,
182 };
183 migrateManager_->softBusDistributedDataMgr_->SessionOpened(sessionId, info);
184 migrateManager_->softBusDistributedDataMgr_->OnSessionServerOpened();
185 migrateManager_->softBusDistributedDataMgr_->MessageReceived(sessionId, "default");
186 migrateManager_->softBusDistributedDataMgr_->OnMessageHandleReceived(sessionId, "default");
187 server_->ConnectProxy(sessionId);
188 server_->OnConnectSession(sessionId);
189 server_->OnConnectProxy(deviceId);
190 EXPECT_EQ(server_->isSoftbusConnecting_, true);
191 }
192
TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_,std::shared_ptr<MigrateAVSessionServer> server_,std::string deviceId)193 void TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_, std::shared_ptr<MigrateAVSessionServer> server_,
194 std::string deviceId)
195 {
196 SLOGI("MigrateTest001 TestMigrateSendByte");
197 AVSessionDescriptor descriptor = avsession_->GetDescriptor();
198 server_->OnSessionCreate(descriptor);
199 server_->OnTopSessionChange(descriptor);
200
201 server_->ObserveControllerChanged(deviceId);
202 server_->CreateController(descriptor.sessionId_);
203 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) !=
204 server_->playerIdToControllerCallbackMap_.end(), true);
205
206 OHOS::sptr<AVControllerItem> controller = nullptr;
207 int32_t ret = server_->GetControllerById(descriptor.sessionId_, controller);
208 EXPECT_EQ(ret, AVSESSION_SUCCESS);
209
210 server_->ResetSupportCrossMediaPlay("{\"mIsSupportSingleFrameMediaPlay\": true}");
211 EXPECT_EQ(server_->supportCrossMediaPlay_, true);
212
213 server_->SendSpecialKeepaliveData();
214 server_->SendRemoteControllerList(deviceId);
215 server_->SendRemoteHistorySessionList(deviceId);
216 server_->ClearRemoteControllerList(deviceId);
217 server_->ClearRemoteHistorySessionList(deviceId);
218
219 char header[] = {MSG_HEAD_MODE, SYNC_COMMAND};
220 const int commandList[] = {18, 30, 31, 36, 37, 38, 39, 41, 42, 43, 46, 48, 50};
221 for (int command : commandList) {
222 std::string data = std::string(header) + "{\"PlayerId\"" + descriptor.sessionId_ +
223 "\",\"MediaCommand\":" + std::to_string(command) + ",\"command\":\"\"}";
224 server_->OnBytesReceived(deviceId, data);
225 }
226
227 server_->OnMetaDataChange(descriptor.sessionId_, avsession_->GetMetaData());
228 server_->OnPlaybackStateChanged(descriptor.sessionId_, avsession_->GetPlaybackState());
229 }
230
231 /**
232 * @tc.name: MigrateTest001
233 * @tc.desc:
234 * @tc.type: FUNC
235 * @tc.require:
236 */
237 static HWTEST_F(MigrateAVSessionTest, MigrateTest001, TestSize.Level0)
238 {
239 SLOGI("MigrateTest001 begin");
240 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
241 int32_t sessionId = 1;
242 std::string deviceId = "538CF5694D736D03B42DAF483D5A8C8E432ADECFAD5A75270F70856028219C64";
243 TestMigrateConnect(avservice_, server_, migrateManager_, sessionId, deviceId);
244
245 OHOS::AppExecFwk::ElementName elementName;
246 elementName.SetBundleName("test.ohos.avsession");
247 elementName.SetAbilityName("test.ability");
248 OHOS::sptr<AVSessionItem> avsession_ =
249 avservice_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
250 SetMetaDataAndPlaybackState(avsession_);
251 AVSessionDescriptor descriptor = avsession_->GetDescriptor();
252 TestMigrateSendByte(avsession_, server_, deviceId);
253
254 // disconnect release
255 avservice_->SuperLauncher("", "SuperLauncher-Dual", "", "IDLE");
256 avservice_->RemoveInnerSessionListener(server_.get());
257 server_->OnSessionRelease(descriptor);
258 server_->ClearCacheBySessionId(descriptor.sessionId_);
259 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) ==
260 server_->playerIdToControllerCallbackMap_.end(), true);
261 avsession_->Destroy();
262 server_->DisconnectAllProxy();
263 server_->DisconnectProxy(sessionId);
264 server_->OnDisConnectSession(sessionId);
265 server_->OnDisconnectProxy(deviceId);
266 EXPECT_EQ(server_->isSoftbusConnecting_, false);
267 migrateManager_->ReleaseLocalSessionStub("SuperLauncher-Dual");
268 EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher-Dual") == migrateManager_->serverMap_.end(), true);
269 SLOGI("MigrateTest001 end");
270 }
271
272 /**
273 * @tc.name: CreateController001
274 * @tc.desc:
275 * @tc.type: FUNC
276 * @tc.require:
277 */
278 static HWTEST_F(MigrateAVSessionTest, CreateController001, TestSize.Level0)
279 {
280 SLOGI("CreateController001 begin");
281 const std::string sessionId = "1111";
282 server_->Init(avservice_);
283 server_->CreateController(sessionId);
284 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
285 server_->playerIdToControllerCallbackMap_.end(), true);
286 SLOGI("CreateController001 end");
287 }
288
289 /**
290 * @tc.name: ClearCacheBySessionId001
291 * @tc.desc:
292 * @tc.type: FUNC
293 * @tc.require:
294 */
295 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId001, TestSize.Level0)
296 {
297 SLOGI("ClearCacheBySessionId001 begin");
298 const std::string sessionId = "1111";
299 server_->ClearCacheBySessionId(sessionId);
300 EXPECT_EQ(server_->playerIdToControllerMap_.find(sessionId) == server_->playerIdToControllerMap_.end(), true);
301 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
302 server_->playerIdToControllerCallbackMap_.end(), true);
303 SLOGI("ClearCacheBySessionId001 end");
304 }
305
306 /**
307 * @tc.name: StopObserveControllerChanged001
308 * @tc.desc:
309 * @tc.type: FUNC
310 * @tc.require:
311 */
312 static HWTEST_F(MigrateAVSessionTest, StopObserveControllerChanged001, TestSize.Level0)
313 {
314 SLOGI("StopObserveControllerChanged001 begin");
315 const std::string deviceId = "1111";
316 server_->StopObserveControllerChanged(deviceId);
317 EXPECT_EQ(server_->playerIdToControllerMap_.size() == 0, true);
318 EXPECT_EQ(server_->sortControllerList_.size() == 0, true);
319 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.size() == 0, true);
320 SLOGI("StopObserveControllerChanged001 end");
321 }
322
323 /**
324 * @tc.name: GetControllerById001
325 * @tc.desc:
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 static HWTEST_F(MigrateAVSessionTest, GetControllerById001, TestSize.Level0)
330 {
331 SLOGI("GetControllerById001 begin");
332 const std::string sessionId = "123";
333 OHOS::sptr<AVControllerItem> controller = nullptr;
334 int32_t ret = server_->GetControllerById(sessionId, controller);
335 EXPECT_EQ(ret, AVSESSION_ERROR);
336 SLOGI("GetControllerById001 end");
337 }
338
339 /**
340 * @tc.name: GetControllerById002
341 * @tc.desc:
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 static HWTEST_F(MigrateAVSessionTest, GetControllerById002, TestSize.Level0)
346 {
347 SLOGI("GetControllerById002 begin");
348 const std::string sessionId = "123";
349 OHOS::sptr<AVControllerItem> controller = nullptr;
350 server_->playerIdToControllerMap_[sessionId] = controller;
351 int32_t ret = server_->GetControllerById(sessionId, controller);
352 EXPECT_EQ(ret, AVSESSION_SUCCESS);
353 SLOGI("GetControllerById002 end");
354 }
355
356 /**
357 * @tc.name: ConvertStateFromSingleToDouble001
358 * @tc.desc:
359 * @tc.type: FUNC
360 * @tc.require:
361 */
362 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble001, TestSize.Level0)
363 {
364 SLOGI("ConvertStateFromSingleToDouble001 begin");
365 int32_t state = AVPlaybackState::PLAYBACK_STATE_PLAY;
366 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
367 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PLAY);
368 SLOGI("ConvertStateFromSingleToDouble001 end");
369 }
370
371 /**
372 * @tc.name: ConvertStateFromSingleToDouble002
373 * @tc.desc:
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble002, TestSize.Level0)
378 {
379 SLOGI("ConvertStateFromSingleToDouble002 begin");
380 int32_t state = AVPlaybackState::PLAYBACK_STATE_PAUSE;
381 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
382 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PAUSE);
383 SLOGI("ConvertStateFromSingleToDouble002 end");
384 }
385
386 /**
387 * @tc.name: ConvertStateFromSingleToDouble003
388 * @tc.desc:
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble003, TestSize.Level0)
393 {
394 SLOGI("ConvertStateFromSingleToDouble003 begin");
395 int32_t state = AVPlaybackState::PLAYBACK_STATE_STOP;
396 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
397 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_STOP);
398 SLOGI("ConvertStateFromSingleToDouble003 end");
399 }
400
401 /**
402 * @tc.name: ConvertStateFromSingleToDouble004
403 * @tc.desc:
404 * @tc.type: FUNC
405 * @tc.require:
406 */
407 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble004, TestSize.Level0)
408 {
409 SLOGI("ConvertStateFromSingleToDouble004 begin");
410 int32_t state = AVPlaybackState::PLAYBACK_STATE_ERROR;
411 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
412 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_ERROR);
413 SLOGI("ConvertStateFromSingleToDouble004 end");
414 }
415
416 /**
417 * @tc.name: ConvertStateFromSingleToDouble005
418 * @tc.desc:
419 * @tc.type: FUNC
420 * @tc.require:
421 */
422 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble005, TestSize.Level0)
423 {
424 SLOGI("ConvertStateFromSingleToDouble005 begin");
425 int32_t state = 13;
426 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
427 EXPECT_EQ(ret, state);
428 SLOGI("ConvertStateFromSingleToDouble005 end");
429 }
430
431 /**
432 * @tc.name: ConvertMetadataToJson001
433 * @tc.desc:
434 * @tc.type: FUNC
435 * @tc.require:
436 */
437 static HWTEST_F(MigrateAVSessionTest, ConvertMetadataToJson001, TestSize.Level0)
438 {
439 SLOGI("ConvertMetadataToJson001 begin");
440 AVMetaData metadata;
441 metadata.SetTitle("song");
442 metadata.SetArtist("sing");
443 cJSON* ret = server_->ConvertMetadataToJson(metadata);
444 EXPECT_EQ(SoftbusSessionUtils::GetStringFromJson(ret, METADATA_TITLE), "song");
445 EXPECT_EQ(SoftbusSessionUtils::GetStringFromJson(ret, METADATA_ARTIST), "sing");
446 cJSON_Delete(ret);
447 SLOGI("ConvertMetadataToJson001 end");
448 }
449
450 /**
451 * @tc.name: ConvertMetadataInfoToStr001
452 * @tc.desc:
453 * @tc.type: FUNC
454 * @tc.require:
455 */
456 static HWTEST_F(MigrateAVSessionTest, ConvertMetadataInfoToStr001, TestSize.Level0)
457 {
458 SLOGI("ConvertMetadataInfoToStr001 begin");
459 const std::string playerId = "123";
460 int32_t controlCommand = 9;
461 AVMetaData metadata;
462 metadata.SetDuration(-2);
463
464 cJSON* result = SoftbusSessionUtils::GetNewCJSONObject();
465 if (result == nullptr) {
466 SLOGE("get result fail");
467 FAIL();
468 }
469 if (!SoftbusSessionUtils::AddStringToJson(result, METADATA_TITLE, "")) {
470 SLOGE("AddStringToJson with key:%{public}s fail", METADATA_TITLE);
471 cJSON_Delete(result);
472 result = nullptr;
473 }
474 if (!SoftbusSessionUtils::AddStringToJson(result, METADATA_ARTIST, "")) {
475 SLOGE("AddStringToJson with key:%{public}s fail", METADATA_ARTIST);
476 cJSON_Delete(result);
477 result = nullptr;
478 }
479 if (!SoftbusSessionUtils::AddStringToJson(result, METADATA_IMAGE, "")) {
480 SLOGE("AddStringToJson with key:%{public}s fail", METADATA_IMAGE);
481 cJSON_Delete(result);
482 result = nullptr;
483 }
484 if (!SoftbusSessionUtils::AddStringToJson(result, PLAYER_ID, playerId)) {
485 SLOGE("AddStringToJson with key:%{public}s|value:%{public}s fail", PLAYER_ID, playerId.c_str());
486 cJSON_Delete(result);
487 result = nullptr;
488 }
489 if (!SoftbusSessionUtils::AddIntToJson(result, MEDIA_INFO, controlCommand)) {
490 SLOGE("AddStringToJson with key:%{public}s|value:%{public}d fail", MEDIA_INFO, controlCommand);
491 cJSON_Delete(result);
492 result = nullptr;
493 }
494
495 std::string msg = "d\002";
496 SoftbusSessionUtils::TransferJsonToStr(result, msg);
497 std::string ret = server_->ConvertMetadataInfoToStr(playerId, controlCommand, metadata);
498 EXPECT_EQ(ret, msg);
499 cJSON_Delete(result);
500 SLOGI("ConvertMetadataInfoToStr001 end");
501 }
502
503 /**
504 * @tc.name: CreateLocalSessionStub001
505 * @tc.desc: test CreateLocalSessionStub
506 * @tc.type: FUNC
507 * @tc.require:
508 */
509 static HWTEST_F(MigrateAVSessionTest, CreateLocalSessionStub001, TestSize.Level0)
510 {
511 SLOGI("CreateLocalSessionStub001 begin");
512 std::string scene = "test";
513 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
514 EXPECT_TRUE(migrateManager_ != nullptr);
515 migrateManager_->CreateLocalSessionStub(scene, server_);
516 SLOGI("CreateLocalSessionStub001 end");
517 }
518
519 /**
520 * @tc.name: CreateLocalSessionStub002
521 * @tc.desc: test CreateLocalSessionStub
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 static HWTEST_F(MigrateAVSessionTest, CreateLocalSessionStub002, TestSize.Level0)
526 {
527 SLOGI("CreateLocalSessionStub002 begin");
528 std::string scene = "SuperLauncher";
529 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
530 EXPECT_TRUE(migrateManager_ != nullptr);
531 migrateManager_->CreateLocalSessionStub(scene, server_);
532 migrateManager_->CreateLocalSessionStub(scene, server_);
533 SLOGI("CreateLocalSessionStub002 end");
534 }
535
536 /**
537 * @tc.name: ReleaseLocalSessionStub001
538 * @tc.desc: test ReleaseLocalSessionStub
539 * @tc.type: FUNC
540 * @tc.require:
541 */
542 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub001, TestSize.Level0)
543 {
544 SLOGI("ReleaseLocalSessionStub001 begin");
545 std::string scene = "test";
546 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
547 EXPECT_TRUE(migrateManager_ != nullptr);
548 migrateManager_->ReleaseLocalSessionStub(scene);
549 SLOGI("ReleaseLocalSessionStub001 end");
550 }
551
552 /**
553 * @tc.name: ReleaseLocalSessionStub002
554 * @tc.desc: test ReleaseLocalSessionStub
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub002, TestSize.Level0)
559 {
560 SLOGI("ReleaseLocalSessionStub002 begin");
561 std::string scene = "SuperLauncher";
562 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
563 EXPECT_TRUE(migrateManager_ != nullptr);
564 migrateManager_->CreateLocalSessionStub(scene, server_);
565 migrateManager_->ReleaseLocalSessionStub(scene);
566 SLOGI("ReleaseLocalSessionStub002 end");
567 }
568
569 /**
570 * @tc.name: ReleaseLocalSessionStub003
571 * @tc.desc: test ReleaseLocalSessionStub
572 * @tc.type: FUNC
573 * @tc.require:
574 */
575 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub003, TestSize.Level0)
576 {
577 SLOGI("ReleaseLocalSessionStub003 begin");
578 std::string scene = "SuperLauncher";
579 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
580 EXPECT_TRUE(migrateManager_ != nullptr);
581 migrateManager_->ReleaseLocalSessionStub(scene);
582 SLOGI("ReleaseLocalSessionStub003 end");
583 }
584
585 /**
586 * @tc.name: IncSoftBusRef001
587 * @tc.desc: test IncSoftBusRef
588 * @tc.type: FUNC
589 * @tc.require:
590 */
591 static HWTEST_F(MigrateAVSessionTest, IncSoftBusRef001, TestSize.Level0)
592 {
593 SLOGI("IncSoftBusRef001 begin");
594 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
595 EXPECT_TRUE(migrateManager_ != nullptr);
596 migrateManager_->refs_ = 1;
597 migrateManager_->IncSoftBusRef();
598 SLOGI("IncSoftBusRef001 end");
599 }
600
601 /**
602 * @tc.name: ClearCacheBySessionId002
603 * @tc.desc: test ClearCacheBySessionId
604 * @tc.type: FUNC
605 * @tc.require:
606 */
607 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId002, TestSize.Level0)
608 {
609 SLOGI("ClearCacheBySessionId002 begin");
610 std::string sessionId = "#####";
611 EXPECT_TRUE(server_ != nullptr);
612 server_->ClearCacheBySessionId(sessionId);
613 SLOGI("ClearCacheBySessionId002 end");
614 }
615
616 /**
617 * @tc.name: ClearCacheBySessionId003
618 * @tc.desc: test ClearCacheBySessionId
619 * @tc.type: FUNC
620 * @tc.require:
621 */
622 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId003, TestSize.Level0)
623 {
624 SLOGI("ClearCacheBySessionId003 begin");
625 std::string sessionId = "12345";
626 OHOS::sptr<AVControllerItem> item = nullptr;
627 std::shared_ptr<AVControllerObserver> observer(nullptr);
628 EXPECT_TRUE(server_ != nullptr);
629 server_->playerIdToControllerMap_[sessionId] = item;
630 server_->playerIdToControllerCallbackMap_[sessionId] = observer;
631 server_->ClearCacheBySessionId(sessionId);
632 SLOGI("ClearCacheBySessionId003 end");
633 }
634
635 /**
636 * @tc.name: ProcControlCommand001
637 * @tc.desc: test ProcControlCommand
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand001, TestSize.Level0)
642 {
643 SLOGI("ProcControlCommand001 begin");
644 std::string data = R"(##{"PlayerId":"1","MediaCommand":"1"})";
645 EXPECT_TRUE(server_ != nullptr);
646 server_->ProcControlCommand(data);
647 SLOGI("ProcControlCommand001 end");
648 }
649
650 /**
651 * @tc.name: ProcControlCommand002
652 * @tc.desc: test ProcControlCommand
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand002, TestSize.Level0)
657 {
658 SLOGI("ProcControlCommand002 begin");
659 std::string data = R"(##{"PlayerId":"1","command":"1"})";
660 EXPECT_TRUE(server_ != nullptr);
661 server_->ProcControlCommand(data);
662 SLOGI("ProcControlCommand002 end");
663 }
664
665 /**
666 * @tc.name: ProcControlCommand003
667 * @tc.desc: test ProcControlCommand
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand003, TestSize.Level0)
672 {
673 SLOGI("ProcControlCommand003 begin");
674 std::string data = R"(##{"MediaCommand":"1","command":"1"})";
675 EXPECT_TRUE(server_ != nullptr);
676 server_->ProcControlCommand(data);
677 SLOGI("ProcControlCommand003 end");
678 }
679
680 /**
681 * @tc.name: ProcControlCommand004
682 * @tc.desc: test ProcControlCommand
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand004, TestSize.Level0)
687 {
688 SLOGI("ProcControlCommand004 begin");
689 std::string data = R"(##{"MediaCommand":"1"})";
690 EXPECT_TRUE(server_ != nullptr);
691 server_->ProcControlCommand(data);
692 SLOGI("ProcControlCommand004 end");
693 }
694
695 /**
696 * @tc.name: ProcControlCommand005
697 * @tc.desc: test ProcControlCommand
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand005, TestSize.Level0)
702 {
703 SLOGI("ProcControlCommand005 begin");
704 std::string data = R"(##{"command":"1"})";
705 EXPECT_TRUE(server_ != nullptr);
706 server_->ProcControlCommand(data);
707 SLOGI("ProcControlCommand005 end");
708 }
709
710 /**
711 * @tc.name: ProcControlCommand006
712 * @tc.desc: test ProcControlCommand
713 * @tc.type: FUNC
714 * @tc.require:
715 */
716 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand006, TestSize.Level0)
717 {
718 SLOGI("ProcControlCommand006 begin");
719 std::string data = R"(##{"PlayerId":"1"})";
720 EXPECT_TRUE(server_ != nullptr);
721 server_->ProcControlCommand(data);
722 SLOGI("ProcControlCommand006 end");
723 }
724
725 /**
726 * @tc.name: ProcControlCommand007
727 * @tc.desc: test ProcControlCommand
728 * @tc.type: FUNC
729 * @tc.require:
730 */
731 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand007, TestSize.Level0)
732 {
733 SLOGI("ProcControlCommand007 begin");
734 std::string data = R"(##{"PlayerId":"","MediaCommand":1,"command":"1"})";
735 EXPECT_TRUE(server_ != nullptr);
736 server_->ProcControlCommand(data);
737 SLOGI("ProcControlCommand007 end");
738 }
739
740 /**
741 * @tc.name: ProcControlCommand008
742 * @tc.desc: test ProcControlCommand
743 * @tc.type: FUNC
744 * @tc.require:
745 */
746 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand008, TestSize.Level0)
747 {
748 SLOGI("ProcControlCommand008 begin");
749 server_->CreateController("111");
750 std::string data = R"(##{"PlayerId":"111","MediaCommand":30,"command":"1"})";
751 EXPECT_TRUE(server_ != nullptr);
752 server_->ProcControlCommand(data);
753 SLOGI("ProcControlCommand008 end");
754 }
755
756 /**
757 * @tc.name: ProcControlCommand009
758 * @tc.desc: test ProcControlCommand
759 * @tc.type: FUNC
760 * @tc.require:
761 */
762 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand009, TestSize.Level0)
763 {
764 SLOGI("ProcControlCommand009 begin");
765 server_->CreateController("111");
766 std::string data = R"(##{"PlayerId":"111","MediaCommand":31,"command":"1","extras":11})";
767 EXPECT_TRUE(server_ != nullptr);
768 server_->ProcControlCommand(data);
769 SLOGI("ProcControlCommand009 end");
770 }
771
772 /**
773 * @tc.name: ProcControlCommand007
774 * @tc.desc: test ProcControlCommand
775 * @tc.type: FUNC
776 * @tc.require:
777 */
778 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand010, TestSize.Level0)
779 {
780 SLOGI("ProcControlCommand007 begin");
781 server_->CreateController("111");
782 std::string data = R"(##{"PlayerId":"111","MediaCommand":50,"command":"1","extras":"124"})";
783 EXPECT_TRUE(server_ != nullptr);
784 server_->ProcControlCommand(data);
785 SLOGI("ProcControlCommand007 end");
786 }
787
788 /**
789 * @tc.name: OnDeviceOffline001
790 * @tc.desc: OnDeviceOffline
791 * @tc.type: FUNC
792 * @tc.require:
793 */
794 static HWTEST_F(MigrateAVSessionTest, OnDeviceOffline001, TestSize.Level1)
795 {
796 SLOGI("OnDeviceOffline001 begin");
797 const int64_t param = 1000;
798 std::string deviceId = "test";
799 const std::string sessionId = "";
800 DeviceLogEventCode eventCode = DeviceLogEventCode::DEVICE_LOG_FULL;
801 EXPECT_TRUE(server_ != nullptr);
802 server_->OnDeviceLogEvent(eventCode, param);
803 OHOS::sptr<AVControllerItem> controller = nullptr;
804 server_->OnDeviceOffline(deviceId);
805 int32_t ret = server_->GetControllerById(sessionId, controller);
806 EXPECT_EQ(ret, AVSESSION_ERROR);
807 SLOGI("OnDeviceOffline001 end");
808 }
809
810 /**
811 * @tc.name: OnAudioSessionChecked001
812 * @tc.desc: OnAudioSessionChecked
813 * @tc.type: FUNC
814 * @tc.require:
815 */
816 static HWTEST_F(MigrateAVSessionTest, OnAudioSessionChecked001, TestSize.Level1)
817 {
818 SLOGI("OnAudioSessionChecked001 begin");
819 int32_t uid = 1000;
820 std::vector<OHOS::sptr<IRemoteObject>> sessionControllers;
821 sessionControllers.push_back(nullptr);
822 ASSERT_TRUE(server_ != nullptr);
823 server_->OnRemoteDistributedSessionChange(sessionControllers);
824 server_->OnAudioSessionChecked(uid);
825 int32_t ret = server_->GetCharacteristic();
826 EXPECT_EQ(ret, MSG_HEAD_MODE);
827 SLOGI("OnAudioSessionChecked001 end");
828 }
829
830 /**
831 * @tc.name: GetControllerById003
832 * @tc.desc: GetControllerById
833 * @tc.type: FUNC
834 * @tc.require:
835 */
836 static HWTEST_F(MigrateAVSessionTest, GetControllerById003, TestSize.Level1)
837 {
838 SLOGI("GetControllerById003 begin");
839 const std::string sessionId = "";
840 OutputDeviceInfo castOutputDeviceInfo;
841 ASSERT_TRUE(server_ != nullptr);
842 server_->OnDeviceAvailable(castOutputDeviceInfo);
843 OHOS::sptr<AVControllerItem> controller = nullptr;
844 int32_t ret = server_->GetControllerById(sessionId, controller);
845 EXPECT_EQ(ret, AVSESSION_ERROR);
846 SLOGI("GetControllerById003 end");
847 }
848
849 /**
850 * @tc.name: GetAllControllers001
851 * @tc.desc: GetAllControllers
852 * @tc.type: FUNC
853 * @tc.require:
854 */
855 static HWTEST_F(MigrateAVSessionTest, GetAllControllers001, TestSize.Level1)
856 {
857 SLOGI("GetAllControllers001 begin");
858 const std::string sessionId = "1111";
859 server_->CreateController(sessionId);
860 std::vector<OHOS::sptr<AVControllerItem>> controllers;
861 int32_t ret = server_->GetAllControllers(controllers);
862 EXPECT_EQ(ret, AVSESSION_SUCCESS);
863 SLOGI("GetAllControllers001 end");
864 }