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 <chrono>
18 #include <new>
19 #include <thread>
20
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 #include "avsession_service.h"
32
33 using namespace testing::ext;
34 using namespace OHOS::AVSession;
35
36 namespace OHOS {
37 namespace AVSession {
38
39 static char g_testSessionTag[] = "test";
40 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
41 static char g_testAnotherAbilityName[] = "testAnother.ability";
42 static std::shared_ptr<MigrateAVSessionServer> g_MigrateAVSessionServer {nullptr};
43 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
44 static OHOS::sptr<AVSessionItem> g_AVSessionItem {nullptr};
45 static OHOS::sptr<AVControllerItem> g_AVControllerItem {nullptr};
46
47 #ifdef ENABLE_AVSESSION_SYSEVENT_CONTROL
48 static const int32_t REPORT_SIZE = 100;
49 static const int32_t CONTROL_COLD_START = 2;
50 #endif
51
52
53 class AVsessionItemTest : public testing::Test {
54 public:
55
56 static void SetUpTestCase();
57 static void TearDownTestCase();
58 void SetUp();
59 void TearDown();
60 };
61
62 class AVSessionCallbackImpl : public IAVSessionCallback {
63 public:
OnPlay()64 ErrCode OnPlay() override { return AVSESSION_SUCCESS; };
OnPause()65 ErrCode OnPause() override { return AVSESSION_SUCCESS; };
OnStop()66 ErrCode OnStop() override { return AVSESSION_SUCCESS; };
OnPlayNext()67 ErrCode OnPlayNext() override { return AVSESSION_SUCCESS; };
OnPlayPrevious()68 ErrCode OnPlayPrevious() override { return AVSESSION_SUCCESS; };
OnFastForward(int64_t time)69 ErrCode OnFastForward(int64_t time) override { return AVSESSION_SUCCESS; };
OnRewind(int64_t time)70 ErrCode OnRewind(int64_t time) override { return AVSESSION_SUCCESS; };
OnSeek(int64_t time)71 ErrCode OnSeek(int64_t time) override { return AVSESSION_SUCCESS; };
OnSetSpeed(double speed)72 ErrCode OnSetSpeed(double speed) override { return AVSESSION_SUCCESS; };
OnSetLoopMode(int32_t loopMode)73 ErrCode OnSetLoopMode(int32_t loopMode) override { return AVSESSION_SUCCESS; };
OnSetTargetLoopMode(int32_t targetLoopMode)74 ErrCode OnSetTargetLoopMode(int32_t targetLoopMode) override { return AVSESSION_SUCCESS; };
OnToggleFavorite(const std::string & mediaId)75 ErrCode OnToggleFavorite(const std::string& mediaId) override { return AVSESSION_SUCCESS; };
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)76 ErrCode OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override { return AVSESSION_SUCCESS; };
OnOutputDeviceChange(const int32_t connectionState,const OHOS::AVSession::OutputDeviceInfo & outputDeviceInfo)77 ErrCode OnOutputDeviceChange(const int32_t connectionState,
78 const OHOS::AVSession::OutputDeviceInfo& outputDeviceInfo) override { return AVSESSION_SUCCESS; };
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)79 ErrCode OnCommonCommand(const std::string& commonCommand,
80 const OHOS::AAFwk::WantParams& commandArgs) override { return AVSESSION_SUCCESS; };
OnSkipToQueueItem(int32_t itemId)81 ErrCode OnSkipToQueueItem(int32_t itemId) override { return AVSESSION_SUCCESS; };
OnAVCallAnswer()82 ErrCode OnAVCallAnswer() override { return AVSESSION_SUCCESS; };
OnAVCallHangUp()83 ErrCode OnAVCallHangUp() override { return AVSESSION_SUCCESS; };
OnAVCallToggleCallMute()84 ErrCode OnAVCallToggleCallMute() override { return AVSESSION_SUCCESS; };
OnPlayFromAssetId(int64_t assetId)85 ErrCode OnPlayFromAssetId(int64_t assetId) override { return AVSESSION_SUCCESS; };
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)86 ErrCode OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override { return AVSESSION_SUCCESS; };
OnCastDisplaySizeChange(const CastDisplayInfo & castDisplayInfo)87 ErrCode OnCastDisplaySizeChange(const CastDisplayInfo& castDisplayInfo) override { return AVSESSION_SUCCESS; };
AsObject()88 sptr<IRemoteObject> AsObject() override { return nullptr; }
OnPlayWithAssetId(const std::string & assetId)89 ErrCode OnPlayWithAssetId(const std::string& assetId) override { return AVSESSION_SUCCESS; };
OnCustomData(const OHOS::AAFwk::WantParams & data)90 ErrCode OnCustomData(const OHOS::AAFwk::WantParams& data) override { return AVSESSION_SUCCESS; };
91
92 AVSessionCallbackImpl() = default;
93 ~AVSessionCallbackImpl() = default;
94 };
95
96 class MockIAVCastControllerProxy : public OHOS::AVSession::IAVCastControllerProxy {
Release()97 void Release() override {}
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> listener)98 int32_t RegisterControllerListener(const
99 std::shared_ptr<IAVCastControllerProxyListener> listener) override { return 0; }
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> listener)100 int32_t UnRegisterControllerListener(const
101 std::shared_ptr<IAVCastControllerProxyListener> listener) override { return 0; }
GetCurrentItem()102 AVQueueItem GetCurrentItem() override { return AVQueueItem(); }
Start(const AVQueueItem & item)103 int32_t Start(const AVQueueItem& item) override { return 0; }
Prepare(const AVQueueItem & item)104 int32_t Prepare(const AVQueueItem& item) override { return 0; }
SendControlCommand(const AVCastControlCommand cmd)105 void SendControlCommand(const AVCastControlCommand cmd) override {}
GetDuration(int32_t & duration)106 int32_t GetDuration(int32_t& duration) override { return 0; }
GetCastAVPlaybackState(AVPlaybackState & state)107 int32_t GetCastAVPlaybackState(AVPlaybackState& state) override { return 0; }
SetValidAbility(const std::vector<int32_t> & validAbilityList)108 int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) override { return 0; }
GetValidAbility(std::vector<int32_t> & validAbilityList)109 int32_t GetValidAbility(std::vector<int32_t>& validAbilityList) override { return 0; }
SetDisplaySurface(std::string & surfaceId)110 int32_t SetDisplaySurface(std::string& surfaceId) override { return 0; }
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)111 int32_t ProcessMediaKeyResponse(const
112 std::string& assetId, const std::vector<uint8_t>& response) override { return 0; }
GetSupportedDecoders(std::vector<std::string> & decoderTypes)113 int32_t GetSupportedDecoders(std::vector<std::string>& decoderTypes) override { return 0; }
GetRecommendedResolutionLevel(std::string & decoderType,ResolutionLevel & resolutionLevel)114 int32_t GetRecommendedResolutionLevel(std::string& decoderType, ResolutionLevel& resolutionLevel)
115 override { return 0; }
GetSupportedHdrCapabilities(std::vector<HDRFormat> & hdrFormats)116 int32_t GetSupportedHdrCapabilities(std::vector<HDRFormat>& hdrFormats) override { return 0; }
GetSupportedPlaySpeeds(std::vector<float> & playSpeeds)117 int32_t GetSupportedPlaySpeeds(std::vector<float>& playSpeeds) override { return 0; }
RefreshCurrentAVQueueItem(const AVQueueItem & avQueueItem)118 int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) override {return 0;}
SetSessionCallbackForCastCap(const std::function<void (bool,bool)> & callback)119 void SetSessionCallbackForCastCap(const std::function<void(bool, bool)>& callback) override {}
SetSpid(uint32_t spid)120 void SetSpid(uint32_t spid) override {}
121 };
122
SetUpTestCase()123 void AVsessionItemTest::SetUpTestCase()
124 {
125 SLOGI("AVsessionItemTest SetUpTestCase");
126 g_MigrateAVSessionServer = std::make_shared<MigrateAVSessionServer>();
127 OHOS::AppExecFwk::ElementName elementName;
128 elementName.SetBundleName(g_testAnotherBundleName);
129 elementName.SetAbilityName(g_testAnotherAbilityName);
130 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID, true);
131 g_AVSessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
132 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
133 g_AVControllerItem = g_AVSessionService->CreateNewControllerForSession(
134 g_AVSessionItem->GetPid(), g_AVSessionItem);
135 }
136
TearDownTestCase()137 void AVsessionItemTest::TearDownTestCase()
138 {
139 SLOGI("AVsessionItemTest TearDownTestCase");
140 g_AVSessionService->HandleSessionRelease(g_AVSessionItem->GetSessionId());
141 g_AVControllerItem->Destroy();
142 g_AVSessionItem->Destroy();
143 }
144
SetUp()145 void AVsessionItemTest::SetUp()
146 {}
147
TearDown()148 void AVsessionItemTest::TearDown()
149 {}
150
151 /**
152 * @tc.name: AVSessionItem_DestroyTask_001
153 * @tc.desc: Test DestroyTask when the session is already destroyed.
154 * @tc.type: FUNC
155 * @tc.require: #I5Y4MZ
156 */
157 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_001, TestSize.Level0)
158 {
159 SLOGD("AVSessionItem_DestroyTask_001 begin!");
160 g_AVSessionItem->isDestroyed_ = true;
161 int32_t result = g_AVSessionItem->DestroyTask(false);
162 EXPECT_EQ(result, AVSESSION_SUCCESS);
163 SLOGD("AVSessionItem_DestroyTask_001 end!");
164 }
165
166 /**
167 * @tc.name: AVSessionItem_DestroyTask_002
168 * @tc.desc: Test DestroyTask with no valid controllers in the controllers list.
169 * @tc.type: FUNC
170 * @tc.require: #I5Y4MZ
171 */
172 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_002, TestSize.Level0)
173 {
174 SLOGD("AVSessionItem_DestroyTask_002 begin!");
175 g_AVSessionItem->controllers_.clear();
176 int32_t result = g_AVSessionItem->DestroyTask(false);
177 EXPECT_EQ(result, AVSESSION_SUCCESS);
178 SLOGD("AVSessionItem_DestroyTask_002 end!");
179 }
180
181 /**
182 * @tc.name: AVSessionItem_DestroyTask_003
183 * @tc.desc: Test DestroyTask with castHandle_ > 0 but sessionTag_ is "RemoteCast".
184 * @tc.type: FUNC
185 * @tc.require: #I5Y4MZ
186 */
187 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_003, TestSize.Level0)
188 {
189 SLOGD("AVSessionItem_DestroyTask_003 begin!");
190 g_AVSessionItem->descriptor_.sessionTag_ = "RemoteCast";
191 g_AVSessionItem->castHandle_ = 1;
192 int32_t result = g_AVSessionItem->DestroyTask(false);
193 EXPECT_EQ(result, AVSESSION_SUCCESS);
194 SLOGD("AVSessionItem_DestroyTask_003 end!");
195 }
196
197 /**
198 * @tc.name: AVSessionItem_DestroyTask_004
199 * @tc.desc: Test DestroyTask with castHandle_ > 0 and sessionTag_ is not "RemoteCast".
200 * @tc.type: FUNC
201 * @tc.require: #I5Y4MZ
202 */
203 HWTEST_F(AVsessionItemTest, AVSessionItem_DestroyTask_004, TestSize.Level0)
204 {
205 SLOGD("AVSessionItem_DestroyTask_004 begin!");
206 g_AVSessionItem->descriptor_.sessionTag_ = "TestSession";
207 g_AVSessionItem->castHandle_ = 1;
208 int32_t result = g_AVSessionItem->DestroyTask(false);
209 EXPECT_EQ(result, AVSESSION_SUCCESS);
210 SLOGD("AVSessionItem_DestroyTask_004 end!");
211 }
212
213 /**
214 * @tc.name: AVSessionItem_SetAVCallMetaData_001
215 * @tc.desc: Test SetAVCallMetaData with valid media image in AVCallMetaData.
216 * @tc.type: FUNC
217 * @tc.require: #I5Y4MZ
218 */
219 HWTEST_F(AVsessionItemTest, AVSessionItem_SetAVCallMetaData_001, TestSize.Level0)
220 {
221 SLOGD("AVSessionItem_SetAVCallMetaData_001 begin!");
222 OHOS::AVSession::AVCallMetaData avCallMetaData;
223 std::shared_ptr<AVSessionPixelMap> innerPixelMap = std::make_shared<AVSessionPixelMap>();
224 avCallMetaData.SetMediaImage(innerPixelMap);
225 int32_t result = g_AVSessionItem->SetAVCallMetaData(avCallMetaData);
226 EXPECT_EQ(result, AVSESSION_SUCCESS);
227 SLOGD("AVSessionItem_SetAVCallMetaData_001 end!");
228 }
229
230 /**
231 * @tc.name: AVSessionItem_SetAVCallMetaData_002
232 * @tc.desc: Test SetAVCallMetaData with no valid controllers in the controllers list.
233 * @tc.type: FUNC
234 * @tc.require: #I5Y4MZ
235 */
236 HWTEST_F(AVsessionItemTest, AVSessionItem_SetAVCallMetaData_002, TestSize.Level0)
237 {
238 SLOGD("AVSessionItem_SetAVCallMetaData_002 begin!");
239 g_AVSessionItem->controllers_.clear();
240 OHOS::AVSession::AVCallMetaData avCallMetaData;
241 avCallMetaData.SetName("TestName");
242 avCallMetaData.SetPhoneNumber("123456789");
243 int32_t result = g_AVSessionItem->SetAVCallMetaData(avCallMetaData);
244 EXPECT_EQ(result, AVSESSION_SUCCESS);
245 SLOGD("AVSessionItem_SetAVCallMetaData_002 end!");
246 }
247
248 /**
249 * @tc.name: AVSessionItem_SetLaunchAbility_001
250 * @tc.desc: Test SetLaunchAbility with want being nullptr.
251 * @tc.type: FUNC
252 * @tc.require: #I5Y4MZ
253 */
254 HWTEST_F(AVsessionItemTest, AVSessionItem_SetLaunchAbility_001, TestSize.Level0)
255 {
256 SLOGD("AVSessionItem_SetLaunchAbility_001 begin!");
257 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
258 int32_t result = g_AVSessionItem->SetLaunchAbility(ability);
259 EXPECT_EQ(result, AVSESSION_SUCCESS);
260 SLOGD("AVSessionItem_SetLaunchAbility_001 end!");
261 }
262
263 /**
264 * @tc.name: AVSessionItem_SetLaunchAbility_003
265 * @tc.desc: Test SetLaunchAbility with valid want and launWantAgent.
266 * @tc.type: FUNC
267 * @tc.require: #I5Y4MZ
268 */
269 HWTEST_F(AVsessionItemTest, AVSessionItem_SetLaunchAbility_003, TestSize.Level0)
270 {
271 SLOGD("AVSessionItem_SetLaunchAbility_003 begin!");
272 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
273 std::shared_ptr<OHOS::AbilityRuntime::WantAgent::WantAgent> launWantAgent =
274 std::make_shared<OHOS::AbilityRuntime::WantAgent::WantAgent>(ability);
275 int32_t result = g_AVSessionItem->SetLaunchAbility(ability);
276 EXPECT_EQ(result, AVSESSION_SUCCESS);
277 SLOGD("AVSessionItem_SetLaunchAbility_003 end!");
278 }
279
280 /**
281 * @tc.name: AVSessionItem_Activate_001
282 * @tc.desc: Test Activate with valid controllers.
283 * @tc.type: FUNC
284 * @tc.require: #I5Y4MZ
285 */
286 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_001, TestSize.Level0)
287 {
288 SLOGD("AVSessionItem_Activate_001 begin!");
289 OHOS::sptr<AVControllerItem> controller = g_AVControllerItem;
290 g_AVSessionItem->controllers_[controller->GetPid()] = controller;
291 int32_t result = g_AVSessionItem->Activate();
292 EXPECT_EQ(result, AVSESSION_SUCCESS);
293 SLOGD("AVSessionItem_Activate_001 end!");
294 }
295
296 /**
297 * @tc.name: AVSessionItem_Activate_002
298 * @tc.desc: Test Activate with session type not being voice or video call.
299 * @tc.type: FUNC
300 * @tc.require: #I5Y4MZ
301 */
302 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_002, TestSize.Level0)
303 {
304 SLOGD("AVSessionItem_Activate_002 begin!");
305 g_AVSessionItem->descriptor_.sessionType_ = AVSession::SESSION_TYPE_VOICE_CALL;
306 int32_t result = g_AVSessionItem->Activate();
307 EXPECT_EQ(result, AVSESSION_SUCCESS);
308 SLOGD("AVSessionItem_Activate_002 end!");
309 }
310
311 /**
312 * @tc.name: AVSessionItem_Activate_003
313 * @tc.desc: Test Activate with session type being voice or video call.
314 * @tc.type: FUNC
315 * @tc.require: #I5Y4MZ
316 */
317 HWTEST_F(AVsessionItemTest, AVSessionItem_Activate_003, TestSize.Level0)
318 {
319 SLOGD("AVSessionItem_Activate_003 begin!");
320 g_AVSessionItem->descriptor_.sessionType_ = AVSession::SESSION_TYPE_VIDEO_CALL;
321 int32_t result = g_AVSessionItem->Activate();
322 EXPECT_EQ(result, AVSESSION_SUCCESS);
323 SLOGD("AVSessionItem_Activate_003 end!");
324 }
325
326 /**
327 * @tc.name: AVSessionItem_UpdateElement_001
328 * @tc.desc: Test update session element.
329 * @tc.type: FUNC
330 * @tc.require: #I5Y4MZ
331 */
332 HWTEST_F(AVsessionItemTest, AVSessionItem_UpdateElement_001, TestSize.Level1)
333 {
334 SLOGD("AVSessionItem_UpdateElement_001 begin!");
335 OHOS::AppExecFwk::ElementName elementName;
336 elementName.SetBundleName("TestBundleName");
337 elementName.SetAbilityName("TestAbilityName");
338 g_AVSessionItem->UpdateSessionElement(elementName);
339 EXPECT_EQ(g_AVSessionItem->GetBundleName(), "TestBundleName");
340 EXPECT_EQ(g_AVSessionItem->GetAbilityName(), "TestAbilityName");
341
342 OHOS::AppExecFwk::ElementName oriElementName;
343 oriElementName.SetBundleName(g_testAnotherBundleName);
344 oriElementName.SetAbilityName(g_testAnotherAbilityName);
345 g_AVSessionItem->UpdateSessionElement(oriElementName);
346 EXPECT_EQ(g_AVSessionItem->GetBundleName(), g_testAnotherBundleName);
347 EXPECT_EQ(g_AVSessionItem->GetAbilityName(), g_testAnotherAbilityName);
348 SLOGD("AVSessionItem_UpdateElement_001 end!");
349 }
350
351 /**
352 * @tc.name: AVSessionItem_GetAnonymousDeviceId_001
353 * @tc.desc: Test GetAnonymousDeviceId with empty deviceId.
354 * @tc.type: FUNC
355 * @tc.require: #I5Y4MZ
356 */
357 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_001, TestSize.Level0)
358 {
359 SLOGD("AVSessionItem_GetAnonymousDeviceId_001 begin!");
360 std::string deviceId = "";
361 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
362 EXPECT_EQ(result, "unknown");
363 SLOGD("AVSessionItem_GetAnonymousDeviceId_001 end!");
364 }
365
366 /**
367 * @tc.name: AVSessionItem_GetAnonymousDeviceId_002
368 * @tc.desc: Test GetAnonymousDeviceId with deviceId length less than DEVICE_ID_MIN_LEN.
369 * @tc.type: FUNC
370 * @tc.require: #I5Y4MZ
371 */
372 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_002, TestSize.Level0)
373 {
374 SLOGD("AVSessionItem_GetAnonymousDeviceId_002 begin!");
375 std::string deviceId = "12345";
376 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
377 EXPECT_EQ(result, "unknown");
378 SLOGD("AVSessionItem_GetAnonymousDeviceId_002 end!");
379 }
380
381 /**
382 * @tc.name: AVSessionItem_GetAnonymousDeviceId_003
383 * @tc.desc: Test GetAnonymousDeviceId with deviceId length greater than or equal to DEVICE_ID_MIN_LEN.
384 * @tc.type: FUNC
385 * @tc.require: #I5Y4MZ
386 */
387 HWTEST_F(AVsessionItemTest, AVSessionItem_GetAnonymousDeviceId_003, TestSize.Level0)
388 {
389 SLOGD("AVSessionItem_GetAnonymousDeviceId_003 begin!");
390 std::string deviceId = "1234567890";
391 std::string result = g_AVSessionItem->GetAnonymousDeviceId(deviceId);
392 EXPECT_NE(result, "unknown");
393 SLOGD("AVSessionItem_GetAnonymousDeviceId_003 end!");
394 }
395
396 /**
397 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_001
398 * @tc.desc: Test RegisterListenerStreamToCast with castHandle_ > 0.
399 * @tc.type: FUNC
400 * @tc.require: #I5Y4MZ
401 */
402 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_001, TestSize.Level0)
403 {
404 SLOGD("AVSessionItem_RegisterListenerStreamToCast_001 begin!");
405 g_AVSessionItem->castHandle_ = 1;
406 std::pair<std::string, std::string> serviceNameStatePair;
407 DeviceInfo deviceInfo;
408 deviceInfo.deviceId_ = "1234567890";
409 deviceInfo.deviceName_ = "TestDevice";
410 deviceInfo.deviceType_ = 1;
411 deviceInfo.networkId_ = "12345";
412 deviceInfo.supportedProtocols_ = 2;
413 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
414 EXPECT_EQ(result, AVSESSION_ERROR);
415 SLOGD("AVSessionItem_RegisterListenerStreamToCast_001 end!");
416 }
417
418 /**
419 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_002
420 * @tc.desc: Test RegisterListenerStreamToCast with GetMirrorCastHandle() == -1.
421 * @tc.type: FUNC
422 * @tc.require: #I5Y4MZ
423 */
424 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_002, TestSize.Level0)
425 {
426 SLOGD("AVSessionItem_RegisterListenerStreamToCast_002 begin!");
427 g_AVSessionItem->castHandle_ = AVSESSION_ERROR;
428 std::pair<std::string, std::string> serviceNameStatePair;
429 DeviceInfo deviceInfo;
430 deviceInfo.deviceId_ = "1234567890";
431 deviceInfo.deviceName_ = "TestDevice";
432 deviceInfo.deviceType_ = 1;
433 deviceInfo.networkId_ = "12345";
434 deviceInfo.supportedProtocols_ = 2;
435 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
436 EXPECT_EQ(result, AVSESSION_SUCCESS);
437 SLOGD("AVSessionItem_RegisterListenerStreamToCast_002 end!");
438 }
439
440 /**
441 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_003
442 * @tc.desc: Test RegisterListenerStreamToCast with castControllerProxy_ and GetDescription() != nullptr.
443 * @tc.type: FUNC
444 * @tc.require: #I5Y4MZ
445 */
446 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_003, TestSize.Level0)
447 {
448 SLOGD("AVSessionItem_RegisterListenerStreamToCast_003 begin!");
449 g_AVSessionItem->castHandle_ = 0;
450 std::pair<std::string, std::string> serviceNameStatePair;
451 DeviceInfo deviceInfo;
452 deviceInfo.deviceId_ = "1234567890";
453 deviceInfo.deviceName_ = "TestDevice";
454 deviceInfo.deviceType_ = 1;
455 deviceInfo.networkId_ = "12345";
456 deviceInfo.supportedProtocols_ = 2;
457
458 auto mockCastControllerProxy = std::make_shared<MockIAVCastControllerProxy>();
459 g_AVSessionItem->castControllerProxy_ = mockCastControllerProxy;
460 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
461 EXPECT_EQ(result, AVSESSION_SUCCESS);
462 SLOGD("AVSessionItem_RegisterListenerStreamToCast_003 end!");
463 }
464
465
466 /**
467 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_004
468 * @tc.desc: Test RegisterListenerStreamToCast with castControllerProxy_ == nullptr and castHandle_ <= 0.
469 * @tc.type: FUNC
470 * @tc.require: #I5Y4MZ
471 */
472 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_004, TestSize.Level0)
473 {
474 SLOGD("AVSessionItem_RegisterListenerStreamToCast_004 begin!");
475 g_AVSessionItem->castHandle_ = 0;
476 std::pair<std::string, std::string> serviceNameStatePair;
477 DeviceInfo deviceInfo;
478 deviceInfo.deviceId_ = "1234567890";
479 deviceInfo.deviceName_ = "TestDevice";
480 deviceInfo.deviceType_ = 1;
481 deviceInfo.networkId_ = "12345";
482 deviceInfo.supportedProtocols_ = 2;
483 g_AVSessionItem->castControllerProxy_ = nullptr;
484 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
485 EXPECT_EQ(result, AVSESSION_SUCCESS);
486 SLOGD("AVSessionItem_RegisterListenerStreamToCast_004 end!");
487 }
488
489 /**
490 * @tc.name: AVSessionItem_RegisterListenerStreamToCast_005
491 * @tc.desc: Test RegisterListenerStreamToCast with GetCurrentItem().GetDescription() == nullptr and castHandle_ <= 0.
492 * @tc.type: FUNC
493 * @tc.require: #I5Y4MZ
494 */
495 HWTEST_F(AVsessionItemTest, AVSessionItem_RegisterListenerStreamToCast_005, TestSize.Level0)
496 {
497 SLOGD("AVSessionItem_RegisterListenerStreamToCast_005 begin!");
498 g_AVSessionItem->castHandle_ = 0;
499 std::pair<std::string, std::string> serviceNameStatePair;
500 DeviceInfo deviceInfo;
501 deviceInfo.deviceId_ = "1234567890";
502 deviceInfo.deviceName_ = "TestDevice";
503 deviceInfo.deviceType_ = 1;
504 deviceInfo.networkId_ = "12345";
505 deviceInfo.supportedProtocols_ = 2;
506
507 auto mockCastControllerProxy = std::make_shared<MockIAVCastControllerProxy>();
508 g_AVSessionItem->castControllerProxy_ = mockCastControllerProxy;
509 AVQueueItem item;
510 item.description_ = nullptr;
511 int32_t result = g_AVSessionItem->RegisterListenerStreamToCast(serviceNameStatePair, deviceInfo);
512 EXPECT_EQ(result, AVSESSION_SUCCESS);
513 SLOGD("AVSessionItem_RegisterListenerStreamToCast_005 end!");
514 }
515
516
517 /**
518 * @tc.name: AVSessionItem_SetOutputDevice_001
519 * @tc.desc: Test SetOutputDevice with controllers not empty.
520 * @tc.type: FUNC
521 * @tc.require: #I5Y4MZ
522 */
523 HWTEST_F(AVsessionItemTest, AVSessionItem_SetOutputDevice_001, TestSize.Level0)
524 {
525 SLOGD("AVSessionItem_SetOutputDevice_001 begin!");
526 OutputDeviceInfo info;
527 DeviceInfo deviceInfo;
528 deviceInfo.deviceId_ = "DeviceId1";
529 deviceInfo.deviceName_ = "DeviceName1";
530 deviceInfo.deviceType_ = 1;
531 info.deviceInfos_.push_back(deviceInfo);
532 OHOS::sptr<AVControllerItem> controller = new AVControllerItem(1, g_AVSessionItem);
533 g_AVSessionItem->SetOutputDevice(info);
534 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceId_ == "DeviceId1");
535 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceName_ == "DeviceName1");
536 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceType_ == 1);
537 SLOGD("AVSessionItem_SetOutputDevice_001 end!");
538 }
539
540 /**
541 * @tc.name: AVSessionItem_SetOutputDevice_002
542 * @tc.desc: Test SetOutputDevice with controllers empty.
543 * @tc.type: FUNC
544 * @tc.require: #I5Y4MZ
545 */
546 HWTEST_F(AVsessionItemTest, AVSessionItem_SetOutputDevice_002, TestSize.Level0)
547 {
548 SLOGD("AVSessionItem_SetOutputDevice_002 begin!");
549 OutputDeviceInfo info;
550 DeviceInfo deviceInfo;
551 deviceInfo.deviceId_ = "DeviceId1";
552 deviceInfo.deviceName_ = "DeviceName1";
553 deviceInfo.deviceType_ = 1;
554 info.deviceInfos_.push_back(deviceInfo);
555 g_AVSessionItem->controllers_.clear();
556 g_AVSessionItem->SetOutputDevice(info);
557 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceId_ == "DeviceId1");
558 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceName_ == "DeviceName1");
559 EXPECT_TRUE(g_AVSessionItem->descriptor_.outputDeviceInfo_.deviceInfos_[0].deviceType_ == 1);
560 SLOGD("AVSessionItem_SetOutputDevice_002 end!");
561 }
562
563 /**
564 * @tc.name: AVSessionItem_HandleOnSetTargetLoopMode_001
565 * @tc.desc: Test HandleOnSetTargetLoopMode.
566 * @tc.type: FUNC
567 * @tc.require: #I5Y4MZ
568 */
569 HWTEST_F(AVsessionItemTest, AVSessionItem_HandleOnSetTargetLoopMode_001, TestSize.Level0)
570 {
571 SLOGD("AVSessionItem_HandleOnSetTargetLoopMode_001 begin!");
572 OHOS::sptr<IAVSessionCallback> callback = new(std::nothrow) AVSessionCallbackImpl();
573 ASSERT_TRUE(callback != nullptr);
574 g_AVSessionItem->callback_ = callback;
575 AVControlCommand cmd;
576 cmd.SetCommand(AVControlCommand::SESSION_CMD_SET_TARGET_LOOP_MODE);
577 g_AVSessionItem->HandleOnSetTargetLoopMode(cmd);
578 int32_t targetLoopMode = AVSESSION_ERROR;
579 auto ret = cmd.GetTargetLoopMode(targetLoopMode);
580 EXPECT_EQ(ret, AVSESSION_SUCCESS);
581 SLOGD("AVSessionItem_HandleOnSetTargetLoopMode_001 end!");
582 }
583
584 /**
585 * @tc.name: AVSessionItem_DelRecommend_001
586 * @tc.desc: Test DelRecommend.
587 * @tc.type: FUNC
588 * @tc.require: #I5Y4MZ
589 */
590 HWTEST_F(AVsessionItemTest, AVSessionItem_DelRecommend_001, TestSize.Level1)
591 {
592 SLOGD("AVSessionItem_DelRecommend_001 begin!");
593 EXPECT_NE(g_AVSessionItem, nullptr);
594 g_AVSessionItem->isRecommend_ = true;
595 g_AVSessionItem->DelRecommend();
596 EXPECT_EQ(g_AVSessionItem->isRecommend_, false);
597 SLOGD("AVSessionItem_DelRecommend_001 end!");
598 }
599
600 /**
601 * @tc.name: AVSessionItem_CheckIfSendCapsule_001
602 * @tc.desc: Test CheckIfSendCapsule.
603 * @tc.type: FUNC
604 * @tc.require: #I5Y4MZ
605 */
606 HWTEST_F(AVsessionItemTest, AVSessionItem_CheckIfSendCapsule_001, TestSize.Level1)
607 {
608 SLOGD("AVSessionItem_CheckIfSendCapsule_001 begin!");
609 EXPECT_NE(g_AVSessionItem, nullptr);
610 int oriUid = g_AVSessionItem->GetUid();
611 g_AVSessionItem->SetUid(5557);
612 AVPlaybackState state;
613 state.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
614 g_AVSessionItem->CheckIfSendCapsule(state);
615 EXPECT_EQ(g_AVSessionItem->isPlayingState_, true);
616 state.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
617 g_AVSessionItem->CheckIfSendCapsule(state);
618 EXPECT_EQ(g_AVSessionItem->isPlayingState_, false);
619 g_AVSessionItem->SetUid(oriUid);
620 SLOGD("AVSessionItem_CheckIfSendCapsule_001 end!");
621 }
622
623 #ifdef ENABLE_AVSESSION_SYSEVENT_CONTROL
624 /**
625 * @tc.name: AVSessionItem_ReportPlaybackState_001
626 * @tc.desc: Test ReportPlaybackState.
627 * @tc.type: FUNC
628 * @tc.require: #IC7XD5
629 */
630 HWTEST_F(AVsessionItemTest, AVSessionItem_ReportPlaybackState_001, TestSize.Level0)
631 {
632 ASSERT_TRUE(g_AVSessionItem != nullptr);
633 AVPlaybackState state;
634 state.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
635 g_AVSessionItem->ReportPlaybackState(state);
636 state.SetState(AVPlaybackState::PLAYBACK_STATE_PAUSE);
637 g_AVSessionItem->ReportPlaybackState(state);
638 state.SetState(AVPlaybackState::PLAYBACK_STATE_PREPARE);
639 g_AVSessionItem->ReportPlaybackState(state);
640
641 auto stateInfo = AVSessionSysEvent::GetInstance().GetPlayingStateInfo(g_testAnotherBundleName);
642 ASSERT_TRUE(stateInfo != nullptr);
643 for (auto i = 0; i < REPORT_SIZE; i++) {
644 stateInfo->playbackState_.push_back(0);
645 }
646
647 state.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
648 AVSessionSysEvent::GetInstance().UpdatePlaybackState(g_testAnotherBundleName, state.GetState());
649 EXPECT_EQ(stateInfo->playbackState_.size(), 0);
650 }
651
652 /**
653 * @tc.name: AVSessionItem_ReportMetadataChange_001
654 * @tc.desc: Test ReportMetadataChange.
655 * @tc.type: FUNC
656 * @tc.require: #IC7XD5
657 */
658 HWTEST_F(AVsessionItemTest, AVSessionItem_ReportMetadataChange_001, TestSize.Level0)
659 {
660 ASSERT_TRUE(g_AVSessionItem != nullptr);
661 std::string title = "Test Title";
662 std::string url = "Test Url";
663 AVMetaData metadata;
664 g_AVSessionItem->ReportMetadataChange(metadata);
665
666 metadata.SetTitle(title);
667 g_AVSessionItem->ReportMetadataChange(metadata);
668
669 metadata.SetTitle("");
670 metadata.SetMediaImageUri(url);
671 g_AVSessionItem->ReportMetadataChange(metadata);
672
673 auto stateInfo = AVSessionSysEvent::GetInstance().GetPlayingStateInfo(g_testAnotherBundleName);
674 ASSERT_TRUE(stateInfo != nullptr);
675 for (auto i = 0; i < REPORT_SIZE; i++) {
676 stateInfo->metaQuality_.push_back(0);
677 }
678
679 AVSessionSysEvent::GetInstance().UpdateMetaQuality(g_testAnotherBundleName, MetadataQuality::METADATA_QUALITY_BOTH);
680 EXPECT_EQ(stateInfo->metaQuality_.size(), 0);
681 }
682
683 /**
684 * @tc.name: AVSessionItem_ReportCommandChange_001
685 * @tc.desc: Test ReportCommandChange.
686 * @tc.type: FUNC
687 * @tc.require: #IC7XD5
688 */
689 HWTEST_F(AVsessionItemTest, AVSessionItem_ReportCommandChange_001, TestSize.Level0)
690 {
691 ASSERT_TRUE(g_AVSessionItem != nullptr);
692 g_AVSessionItem->supportedCmd_.push_back(REPORT_SIZE);
693 g_AVSessionItem->ReportCommandChange();
694
695 auto stateInfo = AVSessionSysEvent::GetInstance().GetPlayingStateInfo(g_testAnotherBundleName);
696 ASSERT_TRUE(stateInfo != nullptr);
697 for (auto i = 0; i < REPORT_SIZE; i++) {
698 stateInfo->commandQuality_.push_back(0);
699 }
700
701 AVSessionSysEvent::GetInstance().UpdateCommandQuality(g_testAnotherBundleName, 0);
702 EXPECT_EQ(stateInfo->commandQuality_.size(), 0);
703 }
704
705 /**
706 * @tc.name: AVSessionItem_ReportSessionControl_001
707 * @tc.desc: Test ReportSessionControl.
708 * @tc.type: FUNC
709 * @tc.require: #IC7XD5
710 */
711 HWTEST_F(AVsessionItemTest, AVSessionItem_ReportSessionControl_001, TestSize.Level0)
712 {
713 ASSERT_TRUE(g_AVSessionItem != nullptr);
714 g_AVSessionItem->ReportSessionControl(g_testAnotherBundleName, AVControlCommand::SESSION_CMD_PLAY);
715 g_AVSessionItem->ReportSessionControl(g_testAnotherBundleName, AVControlCommand::SESSION_CMD_PAUSE);
716 g_AVSessionItem->ReportSessionControl(g_testAnotherBundleName, CONTROL_COLD_START);
717 g_AVSessionItem->ReportSessionControl(g_testAnotherBundleName, REPORT_SIZE);
718
719 auto stateInfo = AVSessionSysEvent::GetInstance().GetPlayingStateInfo(g_testAnotherBundleName);
720 ASSERT_TRUE(stateInfo != nullptr);
721 for (auto i = 0; i < REPORT_SIZE; i++) {
722 stateInfo->control_.push_back(0);
723 }
724
725 AVSessionSysEvent::GetInstance().ReportPlayingState(g_testAnotherBundleName);
726 EXPECT_EQ(stateInfo->control_.size(), 0);
727 }
728 #endif
729 } //AVSession
730 } //OHOS
731