1 /*
2  * Copyright (c) 2024 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 "avsession_log.h"
18 #include "avsession_errors.h"
19 #include "iservice_registry.h"
20 #include "avmedia_description.h"
21 #include "av_file_descriptor.h"
22 #include "system_ability_definition.h"
23 #include "avsession_callback_proxy.h"
24 #include "avsession_controller_proxy.h"
25 #include "avsession_proxy.h"
26 #include "avsession_service.h"
27 
28 using namespace OHOS;
29 using namespace OHOS::AVSession;
30 
31 class AVSessionProxyTest : public testing::Test {
32 public:
33     static void SetUpTestCase(void);
34     static void TearDownTestCase(void);
35     void SetUp();
36     void TearDown();
37 };
38 
SetUpTestCase()39 void AVSessionProxyTest::SetUpTestCase()
40 {
41 }
42 
TearDownTestCase()43 void AVSessionProxyTest::TearDownTestCase()
44 {
45 }
46 
SetUp()47 void AVSessionProxyTest::SetUp()
48 {
49 }
50 
TearDown()51 void AVSessionProxyTest::TearDown()
52 {
53 }
54 
55 static const int32_t DURATION_TIME = 40000;
GetAVMetaData()56 static OHOS::AVSession::AVMetaData GetAVMetaData()
57 {
58     OHOS::AVSession::AVMetaData g_metaData;
59     g_metaData.Reset();
60     g_metaData.SetAssetId("123");
61     g_metaData.SetTitle("Black Humor");
62     g_metaData.SetArtist("zhoujielun");
63     g_metaData.SetAuthor("zhoujielun");
64     g_metaData.SetAlbum("Jay");
65     g_metaData.SetWriter("zhoujielun");
66     g_metaData.SetComposer("zhoujielun");
67     g_metaData.SetDuration(DURATION_TIME);
68     g_metaData.SetMediaImageUri("xxxxx");
69     g_metaData.SetSubTitle("fac");
70     g_metaData.SetDescription("for friends");
71     g_metaData.SetLyric("xxxxx");
72     return g_metaData;
73 }
74 
75 
76 class AVSessionCallbackImpl : public AVSessionCallback {
77 public:
OnPlay()78     void OnPlay() override {};
OnPause()79     void OnPause() override {};
OnStop()80     void OnStop() override {};
OnPlayNext()81     void OnPlayNext() override {};
OnPlayPrevious()82     void OnPlayPrevious() override {};
OnFastForward(int64_t time)83     void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)84     void OnRewind(int64_t time) override {};
OnSeek(int64_t time)85     void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)86     void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)87     void OnSetLoopMode(int32_t loopMode) override {};
OnToggleFavorite(const std::string & mediald)88     void OnToggleFavorite(const std::string& mediald) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)89     void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)90     void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)91     void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)92     void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()93     void OnAVCallAnswer() override {};
OnAVCallHangUp()94     void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()95     void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)96     void OnPlayFromAssetId(int64_t assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)97     void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
98 
~AVSessionCallbackImpl()99     ~AVSessionCallbackImpl() override {};
100 };
101 
102 
103 /**
104  * @tc.name: GetSessionId001
105  * @tc.desc: Test GetSessionId
106  * @tc.type: FUNC
107  */
108 static HWTEST_F(AVSessionProxyTest, GetSessionId001, testing::ext::TestSize.Level1)
109 {
110     SLOGI("GetSessionId001, start");
111 
112     int32_t ret = AVSESSION_ERROR;
113 
114     int32_t systemAbilityId = 1;
115     bool runOnCreate = true;
116     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
117     sessionService->OnStart();
118 
119     sptr<IRemoteObject> sessionInner;
120     std::string tag = "tag";
121     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
122     std::string deviceId = "deviceId";
123     std::string bundleName = "bundleName";
124     std::string abilityName = "abilityName";
125     std::string moduleName = "moduleName";
126     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
127     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
128     EXPECT_TRUE(sessionInner != nullptr);
129     EXPECT_EQ(ret, AVSESSION_SUCCESS);
130 
131     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
132     std::string sessionId = aVSessionProxy->GetSessionId();
133     EXPECT_NE(sessionId, "");
134 
135     sessionService->OnStop();
136     sessionInner = nullptr;
137     sessionService = nullptr;
138     aVSessionProxy = nullptr;
139 
140     SLOGI("GetSessionId001, end");
141 }
142 
143 /**
144  * @tc.name: GetSessionType001
145  * @tc.desc: Test GetSessionType
146  * @tc.type: FUNC
147  */
148 static HWTEST_F(AVSessionProxyTest, GetSessionType001, testing::ext::TestSize.Level1)
149 {
150     SLOGI("GetSessionType001, start");
151 
152     int32_t ret = AVSESSION_ERROR;
153 
154     int32_t systemAbilityId = 1;
155     bool runOnCreate = true;
156     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
157     sessionService->OnStart();
158 
159     sptr<IRemoteObject> sessionInner;
160     std::string tag = "tag";
161     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
162     std::string deviceId = "deviceId";
163     std::string bundleName = "bundleName";
164     std::string abilityName = "abilityName";
165     std::string moduleName = "moduleName";
166     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
167     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
168     EXPECT_TRUE(sessionInner != nullptr);
169     EXPECT_EQ(ret, AVSESSION_SUCCESS);
170 
171     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
172     std::string typeStr = aVSessionProxy->GetSessionType();
173     EXPECT_NE(typeStr, "");
174 
175     sessionService->OnStop();
176     sessionInner = nullptr;
177     sessionService = nullptr;
178     aVSessionProxy = nullptr;
179 
180     SLOGI("GetSessionType001, end");
181 }
182 
183 /**
184  * @tc.name: SetAVCallMetaData001
185  * @tc.desc: Test SetAVCallMetaData
186  * @tc.type: FUNC
187  */
188 static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData001, testing::ext::TestSize.Level1)
189 {
190     SLOGI("SetAVCallMetaData001, start");
191 
192     int32_t ret = AVSESSION_ERROR;
193 
194     int32_t systemAbilityId = 1;
195     bool runOnCreate = true;
196     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
197     sessionService->OnStart();
198 
199     sptr<IRemoteObject> sessionInner;
200     std::string tag = "tag";
201 
202     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
203     std::string deviceId = "deviceId";
204     std::string bundleName = "bundleName";
205     std::string abilityName = "abilityName";
206     std::string moduleName = "moduleName";
207     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
208     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
209     EXPECT_TRUE(sessionInner != nullptr);
210     EXPECT_EQ(ret, AVSESSION_SUCCESS);
211 
212     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
213     AVCallMetaData avCallMetaData;
214     ret = aVSessionProxy->SetAVCallMetaData(avCallMetaData);
215     EXPECT_EQ(ret, ERR_INVALID_PARAM);
216 
217     sessionService->OnStop();
218     sessionInner = nullptr;
219     sessionService = nullptr;
220     aVSessionProxy = nullptr;
221 
222     SLOGI("SetAVCallMetaData001, end");
223 }
224 
225 /**
226  * @tc.name: SetAVCallMetaData002
227  * @tc.desc: Test SetAVCallMetaData
228  * @tc.type: FUNC
229  */
230 static HWTEST_F(AVSessionProxyTest, SetAVCallMetaData002, testing::ext::TestSize.Level1)
231 {
232     SLOGI("SetAVCallMetaData002, start");
233 
234     int32_t ret = AVSESSION_ERROR;
235 
236     int32_t systemAbilityId = 1;
237     bool runOnCreate = true;
238     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
239     sessionService->OnStart();
240 
241     sptr<IRemoteObject> sessionInner;
242     std::string tag = "tag";
243     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
244     std::string deviceId = "deviceId";
245     std::string bundleName = "bundleName";
246     std::string abilityName = "abilityName";
247     std::string moduleName = "moduleName";
248     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
249     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
250     EXPECT_TRUE(sessionInner != nullptr);
251     EXPECT_EQ(ret, AVSESSION_SUCCESS);
252 
253 
254     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
255     AVCallMetaData avCallMetaData;
256     avCallMetaData.SetName("name");
257     avCallMetaData.SetPhoneNumber("number");
258     ret = aVSessionProxy->SetAVCallMetaData(avCallMetaData);
259     EXPECT_EQ(ret, AVSESSION_SUCCESS);
260 
261     sessionService->OnStop();
262     sessionInner = nullptr;
263     sessionService = nullptr;
264     aVSessionProxy = nullptr;
265 
266     SLOGI("SetAVCallMetaData002, end");
267 }
268 
269 /**
270  * @tc.name: SetAVCallState001
271  * @tc.desc: Test SetAVCallState
272  * @tc.type: FUNC
273  */
274 static HWTEST_F(AVSessionProxyTest, SetAVCallState001, testing::ext::TestSize.Level1)
275 {
276     SLOGI("SetAVCallState001, start");
277 
278     int32_t ret = AVSESSION_ERROR;
279 
280     int32_t systemAbilityId = 1;
281     bool runOnCreate = true;
282     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
283     sessionService->OnStart();
284 
285     sptr<IRemoteObject> sessionInner;
286     std::string tag = "tag";
287     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
288     std::string deviceId = "deviceId";
289     std::string bundleName = "bundleName";
290     std::string abilityName = "abilityName";
291     std::string moduleName = "moduleName";
292     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
293     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
294     EXPECT_TRUE(sessionInner != nullptr);
295     EXPECT_EQ(ret, AVSESSION_SUCCESS);
296 
297     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
298     AVCallState avCallState;
299     avCallState.SetAVCallState(AVCallState::AVCALL_STATE_IDLE);
300     ret = aVSessionProxy->SetAVCallState(avCallState);
301     EXPECT_EQ(ret, AVSESSION_SUCCESS);
302 
303     sessionService->OnStop();
304     sessionInner = nullptr;
305     sessionService = nullptr;
306     aVSessionProxy = nullptr;
307 
308     SLOGI("SetAVCallState001, end");
309 }
310 
311 /**
312  * @tc.name: SetAVCallState002
313  * @tc.desc: Test SetAVCallState
314  * @tc.type: FUNC
315  */
316 static HWTEST_F(AVSessionProxyTest, SetAVCallState002, testing::ext::TestSize.Level1)
317 {
318     SLOGI("SetAVCallState002, start");
319 
320     int32_t ret = AVSESSION_ERROR;
321 
322     int32_t systemAbilityId = 1;
323     bool runOnCreate = true;
324     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
325     sessionService->OnStart();
326 
327     sptr<IRemoteObject> sessionInner;
328     std::string tag = "tag";
329     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
330     std::string deviceId = "deviceId";
331     std::string bundleName = "bundleName";
332     std::string abilityName = "abilityName";
333     std::string moduleName = "moduleName";
334     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
335     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
336     EXPECT_TRUE(sessionInner != nullptr);
337     EXPECT_EQ(ret, AVSESSION_SUCCESS);
338 
339     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
340     AVCallState avCallState;
341     avCallState.SetAVCallState(-1);
342     ret = aVSessionProxy->SetAVCallState(avCallState);
343     EXPECT_EQ(ret, ERR_INVALID_PARAM);
344 
345     sessionService->OnStop();
346     sessionInner = nullptr;
347     sessionService = nullptr;
348     aVSessionProxy = nullptr;
349 
350     SLOGI("SetAVCallState002, end");
351 }
352 
353 /**
354  * @tc.name: SetAVMetaData001
355  * @tc.desc: Test SetAVMetaData
356  * @tc.type: FUNC
357  */
358 static HWTEST_F(AVSessionProxyTest, SetAVMetaData001, testing::ext::TestSize.Level1)
359 {
360     SLOGI("SetAVMetaData001, start");
361 
362     int32_t ret = AVSESSION_ERROR;
363 
364     int32_t systemAbilityId = 1;
365     bool runOnCreate = true;
366     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
367     sessionService->OnStart();
368 
369     sptr<IRemoteObject> sessionInner;
370     std::string tag = "tag";
371     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
372     std::string deviceId = "deviceId";
373     std::string bundleName = "bundleName";
374     std::string abilityName = "abilityName";
375     std::string moduleName = "moduleName";
376     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
377     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
378     EXPECT_TRUE(sessionInner != nullptr);
379     EXPECT_EQ(ret, AVSESSION_SUCCESS);
380 
381     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
382     AVMetaData meta;
383     std::string assetId = "assetId";
384     meta.SetAssetId(assetId);
385     std::shared_ptr<AVSessionPixelMap> mediaImage = std::make_shared<AVSessionPixelMap>();
386     std::vector<uint8_t> imgBuffer = {1, 2, 3, 4, 5, 6, 7, 8};
387     mediaImage->SetInnerImgBuffer(imgBuffer);
388     meta.SetMediaImage(mediaImage);
389     ret = aVSessionProxy->SetAVMetaData(meta);
390     EXPECT_EQ(ret, AVSESSION_SUCCESS);
391 
392     sessionService->OnStop();
393     sessionInner = nullptr;
394     sessionService = nullptr;
395     aVSessionProxy = nullptr;
396 
397     SLOGI("SetAVMetaData001, end");
398 }
399 
400 /**
401  * @tc.name: GetAVMetaData001
402  * @tc.desc: Test GetAVMetaData
403  * @tc.type: FUNC
404  */
405 static HWTEST_F(AVSessionProxyTest, GetAVMetaData001, testing::ext::TestSize.Level1)
406 {
407     SLOGI("GetAVMetaData001, start");
408     GetAVMetaData();
409     int32_t ret = AVSESSION_ERROR;
410 
411     int32_t systemAbilityId = 1;
412     bool runOnCreate = true;
413     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
414     sessionService->OnStart();
415 
416     sptr<IRemoteObject> sessionInner;
417     std::string tag = "tag";
418     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
419     std::string deviceId = "deviceId";
420     std::string bundleName = "bundleName";
421     std::string abilityName = "abilityName";
422     std::string moduleName = "moduleName";
423     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
424     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
425     EXPECT_TRUE(sessionInner != nullptr);
426     EXPECT_EQ(ret, AVSESSION_SUCCESS);
427 
428     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
429     AVMetaData meta;
430     ret = aVSessionProxy->GetAVMetaData(meta);
431     EXPECT_EQ(ret, AVSESSION_SUCCESS);
432 
433     sessionService->OnStop();
434     sessionInner = nullptr;
435     sessionService = nullptr;
436     aVSessionProxy = nullptr;
437 
438     SLOGI("GetAVMetaData001, end");
439 }
440 
441 /**
442  * @tc.name: GetAVPlaybackState001
443  * @tc.desc: Test GetAVPlaybackState
444  * @tc.type: FUNC
445  */
446 static HWTEST_F(AVSessionProxyTest, GetAVPlaybackState001, testing::ext::TestSize.Level1)
447 {
448     SLOGI("GetAVPlaybackState001, start");
449 
450     int32_t ret = AVSESSION_ERROR;
451 
452     int32_t systemAbilityId = 1;
453 
454     bool runOnCreate = true;
455     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
456     sessionService->OnStart();
457 
458     sptr<IRemoteObject> sessionInner;
459     std::string tag = "tag";
460     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
461     std::string deviceId = "deviceId";
462     std::string bundleName = "bundleName";
463     std::string abilityName = "abilityName";
464     std::string moduleName = "moduleName";
465     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
466     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
467     EXPECT_TRUE(sessionInner != nullptr);
468     EXPECT_EQ(ret, AVSESSION_SUCCESS);
469 
470     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
471     AVPlaybackState state;
472     ret = aVSessionProxy->GetAVPlaybackState(state);
473     EXPECT_EQ(ret, AVSESSION_SUCCESS);
474 
475     sessionService->OnStop();
476     sessionInner = nullptr;
477     sessionService = nullptr;
478     aVSessionProxy = nullptr;
479 
480     SLOGI("GetAVPlaybackState001, end");
481 }
482 
483 /**
484  * @tc.name: SetAVPlaybackState001
485  * @tc.desc: Test SetAVPlaybackState
486  * @tc.type: FUNC
487  */
488 static HWTEST_F(AVSessionProxyTest, SetAVPlaybackState001, testing::ext::TestSize.Level1)
489 {
490     SLOGI("SetAVPlaybackState001, start");
491 
492     int32_t ret = AVSESSION_ERROR;
493 
494     int32_t systemAbilityId = 1;
495     bool runOnCreate = true;
496     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
497     sessionService->OnStart();
498 
499     sptr<IRemoteObject> sessionInner;
500     std::string tag = "tag";
501     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
502     std::string deviceId = "deviceId";
503     std::string bundleName = "bundleName";
504     std::string abilityName = "abilityName";
505     std::string moduleName = "moduleName";
506     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
507     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
508     EXPECT_TRUE(sessionInner != nullptr);
509     EXPECT_EQ(ret, AVSESSION_SUCCESS);
510 
511     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
512     AVPlaybackState avPlaybackState;
513     AVPlaybackState::Position position;
514     position.elapsedTime_ = 1;
515     position.updateTime_ = 1;
516     avPlaybackState.SetState(1);
517     avPlaybackState.SetSpeed(1);
518     avPlaybackState.SetPosition(position);
519     avPlaybackState.SetBufferedTime(1);
520     avPlaybackState.SetLoopMode(1);
521     avPlaybackState.SetFavorite(1);
522     avPlaybackState.SetActiveItemId(1);
523     avPlaybackState.SetVolume(1);
524     avPlaybackState.SetMaxVolume(1);
525     avPlaybackState.SetMuted(1);
526     avPlaybackState.SetDuration(1);
527     avPlaybackState.SetVideoWidth(1);
528     avPlaybackState.SetVideoHeight(1);
529     ret = aVSessionProxy->SetAVPlaybackState(avPlaybackState);
530     EXPECT_EQ(ret, AVSESSION_SUCCESS);
531 
532     sessionService->OnStop();
533     sessionInner = nullptr;
534     sessionService = nullptr;
535     aVSessionProxy = nullptr;
536 
537     SLOGI("SetAVPlaybackState001, end");
538 }
539 
540 /**
541  * @tc.name: GetAVQueueItems001
542  * @tc.desc: Test GetAVQueueItems
543  * @tc.type: FUNC
544  */
545 static HWTEST_F(AVSessionProxyTest, GetAVQueueItems001, testing::ext::TestSize.Level1)
546 {
547     SLOGI("GetAVQueueItems001, start");
548 
549     int32_t ret = AVSESSION_ERROR;
550 
551     int32_t systemAbilityId = 1;
552     bool runOnCreate = true;
553     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
554     sessionService->OnStart();
555 
556     sptr<IRemoteObject> sessionInner;
557     std::string tag = "tag";
558     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
559     std::string deviceId = "deviceId";
560     std::string bundleName = "bundleName";
561     std::string abilityName = "abilityName";
562     std::string moduleName = "moduleName";
563     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
564     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
565     EXPECT_TRUE(sessionInner != nullptr);
566     EXPECT_EQ(ret, AVSESSION_SUCCESS);
567 
568     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
569     std::vector<AVQueueItem> items = {};
570     ret = aVSessionProxy->GetAVQueueItems(items);
571     EXPECT_EQ(ret, AVSESSION_SUCCESS);
572 
573     sessionService->OnStop();
574     sessionInner = nullptr;
575     sessionService = nullptr;
576     aVSessionProxy = nullptr;
577 
578     SLOGI("GetAVQueueItems001, end");
579 }
580 
581 /**
582  * @tc.name: SetAVQueueItems001
583  * @tc.desc: Test SetAVQueueItems
584  * @tc.type: FUNC
585  */
586 static HWTEST_F(AVSessionProxyTest, SetAVQueueItems001, testing::ext::TestSize.Level1)
587 {
588     SLOGI("SetAVQueueItems001, start");
589 
590     int32_t ret = AVSESSION_ERROR;
591 
592     int32_t systemAbilityId = 1;
593     bool runOnCreate = true;
594     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
595     sessionService->OnStart();
596 
597     sptr<IRemoteObject> sessionInner;
598     std::string tag = "tag";
599     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
600     std::string deviceId = "deviceId";
601     std::string bundleName = "bundleName";
602     std::string abilityName = "abilityName";
603     std::string moduleName = "moduleName";
604     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
605     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
606     EXPECT_TRUE(sessionInner != nullptr);
607     EXPECT_EQ(ret, AVSESSION_SUCCESS);
608 
609     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
610     std::vector<AVQueueItem> items = {};
611     ret = aVSessionProxy->SetAVQueueItems(items);
612     EXPECT_EQ(ret, AVSESSION_SUCCESS);
613 
614     sessionService->OnStop();
615     sessionInner = nullptr;
616     sessionService = nullptr;
617     aVSessionProxy = nullptr;
618 
619     SLOGI("SetAVQueueItems001, end");
620 }
621 
622 /**
623  * @tc.name: GetAVQueueTitle001
624  * @tc.desc: Test GetAVQueueTitle
625  * @tc.type: FUNC
626  */
627 static HWTEST_F(AVSessionProxyTest, GetAVQueueTitle001, testing::ext::TestSize.Level1)
628 {
629     SLOGI("GetAVQueueTitle001, start");
630 
631     int32_t ret = AVSESSION_ERROR;
632 
633     int32_t systemAbilityId = 1;
634     bool runOnCreate = true;
635     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
636     sessionService->OnStart();
637 
638     sptr<IRemoteObject> sessionInner;
639     std::string tag = "tag";
640 
641     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
642     std::string deviceId = "deviceId";
643     std::string bundleName = "bundleName";
644     std::string abilityName = "abilityName";
645     std::string moduleName = "moduleName";
646     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
647     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
648     EXPECT_TRUE(sessionInner != nullptr);
649     EXPECT_EQ(ret, AVSESSION_SUCCESS);
650 
651     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
652     std::string title = "title";
653     ret = aVSessionProxy->GetAVQueueTitle(title);
654     EXPECT_EQ(ret, AVSESSION_SUCCESS);
655 
656     sessionService->OnStop();
657     sessionInner = nullptr;
658     sessionService = nullptr;
659     aVSessionProxy = nullptr;
660 
661     SLOGI("GetAVQueueTitle001, end");
662 }
663 
664 /**
665  * @tc.name: SetAVQueueTitle001
666  * @tc.desc: Test SetAVQueueTitle
667  * @tc.type: FUNC
668  */
669 static HWTEST_F(AVSessionProxyTest, SetAVQueueTitle001, testing::ext::TestSize.Level1)
670 {
671     SLOGI("SetAVQueueTitle001, start");
672 
673     int32_t ret = AVSESSION_ERROR;
674 
675     int32_t systemAbilityId = 1;
676     bool runOnCreate = true;
677     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
678     sessionService->OnStart();
679 
680     sptr<IRemoteObject> sessionInner;
681     std::string tag = "tag";
682     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
683     std::string deviceId = "deviceId";
684     std::string bundleName = "bundleName";
685     std::string abilityName = "abilityName";
686     std::string moduleName = "moduleName";
687     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
688     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
689     EXPECT_TRUE(sessionInner != nullptr);
690     EXPECT_EQ(ret, AVSESSION_SUCCESS);
691 
692 
693     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
694     std::string title = "title";
695     ret = aVSessionProxy->SetAVQueueTitle(title);
696     EXPECT_EQ(ret, AVSESSION_SUCCESS);
697 
698     sessionService->OnStop();
699     sessionInner = nullptr;
700     sessionService = nullptr;
701     aVSessionProxy = nullptr;
702 
703     SLOGI("SetAVQueueTitle001, end");
704 }
705 
706 /**
707  * @tc.name: SetLaunchAbility001
708  * @tc.desc: Test SetLaunchAbility
709  * @tc.type: FUNC
710  */
711 static HWTEST_F(AVSessionProxyTest, SetLaunchAbility001, testing::ext::TestSize.Level1)
712 {
713     SLOGI("SetLaunchAbility001, start");
714 
715     int32_t ret = AVSESSION_ERROR;
716 
717     int32_t systemAbilityId = 1;
718     bool runOnCreate = true;
719     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
720     sessionService->OnStart();
721 
722     sptr<IRemoteObject> sessionInner;
723     std::string tag = "tag";
724     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
725     std::string deviceId = "deviceId";
726     std::string bundleName = "bundleName";
727     std::string abilityName = "abilityName";
728     std::string moduleName = "moduleName";
729     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
730     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
731     EXPECT_TRUE(sessionInner != nullptr);
732     EXPECT_EQ(ret, AVSESSION_SUCCESS);
733 
734     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
735     OHOS::AbilityRuntime::WantAgent::WantAgent ability;
736     ret = aVSessionProxy->SetLaunchAbility(ability);
737     EXPECT_EQ(ret, AVSESSION_SUCCESS);
738 
739     sessionService->OnStop();
740     sessionInner = nullptr;
741     sessionService = nullptr;
742 
743     aVSessionProxy = nullptr;
744 
745     SLOGI("SetLaunchAbility001, end");
746 }
747 
748 /**
749  * @tc.name: GetExtras001
750  * @tc.desc: Test GetExtras
751  * @tc.type: FUNC
752  */
753 static HWTEST_F(AVSessionProxyTest, GetExtras001, testing::ext::TestSize.Level1)
754 {
755     SLOGI("GetExtras001, start");
756 
757     int32_t ret = AVSESSION_ERROR;
758 
759     int32_t systemAbilityId = 1;
760     bool runOnCreate = true;
761     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
762     sessionService->OnStart();
763 
764     sptr<IRemoteObject> sessionInner;
765     std::string tag = "tag";
766     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
767     std::string deviceId = "deviceId";
768     std::string bundleName = "bundleName";
769     std::string abilityName = "abilityName";
770     std::string moduleName = "moduleName";
771     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
772     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
773     EXPECT_TRUE(sessionInner != nullptr);
774     EXPECT_EQ(ret, AVSESSION_SUCCESS);
775 
776     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
777     OHOS::AAFwk::WantParams extras;
778     ret = aVSessionProxy->GetExtras(extras);
779     EXPECT_EQ(ret, AVSESSION_SUCCESS);
780 
781     sessionService->OnStop();
782     sessionInner = nullptr;
783     sessionService = nullptr;
784     aVSessionProxy = nullptr;
785 
786     SLOGI("GetExtras001, end");
787 }
788 
789 /**
790  * @tc.name: SetExtras001
791  * @tc.desc: Test SetExtras
792  * @tc.type: FUNC
793  */
794 static HWTEST_F(AVSessionProxyTest, SetExtras001, testing::ext::TestSize.Level1)
795 {
796     SLOGI("SetExtras001, start");
797 
798     int32_t ret = AVSESSION_ERROR;
799 
800     int32_t systemAbilityId = 1;
801     bool runOnCreate = true;
802     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
803     sessionService->OnStart();
804 
805     sptr<IRemoteObject> sessionInner;
806     std::string tag = "tag";
807     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
808     std::string deviceId = "deviceId";
809     std::string bundleName = "bundleName";
810     std::string abilityName = "abilityName";
811     std::string moduleName = "moduleName";
812     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
813     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
814     EXPECT_TRUE(sessionInner != nullptr);
815     EXPECT_EQ(ret, AVSESSION_SUCCESS);
816 
817     sptr<AVSessionProxy> aVSessionProxy = new AVSessionProxy(sessionInner);
818     OHOS::AAFwk::WantParams extras;
819     ret = aVSessionProxy->SetExtras(extras);
820     EXPECT_EQ(ret, AVSESSION_SUCCESS);
821 
822     sessionService->OnStop();
823     sessionInner = nullptr;
824     sessionService = nullptr;
825     aVSessionProxy = nullptr;
826 
827     SLOGI("SetExtras001, end");
828 }
829 
830 /**
831  * @tc.name: Activate001
832  * @tc.desc: Test Activate
833  * @tc.type: FUNC
834  */
835 static HWTEST_F(AVSessionProxyTest, Activate001, testing::ext::TestSize.Level1)
836 {
837     SLOGI("Activate001, start");
838 
839     int32_t ret = AVSESSION_ERROR;
840 
841     int32_t systemAbilityId = 1;
842     bool runOnCreate = true;
843 
844     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
845     sessionService->OnStart();
846 
847     sptr<IRemoteObject> sessionInner;
848     std::string tag = "tag";
849     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
850     std::string deviceId = "deviceId";
851     std::string bundleName = "bundleName";
852     std::string abilityName = "abilityName";
853     std::string moduleName = "moduleName";
854     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
855     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
856     EXPECT_TRUE(sessionInner != nullptr);
857     EXPECT_EQ(ret, AVSESSION_SUCCESS);
858     sptr<AVSessionProxy> avSessionProxy = new AVSessionProxy(sessionInner);
859 
860     ret = avSessionProxy->Activate();
861     EXPECT_EQ(ret, AVSESSION_SUCCESS);
862 
863     sessionService->OnStop();
864     sessionInner = nullptr;
865     sessionService = nullptr;
866     avSessionProxy = nullptr;
867 
868     SLOGI("Activate001, end");
869 }
870 
871 /**
872  * @tc.name: Deactivate001
873  * @tc.desc: Test Deactivate
874  * @tc.type: FUNC
875  */
876 static HWTEST_F(AVSessionProxyTest, Deactivate001, testing::ext::TestSize.Level1)
877 {
878     SLOGI("Deactivate001, start");
879 
880     int32_t ret = AVSESSION_ERROR;
881     bool retBool = false;
882 
883     int32_t systemAbilityId = 1;
884     bool runOnCreate = true;
885     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
886     sessionService->OnStart();
887 
888     sptr<IRemoteObject> sessionInner;
889     std::string tag = "tag";
890     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
891     std::string deviceId = "deviceId";
892     std::string bundleName = "bundleName";
893     std::string abilityName = "abilityName";
894 
895     std::string moduleName = "moduleName";
896     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
897     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
898     EXPECT_TRUE(sessionInner != nullptr);
899     EXPECT_EQ(ret, AVSESSION_SUCCESS);
900     sptr<AVSessionProxy> avSessionProxy = new AVSessionProxy(sessionInner);
901 
902     ret = avSessionProxy->Activate();
903     EXPECT_EQ(ret, AVSESSION_SUCCESS);
904     retBool = avSessionProxy->IsActive();
905     EXPECT_EQ(retBool, true);
906     ret = avSessionProxy->Deactivate();
907     EXPECT_EQ(ret, AVSESSION_SUCCESS);
908     retBool = avSessionProxy->IsActive();
909     EXPECT_EQ(retBool, false);
910 
911     sessionService->OnStop();
912     sessionInner = nullptr;
913     sessionService = nullptr;
914     avSessionProxy = nullptr;
915 
916     SLOGI("Deactivate001, end");
917 }
918 
919 /**
920  * @tc.name: SetSessionEvent001
921  * @tc.desc: Test SetSessionEvent
922  * @tc.type: FUNC
923  */
924 static HWTEST_F(AVSessionProxyTest, SetSessionEvent001, testing::ext::TestSize.Level1)
925 {
926     SLOGI("SetSessionEvent001, start");
927 
928     int32_t ret = AVSESSION_ERROR;
929 
930     int32_t systemAbilityId = 1;
931     bool runOnCreate = true;
932     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
933     sessionService->OnStart();
934 
935     sptr<IRemoteObject> sessionInner;
936     std::string tag = "tag";
937     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_AUDIO;
938     std::string deviceId = "deviceId";
939     std::string bundleName = "bundleName";
940     std::string abilityName = "abilityName";
941     std::string moduleName = "moduleName";
942     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
943     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
944     EXPECT_TRUE(sessionInner != nullptr);
945 
946     EXPECT_EQ(ret, AVSESSION_SUCCESS);
947 
948     sptr<AVSessionProxy> avSessionProxy = new AVSessionProxy(sessionInner);
949     std::string event = "AVSessionCallback";
950     OHOS::AAFwk::WantParams args;
951     ret = avSessionProxy->SetSessionEvent(event, args);
952     EXPECT_EQ(ret, AVSESSION_SUCCESS);
953 
954     sessionService->OnStop();
955     sessionInner = nullptr;
956     sessionService = nullptr;
957     avSessionProxy = nullptr;
958 
959     SLOGI("SetSessionEvent001, end");
960 }
961 
962 /**
963  * @tc.name: AddSupportCommand001
964  * @tc.desc: Test AddSupportCommand
965  * @tc.type: FUNC
966  */
967 static HWTEST_F(AVSessionProxyTest, AddSupportCommand001, testing::ext::TestSize.Level1)
968 {
969     SLOGI("AddSupportCommand001, start");
970 
971     int32_t ret = AVSESSION_ERROR;
972 
973     int32_t systemAbilityId = 1;
974     bool runOnCreate = true;
975     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
976     sessionService->OnStart();
977 
978     sptr<IRemoteObject> sessionInner;
979     std::string tag = "tag";
980     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_AUDIO;
981     std::string deviceId = "deviceId";
982     std::string bundleName = "bundleName";
983     std::string abilityName = "abilityName";
984     std::string moduleName = "moduleName";
985     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
986     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
987     EXPECT_TRUE(sessionInner != nullptr);
988     EXPECT_EQ(ret, AVSESSION_SUCCESS);
989     sptr<AVSessionProxy> avSessionProxy = new AVSessionProxy(sessionInner);
990 
991     int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
992     ret = avSessionProxy->AddSupportCommand(cmd);
993     EXPECT_EQ(ret, AVSESSION_SUCCESS);
994 
995     sessionService->OnStop();
996 
997     sessionInner = nullptr;
998     sessionService = nullptr;
999     avSessionProxy = nullptr;
1000 
1001     SLOGI("AddSupportCommand001, end");
1002 }
1003 
1004 /**
1005  * @tc.name: DeleteSupportCommand001
1006  * @tc.desc: Test DeleteSupportCommand
1007  * @tc.type: FUNC
1008  */
1009 static HWTEST_F(AVSessionProxyTest, DeleteSupportCommand001, testing::ext::TestSize.Level1)
1010 {
1011     SLOGI("DeleteSupportCommand001, start");
1012 
1013     int32_t ret = AVSESSION_ERROR;
1014 
1015     int32_t systemAbilityId = 1;
1016     bool runOnCreate = true;
1017     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
1018     sessionService->OnStart();
1019 
1020     sptr<IRemoteObject> sessionInner;
1021     std::string tag = "tag";
1022     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_AUDIO;
1023     std::string deviceId = "deviceId";
1024     std::string bundleName = "bundleName";
1025     std::string abilityName = "abilityName";
1026     std::string moduleName = "moduleName";
1027     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
1028     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
1029     EXPECT_TRUE(sessionInner != nullptr);
1030     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1031     sptr<AVSessionProxy> avSessionProxy = new AVSessionProxy(sessionInner);
1032 
1033     int32_t cmd = AVControlCommand::SESSION_CMD_PLAY;
1034     ret = avSessionProxy->AddSupportCommand(cmd);
1035     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1036     ret = avSessionProxy->DeleteSupportCommand(cmd);
1037     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1038 
1039     sessionService->OnStop();
1040     sessionService = nullptr;
1041     avSessionProxy = nullptr;
1042 
1043     SLOGI("DeleteSupportCommand001, end");
1044 }
1045 
1046 /**
1047 
1048  * @tc.name: GetController001
1049  * @tc.desc: Test GetController
1050  * @tc.type: FUNC
1051  */
1052 static HWTEST_F(AVSessionProxyTest, GetController001, testing::ext::TestSize.Level1)
1053 {
1054     SLOGI("GetController001, start");
1055 
1056     int32_t ret = AVSESSION_ERROR;
1057 
1058     int32_t systemAbilityId = 1;
1059     bool runOnCreate = true;
1060     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
1061     sessionService->OnStart();
1062 
1063     sptr<IRemoteObject> sessionInner;
1064     std::string tag = "tag";
1065     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
1066     std::string deviceId = "deviceId";
1067     std::string bundleName = "bundleName";
1068     std::string abilityName = "abilityName";
1069     std::string moduleName = "moduleName";
1070     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
1071     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
1072     EXPECT_TRUE(sessionInner != nullptr);
1073     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1074 
1075     sptr<AVSessionProxy> avSessionProxy = iface_cast<AVSessionProxy>(sessionInner);
1076     std::string sessionId = avSessionProxy->GetSessionId();
1077     sptr<IRemoteObject> controllerInner;
1078     ret = sessionService->CreateControllerInner(sessionId, controllerInner);
1079     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1080     EXPECT_TRUE(controllerInner != nullptr);
1081 
1082     std::shared_ptr<AVSessionController> avSessionController = avSessionProxy->GetController();
1083 
1084     sessionService->HandleSessionRelease(sessionId);
1085     sessionService->OnStop();
1086     sessionInner = nullptr;
1087     avSessionProxy = nullptr;
1088     controllerInner = nullptr;
1089     sessionService = nullptr;
1090 
1091     SLOGI("GetController001, end");
1092 }
1093 
1094 /**
1095  * @tc.name: RegisterCallback001
1096  * @tc.desc: Test RegisterCallback
1097  * @tc.type: FUNC
1098  */
1099 static HWTEST_F(AVSessionProxyTest, RegisterCallback001, testing::ext::TestSize.Level1)
1100 {
1101     SLOGI("RegisterCallback001, start");
1102 
1103     int32_t ret = AVSESSION_ERROR;
1104 
1105     int32_t systemAbilityId = 1;
1106     bool runOnCreate = true;
1107     sptr<AVSessionService> sessionService = new AVSessionService(systemAbilityId, runOnCreate);
1108     sessionService->OnStart();
1109 
1110     sptr<IRemoteObject> sessionInner;
1111     std::string tag = "tag";
1112     int32_t type = OHOS::AVSession::AVSession::SESSION_TYPE_VOICE_CALL;
1113     std::string deviceId = "deviceId";
1114     std::string bundleName = "bundleName";
1115     std::string abilityName = "abilityName";
1116     std::string moduleName = "moduleName";
1117     AppExecFwk::ElementName elementName(deviceId, bundleName, abilityName, moduleName);
1118     ret = sessionService->CreateSessionInner(tag, type, elementName, sessionInner);
1119     EXPECT_TRUE(sessionInner != nullptr);
1120     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1121     sptr<AVSessionProxy> avSessionProxy = iface_cast<AVSessionProxy>(sessionInner);
1122 
1123     std::shared_ptr<AVSessionCallback> avSessionCallbackImpl = std::make_shared<AVSessionCallbackImpl>();
1124     ret = avSessionProxy->RegisterCallback(avSessionCallbackImpl);
1125     EXPECT_EQ(ret, AVSESSION_SUCCESS);
1126 
1127     std::string sessionId = avSessionProxy->GetSessionId();
1128     sessionService->HandleSessionRelease(sessionId);
1129     sessionService->OnStop();
1130     sessionService = nullptr;
1131     avSessionProxy = nullptr;
1132     avSessionCallbackImpl = nullptr;
1133 
1134     SLOGI("RegisterCallback001, end");
1135 }