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