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
18 #include "avsession_callback_client.h"
19 #include "avsession_errors.h"
20 #include "avsession_log.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AVSession {
26
27 namespace {
28 std::string g_errLog;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)29 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
30 const char *msg)
31 {
32 g_errLog = msg;
33 }
34 } // namespace
35
36 class AVSessionCallbackImpl : public AVSessionCallback {
37 public:
OnPlay()38 void OnPlay() override {};
OnPause()39 void OnPause() override {};
OnStop()40 void OnStop() override {};
OnPlayNext()41 void OnPlayNext() override {};
OnPlayPrevious()42 void OnPlayPrevious() override {};
OnFastForward(int64_t time)43 void OnFastForward(int64_t time) override {};
OnRewind(int64_t time)44 void OnRewind(int64_t time) override {};
OnSeek(int64_t time)45 void OnSeek(int64_t time) override {};
OnSetSpeed(double speed)46 void OnSetSpeed(double speed) override {};
OnSetLoopMode(int32_t loopMode)47 void OnSetLoopMode(int32_t loopMode) override {};
OnSetTargetLoopMode(int32_t targetLoopMode)48 void OnSetTargetLoopMode(int32_t targetLoopMode) override {};
OnToggleFavorite(const std::string & mediaId)49 void OnToggleFavorite(const std::string& mediaId) override {};
OnMediaKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)50 void OnMediaKeyEvent(const OHOS::MMI::KeyEvent& keyEvent) override {};
OnOutputDeviceChange(const int32_t connectionState,const OutputDeviceInfo & outputDeviceInfo)51 void OnOutputDeviceChange(const int32_t connectionState, const OutputDeviceInfo& outputDeviceInfo) override {};
OnCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)52 void OnCommonCommand(const std::string& commonCommand, const OHOS::AAFwk::WantParams& commandArgs) override {};
OnSkipToQueueItem(int32_t itemId)53 void OnSkipToQueueItem(int32_t itemId) override {};
OnAVCallAnswer()54 void OnAVCallAnswer() override {};
OnAVCallHangUp()55 void OnAVCallHangUp() override {};
OnAVCallToggleCallMute()56 void OnAVCallToggleCallMute() override {};
OnPlayFromAssetId(int64_t assetId)57 void OnPlayFromAssetId(int64_t assetId) override {};
OnPlayWithAssetId(const std::string & assetId)58 void OnPlayWithAssetId(const std::string& assetId) override {};
OnCastDisplayChange(const CastDisplayInfo & castDisplayInfo)59 void OnCastDisplayChange(const CastDisplayInfo& castDisplayInfo) override {};
OnCustomData(const OHOS::AAFwk::WantParams & data)60 void OnCustomData(const OHOS::AAFwk::WantParams& data) override {};
61
~AVSessionCallbackImpl()62 ~AVSessionCallbackImpl() override {};
63 };
64
65 class AVSessionCallbackClientTest : public testing::Test {
66 public:
67 static void SetUpTestCase();
68 static void TearDownTestCase();
69 void SetUp() override;
70 void TearDown() override;
71 };
72
SetUpTestCase()73 void AVSessionCallbackClientTest::SetUpTestCase()
74 {}
75
TearDownTestCase()76 void AVSessionCallbackClientTest::TearDownTestCase()
77 {}
78
SetUp()79 void AVSessionCallbackClientTest::SetUp()
80 {}
81
TearDown()82 void AVSessionCallbackClientTest::TearDown()
83 {}
84
85 /**
86 * @tc.name: OnAVCallAnswer001
87 * @tc.desc: test OnAVCallAnswer
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 HWTEST_F(AVSessionCallbackClientTest, OnAVCallAnswer001, TestSize.Level1)
92 {
93 LOG_SetCallback(MyLogCallback);
94 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
95 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
96 std::make_shared<AVSessionCallbackClient>(sessionCallback);
97 EXPECT_NE(sessionCallbackClient, nullptr);
98 ErrCode ret = sessionCallbackClient->OnAVCallAnswer();
99 EXPECT_EQ(ret, AVSESSION_SUCCESS);
100 }
101
102 /**
103 * @tc.name: OnAVCallHangUp001
104 * @tc.desc: test OnAVCallHangUp
105 * @tc.type: FUNC
106 * @tc.require:
107 */
108 HWTEST_F(AVSessionCallbackClientTest, OnAVCallHangUp001, TestSize.Level1)
109 {
110 LOG_SetCallback(MyLogCallback);
111 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
112 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
113 std::make_shared<AVSessionCallbackClient>(sessionCallback);
114 EXPECT_NE(sessionCallbackClient, nullptr);
115 ErrCode ret = sessionCallbackClient->OnAVCallHangUp();
116 EXPECT_EQ(ret, AVSESSION_SUCCESS);
117 }
118
119 /**
120 * @tc.name: OnAVCallToggleCallMute001
121 * @tc.desc: test OnAVCallToggleCallMute
122 * @tc.type: FUNC
123 * @tc.require:
124 */
125 HWTEST_F(AVSessionCallbackClientTest, OnAVCallToggleCallMute001, TestSize.Level0)
126 {
127 LOG_SetCallback(MyLogCallback);
128 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
129 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
130 std::make_shared<AVSessionCallbackClient>(sessionCallback);
131 EXPECT_NE(sessionCallbackClient, nullptr);
132 ErrCode ret = sessionCallbackClient->OnAVCallToggleCallMute();
133 EXPECT_EQ(ret, AVSESSION_SUCCESS);
134 }
135
136 /**
137 * @tc.name: OnPlay001
138 * @tc.desc: test OnPlay
139 * @tc.type: FUNC
140 * @tc.require:
141 */
142 HWTEST_F(AVSessionCallbackClientTest, OnPlay001, TestSize.Level0)
143 {
144 LOG_SetCallback(MyLogCallback);
145 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
146 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
147 std::make_shared<AVSessionCallbackClient>(sessionCallback);
148 EXPECT_NE(sessionCallbackClient, nullptr);
149 ErrCode ret = sessionCallbackClient->OnPlay();
150 EXPECT_EQ(ret, AVSESSION_SUCCESS);
151 }
152
153 /**
154 * @tc.name: OnPause001
155 * @tc.desc: test OnPause
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 HWTEST_F(AVSessionCallbackClientTest, OnPause001, TestSize.Level0)
160 {
161 LOG_SetCallback(MyLogCallback);
162 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
163 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
164 std::make_shared<AVSessionCallbackClient>(sessionCallback);
165 EXPECT_NE(sessionCallbackClient, nullptr);
166 ErrCode ret = sessionCallbackClient->OnPause();
167 EXPECT_EQ(ret, AVSESSION_SUCCESS);
168 }
169
170 /**
171 * @tc.name: OnStop001
172 * @tc.desc: test OnStop
173 * @tc.type: FUNC
174 * @tc.require:
175 */
176 HWTEST_F(AVSessionCallbackClientTest, OnStop001, TestSize.Level0)
177 {
178 LOG_SetCallback(MyLogCallback);
179 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
180 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
181 std::make_shared<AVSessionCallbackClient>(sessionCallback);
182 EXPECT_NE(sessionCallbackClient, nullptr);
183 ErrCode ret = sessionCallbackClient->OnStop();
184 EXPECT_EQ(ret, AVSESSION_SUCCESS);
185 }
186
187 /**
188 * @tc.name: OnPlayNext001
189 * @tc.desc: test OnPlayNext
190 * @tc.type: FUNC
191 * @tc.require:
192 */
193 HWTEST_F(AVSessionCallbackClientTest, OnPlayNext001, TestSize.Level0)
194 {
195 LOG_SetCallback(MyLogCallback);
196 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
197 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
198 std::make_shared<AVSessionCallbackClient>(sessionCallback);
199 EXPECT_NE(sessionCallbackClient, nullptr);
200 ErrCode ret = sessionCallbackClient->OnPlayNext();
201 EXPECT_EQ(ret, AVSESSION_SUCCESS);
202 }
203
204 /**
205 * @tc.name: OnPlayPrevious001
206 * @tc.desc: test OnPlayPrevious
207 * @tc.type: FUNC
208 * @tc.require:
209 */
210 HWTEST_F(AVSessionCallbackClientTest, OnPlayPrevious001, TestSize.Level0)
211 {
212 LOG_SetCallback(MyLogCallback);
213 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
214 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
215 std::make_shared<AVSessionCallbackClient>(sessionCallback);
216 EXPECT_NE(sessionCallbackClient, nullptr);
217 ErrCode ret = sessionCallbackClient->OnPlayPrevious();
218 EXPECT_EQ(ret, AVSESSION_SUCCESS);
219 }
220
221 /**
222 * @tc.name: OnFastForward001
223 * @tc.desc: test OnFastForward
224 * @tc.type: FUNC
225 * @tc.require:
226 */
227 HWTEST_F(AVSessionCallbackClientTest, OnFastForward001, TestSize.Level0)
228 {
229 LOG_SetCallback(MyLogCallback);
230 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
231 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
232 std::make_shared<AVSessionCallbackClient>(sessionCallback);
233 EXPECT_NE(sessionCallbackClient, nullptr);
234 int64_t time = 100;
235 ErrCode ret = sessionCallbackClient->OnFastForward(time);
236 EXPECT_EQ(ret, AVSESSION_SUCCESS);
237 }
238
239 /**
240 * @tc.name: OnRewind001
241 * @tc.desc: test OnRewind
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(AVSessionCallbackClientTest, OnRewind001, TestSize.Level0)
246 {
247 LOG_SetCallback(MyLogCallback);
248 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
249 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
250 std::make_shared<AVSessionCallbackClient>(sessionCallback);
251 EXPECT_NE(sessionCallbackClient, nullptr);
252 int64_t time = 100;
253 ErrCode ret = sessionCallbackClient->OnRewind(time);
254 EXPECT_EQ(ret, AVSESSION_SUCCESS);
255 }
256
257 /**
258 * @tc.name: OnSeek001
259 * @tc.desc: test OnSeek
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 HWTEST_F(AVSessionCallbackClientTest, OnSeek001, TestSize.Level0)
264 {
265 LOG_SetCallback(MyLogCallback);
266 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
267 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
268 std::make_shared<AVSessionCallbackClient>(sessionCallback);
269 EXPECT_NE(sessionCallbackClient, nullptr);
270 int64_t time = 100;
271 ErrCode ret = sessionCallbackClient->OnSeek(time);
272 EXPECT_EQ(ret, AVSESSION_SUCCESS);
273 }
274
275 /**
276 * @tc.name: OnSetSpeed001
277 * @tc.desc: test OnSetSpeed
278 * @tc.type: FUNC
279 * @tc.require:
280 */
281 HWTEST_F(AVSessionCallbackClientTest, OnSetSpeed001, TestSize.Level0)
282 {
283 LOG_SetCallback(MyLogCallback);
284 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
285 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
286 std::make_shared<AVSessionCallbackClient>(sessionCallback);
287 EXPECT_NE(sessionCallbackClient, nullptr);
288 double speed = 100;
289 ErrCode ret = sessionCallbackClient->OnSetSpeed(speed);
290 EXPECT_EQ(ret, AVSESSION_SUCCESS);
291 }
292
293 /**
294 * @tc.name: OnSetLoopMode001
295 * @tc.desc: test OnSetLoopMode
296 * @tc.type: FUNC
297 * @tc.require:
298 */
299 HWTEST_F(AVSessionCallbackClientTest, OnSetLoopMode001, TestSize.Level0)
300 {
301 LOG_SetCallback(MyLogCallback);
302 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
303 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
304 std::make_shared<AVSessionCallbackClient>(sessionCallback);
305 EXPECT_NE(sessionCallbackClient, nullptr);
306 int32_t loopMode = 100;
307 ErrCode ret = sessionCallbackClient->OnSetLoopMode(loopMode);
308 EXPECT_EQ(ret, AVSESSION_SUCCESS);
309 }
310
311 /**
312 * @tc.name: OnSetTargetLoopMode001
313 * @tc.desc: test OnSetTargetLoopMode
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317 HWTEST_F(AVSessionCallbackClientTest, OnSetTargetLoopMode001, TestSize.Level0)
318 {
319 LOG_SetCallback(MyLogCallback);
320 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
321 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
322 std::make_shared<AVSessionCallbackClient>(sessionCallback);
323 EXPECT_NE(sessionCallbackClient, nullptr);
324 int32_t targetLoopMode = 100;
325 ErrCode ret = sessionCallbackClient->OnSetTargetLoopMode(targetLoopMode);
326 EXPECT_EQ(ret, AVSESSION_SUCCESS);
327 }
328
329 /**
330 * @tc.name: OnToggleFavorite001
331 * @tc.desc: test OnToggleFavorite
332 * @tc.type: FUNC
333 * @tc.require:
334 */
335 HWTEST_F(AVSessionCallbackClientTest, OnToggleFavorite001, TestSize.Level0)
336 {
337 LOG_SetCallback(MyLogCallback);
338 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
339 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
340 std::make_shared<AVSessionCallbackClient>(sessionCallback);
341 EXPECT_NE(sessionCallbackClient, nullptr);
342 const std::string& mediaId = "123";
343 ErrCode ret = sessionCallbackClient->OnToggleFavorite(mediaId);
344 EXPECT_EQ(ret, AVSESSION_SUCCESS);
345 }
346
347 /**
348 * @tc.name: OnMediaKeyEvent001
349 * @tc.desc: test OnMediaKeyEvent
350 * @tc.type: FUNC
351 * @tc.require:
352 */
353 HWTEST_F(AVSessionCallbackClientTest, OnMediaKeyEvent001, TestSize.Level1)
354 {
355 LOG_SetCallback(MyLogCallback);
356 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
357 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
358 std::make_shared<AVSessionCallbackClient>(sessionCallback);
359 EXPECT_NE(sessionCallbackClient, nullptr);
360 auto keyEvent = OHOS::MMI::KeyEvent::Create();
361 ErrCode ret = sessionCallbackClient->OnMediaKeyEvent(*(keyEvent.get()));
362 EXPECT_EQ(ret, AVSESSION_SUCCESS);
363 }
364
365 /**
366 * @tc.name: OnOutputDeviceChange001
367 * @tc.desc: test OnOutputDeviceChange
368 * @tc.type: FUNC
369 * @tc.require:
370 */
371 HWTEST_F(AVSessionCallbackClientTest, OnOutputDeviceChange001, TestSize.Level1)
372 {
373 LOG_SetCallback(MyLogCallback);
374 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
375 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
376 std::make_shared<AVSessionCallbackClient>(sessionCallback);
377 EXPECT_NE(sessionCallbackClient, nullptr);
378 const int32_t connectionState = 1;
379 const OutputDeviceInfo& outputDeviceInfo = OutputDeviceInfo();
380 ErrCode ret = sessionCallbackClient->OnOutputDeviceChange(connectionState, outputDeviceInfo);
381 EXPECT_EQ(ret, AVSESSION_SUCCESS);
382 }
383
384 /**
385 * @tc.name: OnCommonCommand001
386 * @tc.desc: test OnCommonCommand
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 HWTEST_F(AVSessionCallbackClientTest, OnCommonCommand001, TestSize.Level1)
391 {
392 LOG_SetCallback(MyLogCallback);
393 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
394 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
395 std::make_shared<AVSessionCallbackClient>(sessionCallback);
396 EXPECT_NE(sessionCallbackClient, nullptr);
397 const std::string& commonCommand = "test";
398 const AAFwk::WantParams& commandArgs = AAFwk::WantParams();
399 ErrCode ret = sessionCallbackClient->OnCommonCommand(commonCommand, commandArgs);
400 EXPECT_EQ(ret, AVSESSION_SUCCESS);
401 }
402
403 /**
404 * @tc.name: OnSkipToQueueItem001
405 * @tc.desc: test OnSkipToQueueItem
406 * @tc.type: FUNC
407 * @tc.require:
408 */
409 HWTEST_F(AVSessionCallbackClientTest, OnSkipToQueueItem001, TestSize.Level1)
410 {
411 LOG_SetCallback(MyLogCallback);
412 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
413 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
414 std::make_shared<AVSessionCallbackClient>(sessionCallback);
415 EXPECT_NE(sessionCallbackClient, nullptr);
416 int32_t itemId = 10;
417 ErrCode ret = sessionCallbackClient->OnSkipToQueueItem(itemId);
418 EXPECT_EQ(ret, AVSESSION_SUCCESS);
419 }
420
421 /**
422 * @tc.name: OnPlayFromAssetId001
423 * @tc.desc: test OnPlayFromAssetId
424 * @tc.type: FUNC
425 * @tc.require:
426 */
427 HWTEST_F(AVSessionCallbackClientTest, OnPlayFromAssetId001, TestSize.Level1)
428 {
429 LOG_SetCallback(MyLogCallback);
430 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
431 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
432 std::make_shared<AVSessionCallbackClient>(sessionCallback);
433 EXPECT_NE(sessionCallbackClient, nullptr);
434 int64_t assetId = 10;
435 ErrCode ret = sessionCallbackClient->OnPlayFromAssetId(assetId);
436 EXPECT_EQ(ret, AVSESSION_SUCCESS);
437 }
438
439 /**
440 * @tc.name: OnPlayWithAssetId001
441 * @tc.desc: test OnPlayWithAssetId
442 * @tc.type: FUNC
443 * @tc.require:
444 */
445 HWTEST_F(AVSessionCallbackClientTest, OnPlayWithAssetId001, TestSize.Level1)
446 {
447 LOG_SetCallback(MyLogCallback);
448 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
449 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
450 std::make_shared<AVSessionCallbackClient>(sessionCallback);
451 EXPECT_NE(sessionCallbackClient, nullptr);
452 const std::string& assetId = "123";
453 ErrCode ret = sessionCallbackClient->OnPlayWithAssetId(assetId);
454 EXPECT_EQ(ret, AVSESSION_SUCCESS);
455 }
456
457 /**
458 * @tc.name: OnCastDisplayChange001
459 * @tc.desc: test OnCastDisplayChange
460 * @tc.type: FUNC
461 * @tc.require:
462 */
463 HWTEST_F(AVSessionCallbackClientTest, OnCastDisplayChange001, TestSize.Level1)
464 {
465 LOG_SetCallback(MyLogCallback);
466 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
467 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
468 std::make_shared<AVSessionCallbackClient>(sessionCallback);
469 EXPECT_NE(sessionCallbackClient, nullptr);
470 const CastDisplayInfo& castDisplayInfo = CastDisplayInfo();
471 ErrCode ret = sessionCallbackClient->OnCastDisplayChange(castDisplayInfo);
472 EXPECT_EQ(ret, AVSESSION_SUCCESS);
473 }
474
475 /**
476 * @tc.name: OnCustomData001
477 * @tc.desc: test OnCustomData
478 * @tc.type: FUNC
479 * @tc.require:
480 */
481 HWTEST_F(AVSessionCallbackClientTest, OnCustomData001, TestSize.Level0)
482 {
483 LOG_SetCallback(MyLogCallback);
484 std::shared_ptr<AVSessionCallback> sessionCallback = std::make_shared<AVSessionCallbackImpl>();
485 std::shared_ptr<AVSessionCallbackClient> sessionCallbackClient =
486 std::make_shared<AVSessionCallbackClient>(sessionCallback);
487 EXPECT_NE(sessionCallbackClient, nullptr);
488 OHOS::AAFwk::WantParams extras;
489 ErrCode ret = sessionCallbackClient->OnCustomData(extras);
490 EXPECT_EQ(ret, AVSESSION_SUCCESS);
491 }
492 } // namespace AVSession
493 } // namespace OHOS