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 "OHAVSession.h"
18 #include "OHAVMetadataBuilder.h"
19 #include "native_avmetadata.h"
20 #include "avmeta_data.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS::AVSession {
25
26 class OHAVSessionTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void OHAVSessionTest::SetUpTestCase(void)
35 {
36 }
37
TearDownTestCase(void)38 void OHAVSessionTest::TearDownTestCase(void)
39 {
40 }
41
SetUp()42 void OHAVSessionTest::SetUp()
43 {
44 }
45
TearDown()46 void OHAVSessionTest::TearDown()
47 {
48 }
49
50 /**
51 * @tc.name: OH_AVSession_Create_001
52 * @tc.desc: Create from the class of ohavsession
53 * @tc.type: FUNC
54 * @tc.require: none
55 */
56 HWTEST(OHAVSessionTest, OH_AVSession_Create_001, TestSize.Level1)
57 {
58 OH_AVSession* avsession = nullptr;
59 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Create_001",
60 "com.xxx.hmxx", "ndkxx", &avsession);
61 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
62 ret = OH_AVSession_Destroy(avsession);
63 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
64 }
65
66 /**
67 * @tc.name: OH_AVSession_Destory_001
68 * @tc.desc: Destory from the class of ohavsession
69 * @tc.type: FUNC
70 * @tc.require: none
71 */
72 HWTEST(OHAVSessionTest, OH_AVSession_Destory_001, TestSize.Level1)
73 {
74 OH_AVSession* avsession = nullptr;
75 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Destory_001",
76 "com.xxx.hmxx", "ndkxx", &avsession);
77 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
78 ret = OH_AVSession_Destroy(avsession);
79 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
80 }
81
82 /**
83 * @tc.name: OH_AVSession_Activate_001
84 * @tc.desc: Activate from the class of ohavsession
85 * @tc.type: FUNC
86 * @tc.require: none
87 */
88 HWTEST(OHAVSessionTest, OH_AVSession_Activate_001, TestSize.Level1)
89 {
90 OH_AVSession* avsession = nullptr;
91 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Activate_001",
92 "com.xxx.hmxx", "ndkxx", &avsession);
93 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
94 ret = OH_AVSession_Activate(avsession);
95 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
96 ret = OH_AVSession_Destroy(avsession);
97 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
98 }
99
100 /**
101 * @tc.name: OH_AVSession_Deactivate_001
102 * @tc.desc: Deactivate from the class of ohavsession
103 * @tc.type: FUNC
104 * @tc.require: none
105 */
106 HWTEST(OHAVSessionTest, OH_AVSession_Deactivate_001, TestSize.Level1)
107 {
108 OH_AVSession* avsession = nullptr;
109 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_Deactivate_001",
110 "com.xxx.hmxx", "ndkxx", &avsession);
111 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
112 ret = OH_AVSession_Deactivate(avsession);
113 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
114 ret = OH_AVSession_Destroy(avsession);
115 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
116 }
117
118 /**
119 * @tc.name: OH_AVSession_GetSessionType_001
120 * @tc.desc: GetSessionType from the class of ohavsession
121 * @tc.type: FUNC
122 * @tc.require: none
123 */
124 HWTEST(OHAVSessionTest, OH_AVSession_GetSessionType_001, TestSize.Level1)
125 {
126 OH_AVSession* avsession = nullptr;
127 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_GetSessionType_001",
128 "com.xxx.hmxx", "ndkxx", &avsession);
129 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
130 AVSession_Type sessionType;
131 ret = OH_AVSession_GetSessionType(avsession, &sessionType);
132 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
133 EXPECT_EQ(sessionType, SESSION_TYPE_AUDIO);
134 ret = OH_AVSession_Destroy(avsession);
135 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
136 }
137
138 /**
139 * @tc.name: OH_AVSession_GetSessionId_001
140 * @tc.desc: GetSessionId from the class of ohavsession
141 * @tc.type: FUNC
142 * @tc.require: none
143 */
144 HWTEST(OHAVSessionTest, OH_AVSession_GetSessionId_001, TestSize.Level1)
145 {
146 OH_AVSession* avsession = nullptr;
147 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_GetSessionId_001",
148 "com.xxx.hmxx", "ndkxx", &avsession);
149 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
150 const char* sessionId;
151 ret = OH_AVSession_GetSessionId(avsession, &sessionId);
152 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
153 ret = OH_AVSession_Destroy(avsession);
154 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
155 }
156
157 /**
158 * @tc.name: OH_AVSession_SetAVMetadata_001
159 * @tc.desc: SetAVMetadata from the class of ohavsession
160 * @tc.type: FUNC
161 * @tc.require: none
162 */
163 HWTEST(OHAVSessionTest, OH_AVSession_SetAVMetadata_001, TestSize.Level1)
164 {
165 OH_AVSession* avsession = nullptr;
166 const uint64_t DURATION = 40000;
167 const int32_t TAGS = 1;
168 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetAVMetadata_001",
169 "com.xxx.hmxx", "ndkxx", &avsession);
170 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
171 OH_AVMetadataBuilder *builder;
172 OH_AVMetadata *ohMetaData;
173 AVMetadata_Result res;
174 res = OH_AVMetadataBuilder_Create(&builder);
175 EXPECT_EQ(res, AVMETADATA_SUCCESS);
176 OH_AVMetadataBuilder_SetTitle(builder, "UNIT TEST");
177 OH_AVMetadataBuilder_SetArtist(builder, "Anonymous artist");
178 OH_AVMetadataBuilder_SetAuthor(builder, "Anonymous author");
179 OH_AVMetadataBuilder_SetAlbum(builder, "Anonymous album");
180 OH_AVMetadataBuilder_SetWriter(builder, "Anonymous writer");
181 OH_AVMetadataBuilder_SetComposer(builder, "Anonymous composer");
182 OH_AVMetadataBuilder_SetDuration(builder, DURATION);
183 OH_AVMetadataBuilder_SetMediaImageUri(builder, "https://xxx.xxx.xx");
184 OH_AVMetadataBuilder_SetSubtitle(builder, "fac");
185 OH_AVMetadataBuilder_SetDescription(builder, "For somebody");
186 OH_AVMetadataBuilder_SetLyric(builder, "balabala");
187 OH_AVMetadataBuilder_SetAssetId(builder, "999");
188 OH_AVMetadataBuilder_SetSkipIntervals(builder, SECONDS_30);
189 OH_AVMetadataBuilder_SetDisplayTags(builder, TAGS);
190 OH_AVMetadataBuilder_GenerateAVMetadata(builder, &ohMetaData);
191
192 ret = OH_AVSession_SetAVMetadata(avsession, ohMetaData);
193 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
194 ret = OH_AVSession_Destroy(avsession);
195 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
196 OH_AVMetadata_Destroy(ohMetaData);
197 OH_AVMetadataBuilder_Destroy(builder);
198 }
199
200 /**
201 * @tc.name: OH_AVSession_SetPlaybackState_001
202 * @tc.desc: SetPlaybackState from the class of ohavsession
203 * @tc.type: FUNC
204 * @tc.require: none
205 */
206 HWTEST(OHAVSessionTest, OH_AVSession_SetPlaybackState_001, TestSize.Level1)
207 {
208 OH_AVSession* avsession = nullptr;
209 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetPlaybackState_001",
210 "com.xxx.hmxx", "ndkxx", &avsession);
211 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
212 AVSession_PlaybackState state = PLAYBACK_STATE_PREPARING;
213 ret = OH_AVSession_SetPlaybackState(avsession, state);
214 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
215 ret = OH_AVSession_Destroy(avsession);
216 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
217 }
218
219 /**
220 * @tc.name: OH_AVSession_SetPlaybackPosition_001
221 * @tc.desc: SetPlaybackPosition from the class of ohavsession
222 * @tc.type: FUNC
223 * @tc.require: none
224 */
225 HWTEST(OHAVSessionTest, OH_AVSession_SetPlaybackPosition_001, TestSize.Level1)
226 {
227 OH_AVSession* avsession = nullptr;
228 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "OH_AVSession_SetPlaybackPosition_001",
229 "com.xxx.hmxx", "ndkxx", &avsession);
230 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
231 AVSession_PlaybackPosition* playbackPosition = new AVSession_PlaybackPosition;
232 playbackPosition->elapsedTime = 1;
233 playbackPosition->updateTime = 2;
234 ret = OH_AVSession_SetPlaybackPosition(avsession, playbackPosition);
235 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
236 ret = OH_AVSession_Destroy(avsession);
237 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
238 }
239
240 /**
241 * @tc.name: OH_AVSession_SetFavorite_001
242 * @tc.desc: SetFavorite from the class of ohavsession
243 * @tc.type: FUNC
244 * @tc.require: none
245 */
246 HWTEST(OHAVSessionTest, OH_AVSession_SetFavorite_001, TestSize.Level1)
247 {
248 OH_AVSession* avsession = nullptr;
249 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
250 "com.xxx.hmxx", "ndkxx", &avsession);
251 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
252 bool isFavorite = true;
253 ret = OH_AVSession_SetFavorite(avsession, isFavorite);
254 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
255 ret = OH_AVSession_Destroy(avsession);
256 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
257 }
258
259 /**
260 * @tc.name: OH_AVSession_SetLoopMode_001
261 * @tc.desc: SetLoopMode from the class of ohavsession
262 * @tc.type: FUNC
263 * @tc.require: none
264 */
265 HWTEST(OHAVSessionTest, OH_AVSession_SetLoopMode_001, TestSize.Level1)
266 {
267 OH_AVSession* avsession = nullptr;
268 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
269 "com.xxx.hmxx", "ndkxx", &avsession);
270 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
271 AVSession_LoopMode loopMode = LOOP_MODE_SINGLE;
272 ret = OH_AVSession_SetLoopMode(avsession, loopMode);
273 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
274 ret = OH_AVSession_Destroy(avsession);
275 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
276 }
277
278 /**
279 * @tc.name: OH_AVSession_RegisterCommandCallback_001
280 * @tc.desc: RegisterCommandCallback from the class of ohavsession
281 * @tc.type: FUNC
282 * @tc.require: none
283 */
284 HWTEST(OHAVSessionTest, OH_AVSession_RegisterCommandCallback_001, TestSize.Level1)
285 {
286 OH_AVSession* avsession = nullptr;
287 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "RegisterCommandCallback_001",
288 "com.xxx.hmxx", "ndkxx", &avsession);
289 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
290 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
291 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
292 void* userData) -> AVSessionCallback_Result
__anon99310b6f0102(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 293 {
294 return AVSESSION_CALLBACK_RESULT_SUCCESS;
295 };
296 int userData = 1;
297 ret = OH_AVSession_RegisterCommandCallback(avsession, command, callback, (void *)(&userData));
298 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
299 ret = OH_AVSession_Destroy(avsession);
300 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
301 }
302
303 /**
304 * @tc.name: OH_AVSession_UnregisterCommandCallback_001
305 * @tc.desc: UnregisterCommandCallback from the class of ohavsession
306 * @tc.type: FUNC
307 * @tc.require: none
308 */
309 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterCommandCallback_001, TestSize.Level1)
310 {
311 OH_AVSession* avsession = nullptr;
312 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "UnregisterCommandCallback_001",
313 "com.xxx.hmxx", "ndkxx", &avsession);
314 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
315 AVSession_ControlCommand command = CONTROL_CMD_PLAY;
316 OH_AVSessionCallback_OnCommand callback = [](OH_AVSession* session, AVSession_ControlCommand command,
317 void* userData) -> AVSessionCallback_Result
__anon99310b6f0202(OH_AVSession* session, AVSession_ControlCommand command, void* userData) 318 {
319 return AVSESSION_CALLBACK_RESULT_SUCCESS;
320 };
321 ret = OH_AVSession_UnregisterCommandCallback(avsession, command, callback);
322 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
323 ret = OH_AVSession_Destroy(avsession);
324 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
325 }
326
327 /**
328 * @tc.name: OH_AVSession_RegisterForwardCallback_001
329 * @tc.desc: RegisterForwardCallback from the class of ohavsession
330 * @tc.type: FUNC
331 * @tc.require: none
332 */
333 HWTEST(OHAVSessionTest, OH_AVSession_RegisterForwardCallback_001, TestSize.Level1)
334 {
335 OH_AVSession* avsession = nullptr;
336 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
337 "com.xxx.hmxx", "ndkxx", &avsession);
338 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
339 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
340 void* userData) -> AVSessionCallback_Result
__anon99310b6f0302(OH_AVSession* session, uint32_t seekTime, void* userData) 341 {
342 return AVSESSION_CALLBACK_RESULT_SUCCESS;
343 };
344 int userData = 1;
345 ret = OH_AVSession_RegisterForwardCallback(avsession, callback, (void *)(&userData));
346 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
347 ret = OH_AVSession_Destroy(avsession);
348 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
349 }
350
351 /**
352 * @tc.name: OH_AVSession_UnregisterForwardCallback_001
353 * @tc.desc: UnregisterForwardCallback from the class of ohavsession
354 * @tc.type: FUNC
355 * @tc.require: none
356 */
357 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterForwardCallback_001, TestSize.Level1)
358 {
359 OH_AVSession* avsession = nullptr;
360 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
361 "com.xxx.hmxx", "ndkxx", &avsession);
362 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
363 OH_AVSessionCallback_OnFastForward callback = [](OH_AVSession* session, uint32_t seekTime,
364 void* userData) -> AVSessionCallback_Result
__anon99310b6f0402(OH_AVSession* session, uint32_t seekTime, void* userData) 365 {
366 return AVSESSION_CALLBACK_RESULT_SUCCESS;
367 };
368 int userData = 1;
369 ret = OH_AVSession_RegisterForwardCallback(avsession, callback, (void *)(&userData));
370 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
371 ret = OH_AVSession_UnregisterForwardCallback(avsession, callback);
372 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
373 ret = OH_AVSession_Destroy(avsession);
374 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
375 }
376
377 /**
378 * @tc.name: OH_AVSession_RegisterRewindCallback_001
379 * @tc.desc: RegisterRewindCallback from the class of ohavsession
380 * @tc.type: FUNC
381 * @tc.require: none
382 */
383 HWTEST(OHAVSessionTest, OH_AVSession_RegisterRewindCallback_001, TestSize.Level1)
384 {
385 OH_AVSession* avsession = nullptr;
386 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
387 "com.xxx.hmxx", "ndkxx", &avsession);
388 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
389 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* session, uint32_t seekTime,
390 void* userData) -> AVSessionCallback_Result
__anon99310b6f0502(OH_AVSession* session, uint32_t seekTime, void* userData) 391 {
392 return AVSESSION_CALLBACK_RESULT_SUCCESS;
393 };
394 int userData = 1;
395 ret = OH_AVSession_RegisterRewindCallback(avsession, callback, (void *)(&userData));
396 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
397 ret = OH_AVSession_Destroy(avsession);
398 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
399 }
400
401 /**
402 * @tc.name: OH_AVSession_UnregisterRewindCallback_001
403 * @tc.desc: UnregisterRewindCallback from the class of ohavsession
404 * @tc.type: FUNC
405 * @tc.require: none
406 */
407 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterRewindCallback_001, TestSize.Level1)
408 {
409 OH_AVSession* avsession = nullptr;
410 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
411 "com.xxx.hmxx", "ndkxx", &avsession);
412 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
413 OH_AVSessionCallback_OnRewind callback = [](OH_AVSession* session, uint32_t seekTime,
414 void* userData) -> AVSessionCallback_Result
__anon99310b6f0602(OH_AVSession* session, uint32_t seekTime, void* userData) 415 {
416 return AVSESSION_CALLBACK_RESULT_SUCCESS;
417 };
418 int userData = 1;
419 ret = OH_AVSession_RegisterRewindCallback(avsession, callback, (void *)(&userData));
420 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
421 ret = OH_AVSession_UnregisterRewindCallback(avsession, callback);
422 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
423 ret = OH_AVSession_Destroy(avsession);
424 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
425 }
426
427 /**
428 * @tc.name: OH_AVSession_RegisterSeekCallback_001
429 * @tc.desc: RegisterSeekCallback from the class of ohavsession
430 * @tc.type: FUNC
431 * @tc.require: none
432 */
433 HWTEST(OHAVSessionTest, OH_AVSession_RegisterSeekCallback_001, TestSize.Level1)
434 {
435 OH_AVSession* avsession = nullptr;
436 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
437 "com.xxx.hmxx", "ndkxx", &avsession);
438 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
439 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
440 void* userData) -> AVSessionCallback_Result
__anon99310b6f0702(OH_AVSession* session, uint64_t seekTime, void* userData) 441 {
442 return AVSESSION_CALLBACK_RESULT_SUCCESS;
443 };
444 int userData = 1;
445 ret = OH_AVSession_RegisterSeekCallback(avsession, callback, (void *)(&userData));
446 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
447 ret = OH_AVSession_Destroy(avsession);
448 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
449 }
450
451 /**
452 * @tc.name: OH_AVSession_UnregisterSeekCallback_001
453 * @tc.desc: UnregisterSeekCallback from the class of ohavsession
454 * @tc.type: FUNC
455 * @tc.require: none
456 */
457 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterSeekCallback_001, TestSize.Level1)
458 {
459 OH_AVSession* avsession = nullptr;
460 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
461 "com.xxx.hmxx", "ndkxx", &avsession);
462 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
463 OH_AVSessionCallback_OnSeek callback = [](OH_AVSession* session, uint64_t seekTime,
464 void* userData) -> AVSessionCallback_Result
__anon99310b6f0802(OH_AVSession* session, uint64_t seekTime, void* userData) 465 {
466 return AVSESSION_CALLBACK_RESULT_SUCCESS;
467 };
468 int userData = 1;
469 ret = OH_AVSession_RegisterSeekCallback(avsession, callback, (void *)(&userData));
470 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
471 ret = OH_AVSession_UnregisterSeekCallback(avsession, callback);
472 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
473 ret = OH_AVSession_Destroy(avsession);
474 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
475 }
476
477 /**
478 * @tc.name: OH_AVSession_RegisterSetLoopModeCallback_001
479 * @tc.desc: RegisterSetLoopModeCallback from the class of ohavsession
480 * @tc.type: FUNC
481 * @tc.require: none
482 */
483 HWTEST(OHAVSessionTest, OH_AVSession_RegisterSetLoopModeCallback_001, TestSize.Level1)
484 {
485 OH_AVSession* avsession = nullptr;
486 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
487 "com.xxx.hmxx", "ndkxx", &avsession);
488 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
489 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
490 void* userData) -> AVSessionCallback_Result
__anon99310b6f0902(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 491 {
492 return AVSESSION_CALLBACK_RESULT_SUCCESS;
493 };
494 int userData = 1;
495 ret = OH_AVSession_RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
496 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
497 ret = OH_AVSession_Destroy(avsession);
498 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
499 }
500
501 /**
502 * @tc.name: OH_AVSession_UnregisterSetLoopModeCallback_001
503 * @tc.desc: UnregisterSetLoopModeCallback from the class of ohavsession
504 * @tc.type: FUNC
505 * @tc.require: none
506 */
507 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterSetLoopModeCallback_001, TestSize.Level1)
508 {
509 OH_AVSession* avsession = nullptr;
510 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
511 "com.xxx.hmxx", "ndkxx", &avsession);
512 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
513 OH_AVSessionCallback_OnSetLoopMode callback = [](OH_AVSession* session, AVSession_LoopMode curLoopMode,
514 void* userData) -> AVSessionCallback_Result
__anon99310b6f0a02(OH_AVSession* session, AVSession_LoopMode curLoopMode, void* userData) 515 {
516 return AVSESSION_CALLBACK_RESULT_SUCCESS;
517 };
518 int userData = 1;
519 ret = OH_AVSession_RegisterSetLoopModeCallback(avsession, callback, (void *)(&userData));
520 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
521 ret = OH_AVSession_UnregisterSetLoopModeCallback(avsession, callback);
522 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
523 ret = OH_AVSession_Destroy(avsession);
524 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
525 }
526
527 /**
528 * @tc.name: OH_AVSession_RegisterToggleFavoriteCallback_001
529 * @tc.desc: RegisterToggleFavoriteCallback from the class of ohavsession
530 * @tc.type: FUNC
531 * @tc.require: none
532 */
533 HWTEST(OHAVSessionTest, OH_AVSession_RegisterToggleFavoriteCallback_001, TestSize.Level1)
534 {
535 OH_AVSession* avsession = nullptr;
536 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
537 "com.xxx.hmxx", "ndkxx", &avsession);
538 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
539 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
540 void* userData) -> AVSessionCallback_Result
__anon99310b6f0b02(OH_AVSession* session, const char* assetId, void* userData) 541 {
542 return AVSESSION_CALLBACK_RESULT_SUCCESS;
543 };
544 int userData = 1;
545 ret = OH_AVSession_RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
546 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
547 ret = OH_AVSession_Destroy(avsession);
548 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
549 }
550
551 /**
552 * @tc.name: OH_AVSession_UnregisterToggleFavoriteCallback_001
553 * @tc.desc: Unregister Toggle Favorite Callback from the class of ohavsession
554 * @tc.type: FUNC
555 * @tc.require: none
556 */
557 HWTEST(OHAVSessionTest, OH_AVSession_UnregisterToggleFavoriteCallback_001, TestSize.Level1)
558 {
559 OH_AVSession* avsession = nullptr;
560 AVSession_ErrCode ret = OH_AVSession_Create(SESSION_TYPE_AUDIO, "oh_av_session_test_001",
561 "com.xxx.hmxx", "ndkxx", &avsession);
562 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
563 OH_AVSessionCallback_OnToggleFavorite callback = [](OH_AVSession* session, const char* assetId,
564 void* userData) -> AVSessionCallback_Result
__anon99310b6f0c02(OH_AVSession* session, const char* assetId, void* userData) 565 {
566 return AVSESSION_CALLBACK_RESULT_SUCCESS;
567 };
568 int userData = 1;
569 ret = OH_AVSession_RegisterToggleFavoriteCallback(avsession, callback, (void *)(&userData));
570 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
571 ret = OH_AVSession_UnregisterToggleFavoriteCallback(avsession, callback);
572 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
573 ret = OH_AVSession_Destroy(avsession);
574 EXPECT_EQ(ret, AV_SESSION_ERR_SUCCESS);
575 }
576 }