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 "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23 #include "avmeta_data.h"
24 #include "avplayback_state.h"
25 #include "avsession_errors.h"
26 #include "avsession_item.h"
27 #include "avsession_log.h"
28 #include "migrate_avsession_constant.h"
29 #include "system_ability_definition.h"
30 #define private public
31 #define protected public
32 #include "avsession_service.h"
33 #include "migrate_avsession_manager.h"
34 #undef protected
35 #undef private
36 
37 using namespace testing::ext;
38 using namespace OHOS::AVSession;
39 
40 static const char* g_perms[] = {"ohos.permission.DISTRIBUTED_SOFTBUS_CENTER", "ohos.permission.DISTRIBUTED_DATASYNC",
41     "ohos.permission.ACCESS_SERVICE_DM"};
42 static const int SIZE = 3;
43 static const int64_t TEST_DURATION = 40000;
44 static const double TEST_SPEED = 1.5;
45 static const int64_t TEST_BUFFERED_TIME = 60000;
46 static const int32_t TEST_LOOG_MODE = 2;
47 static std::shared_ptr<MigrateAVSessionServer> server_;
48 static AVSessionService *avservice_;
49 
50 class MigrateAVSessionTest : public testing::Test {
51 public:
52     static void SetUpTestCase();
53     static void TearDownTestCase();
54     void SetUp();
55     void TearDown();
56     void NativeTokenGet(const char *perms[], int size);
57 };
58 
SetUpTestCase()59 void MigrateAVSessionTest::SetUpTestCase()
60 {
61     SLOGI("MigrateAVSessionTest SetUpTestCase");
62     server_ = std::make_shared<MigrateAVSessionServer>();
63     avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
64 }
65 
TearDownTestCase()66 void MigrateAVSessionTest::TearDownTestCase()
67 {
68     SLOGI("MigrateAVSessionTest TearDownTestCase");
69     server_ = nullptr;
70     avservice_ = nullptr;
71 }
72 
SetUp()73 void MigrateAVSessionTest::SetUp()
74 {
75     SLOGI("MigrateAVSessionTest SetUp");
76     NativeTokenGet(g_perms, SIZE);
77 }
78 
TearDown()79 void MigrateAVSessionTest::TearDown()
80 {
81     SLOGI("MigrateAVSessionTest TearDown");
82     NativeTokenGet(nullptr, 0);
83 }
84 
NativeTokenGet(const char * perms[],int size)85 void MigrateAVSessionTest::NativeTokenGet(const char *perms[], int size)
86 {
87     uint64_t tokenId;
88     NativeTokenInfoParams infoInstance = {
89         .dcapsNum = 0,
90         .permsNum = size,
91         .aclsNum = 0,
92         .dcaps = nullptr,
93         .perms = perms,
94         .acls = nullptr,
95         .aplStr = "system_basic",
96     };
97 
98     infoInstance.processName = "migrate_softbus_test";
99     tokenId = GetAccessTokenId(&infoInstance);
100     SetSelfTokenID(tokenId);
101     OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
102 }
103 
104 /**
105 * @tc.name: GetCharacteristic001
106 * @tc.desc:
107 * @tc.type: FUNC
108 * @tc.require:
109 */
110 HWTEST_F(MigrateAVSessionTest, GetCharacteristic001, TestSize.Level1)
111 {
112     SLOGI("GetCharacteristic001 begin");
113     int32_t ret = server_->GetCharacteristic();
114     EXPECT_EQ(ret, MSG_HEAD_MODE);
115     SLOGI("GetCharacteristic001 end");
116 }
117 
SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)118 void SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)
119 {
120     SLOGI("MigrateTest001 SetMetaDataAndPlaybackState");
121     AVMetaData metaData;
122     metaData.Reset();
123     metaData.SetAssetId("123");
124     metaData.SetTitle("Black Humor");
125     metaData.SetArtist("zhoujielun");
126     metaData.SetAuthor("zhoujielun");
127     metaData.SetAlbum("Jay");
128     metaData.SetWriter("zhoujielun");
129     metaData.SetComposer("zhoujielun");
130     metaData.SetDuration(TEST_DURATION);
131     metaData.SetMediaImageUri("xxxxx");
132     metaData.SetSubTitle("fac");
133     metaData.SetDescription("for friends");
134     metaData.SetLyric("xxxxx");
135     avsession_->SetAVMetaData(metaData);
136 
137     AVPlaybackState playbackState;
138     playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
139     playbackState.SetSpeed(TEST_SPEED);
140     playbackState.SetPosition({ 80000, 0 });
141     playbackState.SetBufferedTime(TEST_BUFFERED_TIME);
142     playbackState.SetLoopMode(TEST_LOOG_MODE);
143     playbackState.SetFavorite(true);
144     avsession_->SetAVPlaybackState(playbackState);
145 }
146 
TestMigrateConnect(AVSessionService * avservice_,std::shared_ptr<MigrateAVSessionServer> server_,std::shared_ptr<MigrateAVSessionManager> migrateManager_,int32_t sessionId,std::string deviceId)147 void TestMigrateConnect(AVSessionService *avservice_, std::shared_ptr<MigrateAVSessionServer> server_,
148     std::shared_ptr<MigrateAVSessionManager> migrateManager_, int32_t sessionId, std::string deviceId)
149 {
150     SLOGI("MigrateTest001 TestMigrateConnect");
151     avservice_->SuperLauncher("", "SuperLauncher", "", "CONNECTING");
152     avservice_->AddInnerSessionListener(server_.get());
153 
154     server_->Init(avservice_);
155     migrateManager_->CreateLocalSessionStub("SuperLauncher", server_);
156     EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher") != migrateManager_->serverMap_.end(), true);
157 
158     char infoName[] = "testInfoName";
159     char infoNetworkId[] = "testInfoNetworkId";
160     char infoPkgName[] = "testInfoPkgName";
161     PeerSocketInfo info = {
162         .name = infoName,
163         .networkId = infoNetworkId,
164         .pkgName = infoPkgName,
165         .dataType = DATA_TYPE_BYTES,
166     };
167     migrateManager_->softBusDistributedDataMgr_->SessionOpened(sessionId, info);
168     migrateManager_->softBusDistributedDataMgr_->OnSessionServerOpened();
169     migrateManager_->softBusDistributedDataMgr_->MessageReceived(sessionId, "");
170     migrateManager_->softBusDistributedDataMgr_->OnMessageHandleReceived(sessionId, "");
171     server_->ConnectProxy(sessionId);
172     server_->OnConnectSession(sessionId);
173     server_->OnConnectProxy(deviceId);
174     EXPECT_EQ(server_->isSoftbusConnecting_, true);
175 }
176 
TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_,std::shared_ptr<MigrateAVSessionServer> server_,std::string deviceId)177 void TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_, std::shared_ptr<MigrateAVSessionServer> server_,
178     std::string deviceId)
179 {
180     SLOGI("MigrateTest001 TestMigrateSendByte");
181     AVSessionDescriptor descriptor = avsession_->GetDescriptor();
182     server_->OnSessionCreate(descriptor);
183     server_->OnTopSessionChange(descriptor);
184 
185     server_->ObserveControllerChanged(deviceId);
186     server_->CreateController(descriptor.sessionId_);
187     EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) !=
188         server_->playerIdToControllerCallbackMap_.end(), true);
189 
190     OHOS::sptr<AVControllerItem> controller = nullptr;
191     int32_t ret = server_->GetControllerById(descriptor.sessionId_, controller);
192     EXPECT_EQ(ret, AVSESSION_SUCCESS);
193 
194     server_->SendSpecialKeepaliveData();
195     server_->SendRemoteControllerList(deviceId);
196 
197     char header[] = {MSG_HEAD_MODE, SYNC_COMMAND};
198     const int commandList[] = {18, 30, 31, 36, 37, 38, 39, 41, 42, 43, 46, 48, 50};
199     for (int command : commandList) {
200         std::string data = std::string(header) + "{\"PlayerId\"" + descriptor.sessionId_ +
201             "\",\"MediaCommand\":" + std::to_string(command) + ",\"command\":\"\"}";
202         server_->OnBytesReceived(deviceId, data);
203     }
204 
205     server_->OnMetaDataChange(descriptor.sessionId_, avsession_->GetMetaData());
206     server_->OnPlaybackStateChanged(descriptor.sessionId_, avsession_->GetPlaybackState());
207 }
208 
209 /**
210 * @tc.name: MigrateTest001
211 * @tc.desc:
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 HWTEST_F(MigrateAVSessionTest, MigrateTest001, TestSize.Level1)
216 {
217     SLOGI("MigrateTest001 begin");
218     std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
219     int32_t sessionId = 1;
220     std::string deviceId = "538CF5694D736D03B42DAF483D5A8C8E432ADECFAD5A75270F70856028219C64";
221     TestMigrateConnect(avservice_, server_, migrateManager_, sessionId, deviceId);
222 
223     OHOS::AppExecFwk::ElementName elementName;
224     elementName.SetBundleName("test.ohos.avsession");
225     elementName.SetAbilityName("test.ability");
226     OHOS::sptr<AVSessionItem> avsession_ =
227         avservice_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
228     SetMetaDataAndPlaybackState(avsession_);
229     AVSessionDescriptor descriptor = avsession_->GetDescriptor();
230     TestMigrateSendByte(avsession_, server_, deviceId);
231 
232     // disconnect release
233     avservice_->SuperLauncher("", "SuperLauncher", "", "IDLE");
234     avservice_->RemoveInnerSessionListener(server_.get());
235     server_->OnSessionRelease(descriptor);
236     server_->ClearCacheBySessionId(descriptor.sessionId_);
237     EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) ==
238         server_->playerIdToControllerCallbackMap_.end(), true);
239     avsession_->Destroy();
240     server_->DisconnectAllProxy();
241     server_->DisconnectProxy(sessionId);
242     server_->OnDisConnectSession(sessionId);
243     server_->OnDisconnectProxy(deviceId);
244     EXPECT_EQ(server_->isSoftbusConnecting_, false);
245     migrateManager_->ReleaseLocalSessionStub("SuperLauncher");
246     EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher") == migrateManager_->serverMap_.end(), true);
247     SLOGI("MigrateTest001 end");
248 }
249 
250 /**
251 * @tc.name: CreateController001
252 * @tc.desc:
253 * @tc.type: FUNC
254 * @tc.require:
255 */
256 HWTEST_F(MigrateAVSessionTest, CreateController001, TestSize.Level1)
257 {
258     SLOGI("CreateController001 begin");
259     const std::string sessionId = "1111";
260     server_->Init(avservice_);
261     server_->CreateController(sessionId);
262     EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
263         server_->playerIdToControllerCallbackMap_.end(), true);
264     SLOGI("CreateController001 end");
265 }
266 
267 /**
268 * @tc.name: ClearCacheBySessionId001
269 * @tc.desc:
270 * @tc.type: FUNC
271 * @tc.require:
272 */
273 HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId001, TestSize.Level1)
274 {
275     SLOGI("ClearCacheBySessionId001 begin");
276     const std::string sessionId = "1111";
277     server_->ClearCacheBySessionId(sessionId);
278     EXPECT_EQ(server_->playerIdToControllerMap_.find(sessionId) == server_->playerIdToControllerMap_.end(), true);
279     EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
280         server_->playerIdToControllerCallbackMap_.end(), true);
281     SLOGI("ClearCacheBySessionId001 end");
282 }
283 
284 /**
285 * @tc.name: StopObserveControllerChanged001
286 * @tc.desc:
287 * @tc.type: FUNC
288 * @tc.require:
289 */
290 HWTEST_F(MigrateAVSessionTest, StopObserveControllerChanged001, TestSize.Level1)
291 {
292     SLOGI("StopObserveControllerChanged001 begin");
293     const std::string deviceId = "1111";
294     server_->StopObserveControllerChanged(deviceId);
295     EXPECT_EQ(server_->playerIdToControllerMap_.size() == 0, true);
296     EXPECT_EQ(server_->sortControllerList_.size() == 0, true);
297     EXPECT_EQ(server_->playerIdToControllerCallbackMap_.size() == 0, true);
298     SLOGI("StopObserveControllerChanged001 end");
299 }
300 
301 /**
302 * @tc.name: GetControllerById001
303 * @tc.desc:
304 * @tc.type: FUNC
305 * @tc.require:
306 */
307 HWTEST_F(MigrateAVSessionTest, GetControllerById001, TestSize.Level1)
308 {
309     SLOGI("GetControllerById001 begin");
310     const std::string sessionId = "123";
311     OHOS::sptr<AVControllerItem> controller = nullptr;
312     int32_t ret = server_->GetControllerById(sessionId, controller);
313     EXPECT_EQ(ret, AVSESSION_ERROR);
314     SLOGI("GetControllerById001 end");
315 }
316 
317 /**
318 * @tc.name: GetControllerById002
319 * @tc.desc:
320 * @tc.type: FUNC
321 * @tc.require:
322 */
323 HWTEST_F(MigrateAVSessionTest, GetControllerById002, TestSize.Level1)
324 {
325     SLOGI("GetControllerById002 begin");
326     const std::string sessionId = "123";
327     OHOS::sptr<AVControllerItem> controller = nullptr;
328     server_->playerIdToControllerMap_[sessionId] = controller;
329     int32_t ret = server_->GetControllerById(sessionId, controller);
330     EXPECT_EQ(ret, AVSESSION_SUCCESS);
331     SLOGI("GetControllerById002 end");
332 }
333 
334 /**
335 * @tc.name: ConvertStateFromSingleToDouble001
336 * @tc.desc:
337 * @tc.type: FUNC
338 * @tc.require:
339 */
340 HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble001, TestSize.Level1)
341 {
342     SLOGI("ConvertStateFromSingleToDouble001 begin");
343     int32_t state = AVPlaybackState::PLAYBACK_STATE_PLAY;
344     int32_t ret = server_->ConvertStateFromSingleToDouble(state);
345     EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PLAY);
346     SLOGI("ConvertStateFromSingleToDouble001 end");
347 }
348 
349 /**
350 * @tc.name: ConvertStateFromSingleToDouble002
351 * @tc.desc:
352 * @tc.type: FUNC
353 * @tc.require:
354 */
355 HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble002, TestSize.Level1)
356 {
357     SLOGI("ConvertStateFromSingleToDouble002 begin");
358     int32_t state = AVPlaybackState::PLAYBACK_STATE_PAUSE;
359     int32_t ret = server_->ConvertStateFromSingleToDouble(state);
360     EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PAUSE);
361     SLOGI("ConvertStateFromSingleToDouble002 end");
362 }
363 
364 /**
365 * @tc.name: ConvertStateFromSingleToDouble003
366 * @tc.desc:
367 * @tc.type: FUNC
368 * @tc.require:
369 */
370 HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble003, TestSize.Level1)
371 {
372     SLOGI("ConvertStateFromSingleToDouble003 begin");
373     int32_t state = AVPlaybackState::PLAYBACK_STATE_STOP;
374     int32_t ret = server_->ConvertStateFromSingleToDouble(state);
375     EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_STOP);
376     SLOGI("ConvertStateFromSingleToDouble003 end");
377 }
378 
379 /**
380 * @tc.name: ConvertStateFromSingleToDouble004
381 * @tc.desc:
382 * @tc.type: FUNC
383 * @tc.require:
384 */
385 HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble004, TestSize.Level1)
386 {
387     SLOGI("ConvertStateFromSingleToDouble004 begin");
388     int32_t state = AVPlaybackState::PLAYBACK_STATE_ERROR;
389     int32_t ret = server_->ConvertStateFromSingleToDouble(state);
390     EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_ERROR);
391     SLOGI("ConvertStateFromSingleToDouble004 end");
392 }
393 
394 /**
395 * @tc.name: ConvertStateFromSingleToDouble005
396 * @tc.desc:
397 * @tc.type: FUNC
398 * @tc.require:
399 */
400 HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble005, TestSize.Level1)
401 {
402     SLOGI("ConvertStateFromSingleToDouble005 begin");
403     int32_t state = 13;
404     int32_t ret = server_->ConvertStateFromSingleToDouble(state);
405     EXPECT_EQ(ret, state);
406     SLOGI("ConvertStateFromSingleToDouble005 end");
407 }
408 
409 /**
410 * @tc.name: ConvertMetadataToJson001
411 * @tc.desc:
412 * @tc.type: FUNC
413 * @tc.require:
414 */
415 HWTEST_F(MigrateAVSessionTest, ConvertMetadataToJson001, TestSize.Level1)
416 {
417     SLOGI("ConvertMetadataToJson001 begin");
418     AVMetaData metadata;
419     metadata.SetTitle("song");
420     metadata.SetArtist("sing");
421     Json::Value ret = server_->ConvertMetadataToJson(metadata);
422     EXPECT_EQ(ret[METADATA_TITLE], "song");
423     EXPECT_EQ(ret[METADATA_ARTIST], "sing");
424     SLOGI("ConvertMetadataToJson001 end");
425 }
426 
427 /**
428 * @tc.name: ConvertMetadataInfoToStr001
429 * @tc.desc:
430 * @tc.type: FUNC
431 * @tc.require:
432 */
433 HWTEST_F(MigrateAVSessionTest, ConvertMetadataInfoToStr001, TestSize.Level1)
434 {
435     SLOGI("ConvertMetadataInfoToStr001 begin");
436     const std::string playerId = "123";
437     int32_t controlCommand = 9;
438     AVMetaData metadata;
439     metadata.SetDuration(-2);
440     Json::Value result;
441     result[PLAYER_ID] = playerId;
442     result[MEDIA_INFO] = controlCommand;
443     result[METADATA_IMAGE] = "";
444     result[METADATA_ARTIST] = "";
445     result[METADATA_TITLE] = "";
446     Json::FastWriter writer;
447     std::string msg = "d\002" + writer.write(result);
448     std::string ret = server_->ConvertMetadataInfoToStr(playerId, controlCommand, metadata);
449     EXPECT_EQ(ret, msg);
450     SLOGI("ConvertMetadataInfoToStr001 end");
451 }