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 "native_avsession.h"
18 #include "OHAVSession.h"
19 #include "OHAVSessionCallbackImpl.h"
20 #include "avsession_log.h"
21 #include "avsession_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS::AVSession {
26 static OHAVSessionCallbackImpl g_ohAVSessionCallbackImpl;
27
28 class OHAVSessionCallbackImplTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase(void)36 void OHAVSessionCallbackImplTest::SetUpTestCase(void)
37 {
38 }
39
TearDownTestCase(void)40 void OHAVSessionCallbackImplTest::TearDownTestCase(void)
41 {
42 }
43
SetUp()44 void OHAVSessionCallbackImplTest::SetUp()
45 {
46 }
47
TearDown()48 void OHAVSessionCallbackImplTest::TearDown()
49 {
50 }
51
52 /**
53 * @tc.name: UnSetPlayCallback001
54 * @tc.desc: test UnSetPlayCallback
55 * @tc.type: FUNC
56 * @tc.require: AR000H31JO
57 */
58 HWTEST_F(OHAVSessionCallbackImplTest, UnSetPlayCallback001, TestSize.Level0)
59 {
60 SLOGI("UnSetPlayCallback001 Begin");
61 OH_AVSession* avsession = nullptr;
62 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
63 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
64 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970102(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 65 void* userData) -> AVSessionCallback_Result {
66 return AVSESSION_CALLBACK_RESULT_SUCCESS;
67 };
68 int userData = 1;
69 g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command, callback, (void *)(&userData));
70 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
71 avsession, command, callback);
72 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
73 ret = OH_AVSession_Destroy(avsession);
74 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
75 SLOGI("UnSetPlayCallback001 End");
76 }
77
78 /**
79 * @tc.name: SetPauseCallback001
80 * @tc.desc: test SetPauseCallback
81 * @tc.type: FUNC
82 * @tc.require: AR000H31JO
83 */
84 HWTEST_F(OHAVSessionCallbackImplTest, SetPauseCallback001, TestSize.Level0)
85 {
86 SLOGI("SetPauseCallback001 Begin");
87 OH_AVSession* avsession = nullptr;
88 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPauseCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
89 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
90 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970202(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 91 void* userData) -> AVSessionCallback_Result {
92 return AVSESSION_CALLBACK_RESULT_SUCCESS;
93 };
94 int userData = 1;
95 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPauseCallback(
96 avsession, command, callback, (void *)(&userData));
97 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
98 SLOGI("SetPauseCallback001 End");
99 }
100
101 /**
102 * @tc.name: SetPauseCallback002
103 * @tc.desc: test SetPauseCallback
104 * @tc.type: FUNC
105 * @tc.require: AR000H31JO
106 */
107 HWTEST_F(OHAVSessionCallbackImplTest, SetPauseCallback002, TestSize.Level0)
108 {
109 SLOGI("SetPauseCallback002 Begin");
110 OH_AVSession* avsession = nullptr;
111 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPauseCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
112 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
113 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970302(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 114 void* userData) -> AVSessionCallback_Result {
115 return AVSESSION_CALLBACK_RESULT_SUCCESS;
116 };
117 int userData = 1;
118 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPauseCallback(
119 avsession, command, callback, (void *)(&userData));
120 g_ohAVSessionCallbackImpl.SetPauseCallback(avsession, command, callback, (void *)(&userData));
121 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
122 SLOGI("SetPauseCallback002 End");
123 }
124
125 /**
126 * @tc.name: UnSetPauseCallback001
127 * @tc.desc: test UnSetPauseCallback
128 * @tc.type: FUNC
129 * @tc.require: AR000H31JO
130 */
131 HWTEST_F(OHAVSessionCallbackImplTest, UnSetPauseCallback001, TestSize.Level0)
132 {
133 SLOGI("UnSetPauseCallback001 Begin");
134 OH_AVSession* avsession = nullptr;
135 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPauseCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
136 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
137 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970402(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 138 void* userData) -> AVSessionCallback_Result {
139 return AVSESSION_CALLBACK_RESULT_SUCCESS;
140 };
141 int userData = 1;
142 g_ohAVSessionCallbackImpl.SetPauseCallback(avsession, command, callback, (void *)(&userData));
143 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPauseCallback(
144 avsession, command, callback);
145 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
146 SLOGI("UnSetPauseCallback001 End");
147 }
148
149 /**
150 * @tc.name: SetStopCallback001
151 * @tc.desc: test SetStopCallback
152 * @tc.type: FUNC
153 * @tc.require: AR000H31JO
154 */
155 HWTEST_F(OHAVSessionCallbackImplTest, SetStopCallback001, TestSize.Level0)
156 {
157 SLOGI("SetStopCallback001 Begin");
158 OH_AVSession* avsession = nullptr;
159 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetStopCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
160 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
161 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970502(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 162 void* userData) -> AVSessionCallback_Result {
163 return AVSESSION_CALLBACK_RESULT_SUCCESS;
164 };
165 int userData = 1;
166 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetStopCallback(
167 avsession, command, callback, (void *)(&userData));
168 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
169 SLOGI("SetStopCallback001 End");
170 }
171
172 /**
173 * @tc.name: SetStopCallback002
174 * @tc.desc: test SetStopCallback
175 * @tc.type: FUNC
176 * @tc.require: AR000H31JO
177 */
178 HWTEST_F(OHAVSessionCallbackImplTest, SetStopCallback002, TestSize.Level0)
179 {
180 SLOGI("SetStopCallback002 Begin");
181 OH_AVSession* avsession = nullptr;
182 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetStopCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
183 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
184 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970602(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 185 void* userData) -> AVSessionCallback_Result {
186 return AVSESSION_CALLBACK_RESULT_SUCCESS;
187 };
188 int userData = 1;
189 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetStopCallback(
190 avsession, command, callback, (void *)(&userData));
191 g_ohAVSessionCallbackImpl.SetStopCallback(avsession, command, callback, (void *)(&userData));
192 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
193 SLOGI("SetStopCallback002 End");
194 }
195
196 /**
197 * @tc.name: SetPlayNextCallback001
198 * @tc.desc: test SetPlayNextCallback
199 * @tc.type: FUNC
200 * @tc.require: AR000H31JO
201 */
202 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayNextCallback001, TestSize.Level0)
203 {
204 SLOGI("SetPlayNextCallback001 Begin");
205 OH_AVSession* avsession = nullptr;
206 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayNextCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
207 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
208 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970702(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 209 void* userData) -> AVSessionCallback_Result {
210 return AVSESSION_CALLBACK_RESULT_SUCCESS;
211 };
212 int userData = 1;
213 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayNextCallback(
214 avsession, command, callback, (void *)(&userData));
215 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
216 SLOGI("SetPlayNextCallback001 End");
217 }
218
219 /**
220 * @tc.name: SetPlayNextCallback002
221 * @tc.desc: test SetPlayNextCallback
222 * @tc.type: FUNC
223 * @tc.require: AR000H31JO
224 */
225 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayNextCallback002, TestSize.Level0)
226 {
227 SLOGI("SetPlayNextCallback002 Begin");
228 OH_AVSession* avsession = nullptr;
229 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayNextCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
230 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
231 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970802(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 232 void* userData) -> AVSessionCallback_Result {
233 return AVSESSION_CALLBACK_RESULT_SUCCESS;
234 };
235 int userData = 1;
236 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayNextCallback(
237 avsession, command, callback, (void *)(&userData));
238 g_ohAVSessionCallbackImpl.SetPlayNextCallback(avsession, command, callback, (void *)(&userData));
239 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
240 SLOGI("SetPlayNextCallback002 End");
241 }
242
243 /**
244 * @tc.name: SetPlayPreviousCallback001
245 * @tc.desc: test SetPlayPreviousCallback
246 * @tc.type: FUNC
247 * @tc.require: AR000H31JO
248 */
249 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayPreviousCallback001, TestSize.Level0)
250 {
251 SLOGI("SetPlayPreviousCallback001 Begin");
252 OH_AVSession* avsession = nullptr;
253 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayPreviousCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
254 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
255 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970902(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 256 void* userData) -> AVSessionCallback_Result {
257 return AVSESSION_CALLBACK_RESULT_SUCCESS;
258 };
259 int userData = 1;
260 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(
261 avsession, command, callback, (void *)(&userData));
262 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
263 SLOGI("SetPlayPreviousCallback001 End");
264 }
265
266 /**
267 * @tc.name: SetPlayPreviousCallback002
268 * @tc.desc: test SetPlayPreviousCallback
269 * @tc.type: FUNC
270 * @tc.require: AR000H31JO
271 */
272 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayPreviousCallback002, TestSize.Level0)
273 {
274 SLOGI("SetPlayPreviousCallback002 Begin");
275 OH_AVSession* avsession = nullptr;
276 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayPreviousCallback002", "com.xxx.hmxx", "ndkxx", &avsession);
277 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
278 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970a02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 279 void* userData) -> AVSessionCallback_Result {
280 return AVSESSION_CALLBACK_RESULT_SUCCESS;
281 };
282 int userData = 1;
283 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(
284 avsession, command, callback, (void *)(&userData));
285 g_ohAVSessionCallbackImpl.SetPlayPreviousCallback(avsession, command, callback, (void *)(&userData));
286 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
287 SLOGI("SetPlayPreviousCallback002 End");
288 }
289
290 /**
291 * @tc.name: SetPlayCallback001
292 * @tc.desc: test SetPlayCallback
293 * @tc.type: FUNC
294 * @tc.require: AR000H31JO
295 */
296 HWTEST_F(OHAVSessionCallbackImplTest, SetPlayCallback001, TestSize.Level0)
297 {
298 SLOGI("SetPlayCallback001 Begin");
299 OH_AVSession* avsession = nullptr;
300 OH_AVSession_Create(SESSION_TYPE_AUDIO, "SetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
301 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
302 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5970b02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 303 void* userData) -> AVSessionCallback_Result {
304 return AVSESSION_CALLBACK_RESULT_SUCCESS;
305 };
306 int userData = 1;
307 g_ohAVSessionCallbackImpl.avsession_ = avsession;
308 g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command, callback, (void *)(&userData));
309 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
310 avsession, command, callback);
311 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
312 SLOGI("SetPlayCallback001 End");
313 }
314
315 /**
316 * @tc.name: RegisterForwardCallback001
317 * @tc.desc: test RegisterForwardCallback
318 * @tc.type: FUNC
319 * @tc.require: AR000H31JO
320 */
321 HWTEST_F(OHAVSessionCallbackImplTest, RegisterForwardCallback001, TestSize.Level0)
322 {
323 SLOGI("RegisterForwardCallback001 Begin");
324 OH_AVSession* avsession = nullptr;
325 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterForwardCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
326 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
__anon957ea5970c02(OH_AVSession* session, uint32_t seekTime, void* userData) 327 void* userData) -> AVSessionCallback_Result {
328 return AVSESSION_CALLBACK_RESULT_SUCCESS;
329 };
330 int userData = 1;
331 g_ohAVSessionCallbackImpl.avsession_ = avsession;
332 auto ret = g_ohAVSessionCallbackImpl.RegisterForwardCallback(avsession, callback, (void *)(&userData));
333 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
334 SLOGI("RegisterForwardCallback001 End");
335 }
336
337 /**
338 * @tc.name: RegisterSeekCallback001
339 * @tc.desc: test RegisterSeekCallback
340 * @tc.type: FUNC
341 * @tc.require: AR000H31JO
342 */
343 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSeekCallback001, TestSize.Level0)
344 {
345 SLOGI("RegisterSeekCallback001 Begin");
346 OH_AVSession* avsession = nullptr;
347 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterSeekCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
348 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
__anon957ea5970d02(OH_AVSession* session, uint64_t seekTime, void* userData) 349 void* userData) -> AVSessionCallback_Result {
350 return AVSESSION_CALLBACK_RESULT_SUCCESS;
351 };
352 int userData = 1;
353 g_ohAVSessionCallbackImpl.avsession_ = avsession;
354 auto ret = g_ohAVSessionCallbackImpl.RegisterSeekCallback(avsession, callback, (void *)(&userData));
355 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
356 SLOGI("RegisterSeekCallback001 End");
357 }
358
359 /**
360 * @tc.name: RegisterSetLoopModeCallback001
361 * @tc.desc: test RegisterSetLoopModeCallback
362 * @tc.type: FUNC
363 * @tc.require: AR000H31JO
364 */
365 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSetLoopModeCallback001, TestSize.Level0)
366 {
367 SLOGI("RegisterSetLoopModeCallback001 Begin");
368 OH_AVSession* avsession = nullptr;
369 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterSetLoopModeCallback", "com.xxx.hmxx", "ndkxx", &avsession);
370 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
__anon957ea5970e02(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 371 void* userData) -> AVSessionCallback_Result {
372 return AVSESSION_CALLBACK_RESULT_SUCCESS;
373 };
374 int userData = 1;
375 g_ohAVSessionCallbackImpl.avsession_ = avsession;
376 auto ret = g_ohAVSessionCallbackImpl.RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
377 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
378 SLOGI("RegisterSetLoopModeCallback001 End");
379 }
380
381 /**
382 * @tc.name: RegisterToggleFavoriteCallback001
383 * @tc.desc: test RegisterToggleFavoriteCallback
384 * @tc.type: FUNC
385 * @tc.require: AR000H31JO
386 */
387 HWTEST_F(OHAVSessionCallbackImplTest, RegisterToggleFavoriteCallback001, TestSize.Level0)
388 {
389 SLOGI("RegisterToggleFavoriteCallback001 Begin");
390 OH_AVSession* avsession = nullptr;
391 OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterToggleFavoriteCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
392 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
__anon957ea5970f02(OH_AVSession* session, const char* assetId, void* userData) 393 void* userData) -> AVSessionCallback_Result {
394 return AVSESSION_CALLBACK_RESULT_SUCCESS;
395 };
396 int userData = 1;
397 g_ohAVSessionCallbackImpl.avsession_ = avsession;
398 auto ret = g_ohAVSessionCallbackImpl.RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
399 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
400 SLOGI("RegisterToggleFavoriteCallback001 End");
401 }
402
403 /**
404 * @tc.name: RegisterForwardCallback002
405 * @tc.desc: have registered RegisterForwardCallback
406 * @tc.type: FUNC
407 * @tc.require: AR000H31JO
408 */
409 HWTEST_F(OHAVSessionCallbackImplTest, RegisterForwardCallback002, TestSize.Level0)
410 {
411 SLOGI("RegisterForwardCallback002 Begin");
412 auto avsession = std::make_shared<OHAVSession>();
413 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
414 EXPECT_TRUE(oh_avsession != nullptr);
415
416 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* oh_avsession, uint32_t seekTime,
__anon957ea5971002(OH_AVSession* oh_avsession, uint32_t seekTime, void* userData) 417 void* userData) -> AVSessionCallback_Result {
418 return AVSESSION_CALLBACK_RESULT_SUCCESS;
419 };
420 int userData = 1;
421 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
422 auto ret = g_ohAVSessionCallbackImpl.RegisterForwardCallback(oh_avsession, callback, (void *)(&userData));
423 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
424
425 auto it = std::find_if (g_ohAVSessionCallbackImpl.forwardCallbacks_.begin(),
426 g_ohAVSessionCallbackImpl.forwardCallbacks_.end(),
__anon957ea5971102(const std::pair<OH_AVSessionCallback_OnFastForward, void*> &element) 427 [callback](const std::pair<OH_AVSessionCallback_OnFastForward, void*> &element) {
428 return element.first == callback; });
429 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.forwardCallbacks_.end());
430 SLOGI("RegisterForwardCallback002 End");
431 }
432
433 /**
434 * @tc.name: RegisterRewindCallback002
435 * @tc.desc: have registered RegisterRewindCallback
436 * @tc.type: FUNC
437 * @tc.require: AR000H31JO
438 */
439 HWTEST_F(OHAVSessionCallbackImplTest, RegisterRewindCallback002, TestSize.Level0)
440 {
441 SLOGI("RegisterRewindCallback002 Begin");
442 auto avsession = std::make_shared<OHAVSession>();
443 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
444 EXPECT_TRUE(oh_avsession != nullptr);
445
446 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* oh_avsession, uint32_t seekTime,
__anon957ea5971202(OH_AVSession* oh_avsession, uint32_t seekTime, void* userData) 447 void* userData) -> AVSessionCallback_Result {
448 return AVSESSION_CALLBACK_RESULT_SUCCESS;
449 };
450 int userData = 1;
451 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
452 auto ret = g_ohAVSessionCallbackImpl.RegisterRewindCallback(oh_avsession, callback, (void *)(&userData));
453 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
454
455 auto it = std::find_if (g_ohAVSessionCallbackImpl.rewindCallbacks_.begin(),
456 g_ohAVSessionCallbackImpl.rewindCallbacks_.end(),
__anon957ea5971302(const std::pair<OH_AVSessionCallback_OnRewind, void*> &element) 457 [callback](const std::pair<OH_AVSessionCallback_OnRewind, void*> &element) {
458 return element.first == callback; });
459 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.rewindCallbacks_.end());
460 SLOGI("RegisterRewindCallback002 End");
461 }
462
463 /**
464 * @tc.name: RegisterSeekCallback002
465 * @tc.desc: have registered RegisterSeekCallback
466 * @tc.type: FUNC
467 * @tc.require: AR000H31JO
468 */
469 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSeekCallback002, TestSize.Level0)
470 {
471 SLOGI("RegisterSeekCallback002 Begin");
472 auto avsession = std::make_shared<OHAVSession>();
473 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
474 EXPECT_TRUE(oh_avsession != nullptr);
475
476 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* oh_avsession, uint64_t seekTime,
__anon957ea5971402(OH_AVSession* oh_avsession, uint64_t seekTime, void* userData) 477 void* userData) -> AVSessionCallback_Result {
478 return AVSESSION_CALLBACK_RESULT_SUCCESS;
479 };
480 int userData = 1;
481 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
482 auto ret = g_ohAVSessionCallbackImpl.RegisterSeekCallback(oh_avsession, callback, (void *)(&userData));
483 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
484
485 auto it = std::find_if (g_ohAVSessionCallbackImpl.seekCallbacks_.begin(),
486 g_ohAVSessionCallbackImpl.seekCallbacks_.end(),
__anon957ea5971502(const std::pair<OH_AVSessionCallback_OnSeek, void*> &element) 487 [callback](const std::pair<OH_AVSessionCallback_OnSeek, void*> &element) {
488 return element.first == callback; });
489 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.seekCallbacks_.end());
490 SLOGI("RegisterSeekCallback002 End");
491 }
492
493 /**
494 * @tc.name: RegisterSetLoopModeCallback002
495 * @tc.desc: have registered RegisterSetLoopModeCallback
496 * @tc.type: FUNC
497 * @tc.require: AR000H31JO
498 */
499 HWTEST_F(OHAVSessionCallbackImplTest, RegisterSetLoopModeCallback002, TestSize.Level0)
500 {
501 SLOGI("RegisterSetLoopModeCallback002 Begin");
502 auto avsession = std::make_shared<OHAVSession>();
503 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
504 EXPECT_TRUE(oh_avsession != nullptr);
505
506 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session,
__anon957ea5971602(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 507 AVSession_LoopMode curLoopMode, void* userData) -> AVSessionCallback_Result {
508 return AVSESSION_CALLBACK_RESULT_SUCCESS;
509 };
510 int userData = 1;
511 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
512 auto ret = g_ohAVSessionCallbackImpl.RegisterSetLoopModeCallback(oh_avsession, callback, (void *)(&userData));
513 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
514
515 auto it = std::find_if (g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.begin(),
516 g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.end(),
__anon957ea5971702(const std::pair<OH_AVSessionCallback_OnSetLoopMode, void*> &element) 517 [callback](const std::pair<OH_AVSessionCallback_OnSetLoopMode, void*> &element) {
518 return element.first == callback; });
519 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.setLoopModeCallbacks_.end());
520 SLOGI("RegisterSetLoopModeCallback002 End");
521 }
522
523 /**
524 * @tc.name: RegisterToggleFavoriteCallback002
525 * @tc.desc: have registered RegisterToggleFavoriteCallback
526 * @tc.type: FUNC
527 * @tc.require: AR000H31JO
528 */
529 HWTEST_F(OHAVSessionCallbackImplTest, RegisterToggleFavoriteCallback002, TestSize.Level0)
530 {
531 SLOGI("RegisterToggleFavoriteCallback002 Begin");
532 auto avsession = std::make_shared<OHAVSession>();
533 OH_AVSession* oh_avsession = reinterpret_cast<OH_AVSession*>(avsession.get());
534 EXPECT_TRUE(oh_avsession != nullptr);
535
536 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session,
__anon957ea5971802(OH_AVSession* session, const char* assetId, void* userData) 537 const char* assetId, void* userData) -> AVSessionCallback_Result {
538 return AVSESSION_CALLBACK_RESULT_SUCCESS;
539 };
540 int userData = 1;
541 g_ohAVSessionCallbackImpl.avsession_ = oh_avsession;
542 auto ret = g_ohAVSessionCallbackImpl.RegisterToggleFavoriteCallback(oh_avsession, callback, (void *)(&userData));
543 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
544
545 auto it = std::find_if (g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.begin(),
546 g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.end(),
__anon957ea5971902(const std::pair<OH_AVSessionCallback_OnToggleFavorite, void*> &element) 547 [callback](const std::pair<OH_AVSessionCallback_OnToggleFavorite, void*> &element) {
548 return element.first == callback; });
549 EXPECT_TRUE (it != g_ohAVSessionCallbackImpl.toggleFavoriteCallbacks_.end());
550 SLOGI("RegisterToggleFavoriteCallback002 End");
551 }
552
553 /**
554 * @tc.name: OnSetTargetLoopMode001
555 * @tc.desc: have registered RegisterToggleFavoriteCallback
556 * @tc.type: FUNC
557 * @tc.require: AR000H31JO
558 */
559 HWTEST_F(OHAVSessionCallbackImplTest, OnSetTargetLoopMode001, TestSize.Level1)
560 {
561 SLOGI("OnSetTargetLoopMode001 Begin");
562 std::string assetId = "assetId";
563 g_ohAVSessionCallbackImpl.OnPlayWithAssetId(assetId);
564 OH_AVSession* avsession = nullptr;
565 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
566 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
567 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5971a02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 568 void* userData) -> AVSessionCallback_Result {
569 return AVSESSION_CALLBACK_RESULT_SUCCESS;
570 };
571 int userData = 1;
572 AVSession_LoopMode loopMode = LOOP_MODE_SINGLE;
573 g_ohAVSessionCallbackImpl.OnSetTargetLoopMode(loopMode);
574 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command,
575 callback, (void *)(&userData));
576 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
577 ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
578 avsession, command, callback);
579 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
580 SLOGI("OnSetTargetLoopMode001 End");
581 }
582
583 /**
584 * @tc.name: OnPlayWithAssetId001
585 * @tc.desc: have registered OnPlayWithAssetId
586 * @tc.type: FUNC
587 * @tc.require: AR000H31JO
588 */
589 HWTEST_F(OHAVSessionCallbackImplTest, OnPlayWithAssetId001, TestSize.Level0)
590 {
591 SLOGI("OnPlayWithAssetId001 Begin");
592 OH_AVSession* avsession = nullptr;
593 OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnSetPlayCallback001", "com.xxx.hmxx", "ndkxx", &avsession);
594 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
595 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
__anon957ea5971b02(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 596 void* userData) -> AVSessionCallback_Result {
597 return AVSESSION_CALLBACK_RESULT_SUCCESS;
598 };
599 int userData = 1;
600 std::string assetId = "assetId";
601 g_ohAVSessionCallbackImpl.OnPlayWithAssetId(assetId);
602 AVSession_ErrCode ret = g_ohAVSessionCallbackImpl.SetPlayCallback(avsession, command,
603 callback, (void *)(&userData));
604 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
605 ret = g_ohAVSessionCallbackImpl.UnSetPlayCallback(
606 avsession, command, callback);
607 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
608 SLOGI("OnPlayWithAssetId001 End");
609 }
610 } //OHOS::AVSession
611