• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2022 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
16import media from '@ohos.multimedia.media'
17import * as mediaTestBase from './MediaTestBase.js';
18
19export const AV_PLAYER_STATE = {
20    IDLE : 'idle',
21    INITIALIZED : 'initialized',
22    PREPARED : 'prepared',
23    PLAYING : 'playing',
24    PAUSED : 'paused',
25    COMPLETED : 'completed',
26    STOPPED : 'stopped',
27    RELEASED : 'released',
28    ERROR : 'error',
29}
30
31let playTest = {
32    width: 0,
33    height: 0,
34    duration: -1
35}
36export {playTest};
37
38export function setSource(avPlayer, src) {
39    if (typeof(avPlayer) == 'undefined') {
40        console.error('case avPlayer is undefined');
41        return;
42    }
43    if (typeof(src) == 'string') {
44        console.info('case src test');
45        avPlayer.url = src;
46    } else {
47        console.info('case fdsrc test');
48        avPlayer.fdSrc = src;
49    }
50}
51
52function checkPlayTest(avPlayer, playTest) {
53    if (avPlayer == null) {
54        return;
55    }
56    expect(Math.abs(avPlayer.duration - playTest.duration)).assertLess(500);
57    if (playTest.width > 0) {
58        expect(avPlayer.width).assertEqual(playTest.width);
59        expect(avPlayer.height).assertEqual(playTest.height);
60    }
61}
62
63function toPreparePromise(avPlayer, playTest) {
64    if (typeof(avPlayer) == 'undefined') {
65        return;
66    }
67    avPlayer.prepare().then(() => {
68        console.info('case prepare called');
69        console.info('case avPlayer.duration: ' + avPlayer.duration);
70        checkPlayTest(avPlayer, playTest);
71    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
72}
73
74async function preparePromise(avPlayer) {
75    if (typeof(avPlayer) == 'undefined') {
76        return;
77    }
78    await avPlayer.prepare().then(() => {
79        console.info('case prepare called');
80        console.info('case avPlayer.duration: ' + avPlayer.duration);
81    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
82}
83
84function addCnt(countArr) {
85    if (countArr != null) {
86        countArr[0]++;
87    }
88}
89
90export function setCallback(avPlayer, type, countArr) {
91    if (avPlayer == null) {
92        return;
93    }
94    switch (type) {
95        case 'volumeChange':
96            avPlayer.on('volumeChange', (volume) => {
97                console.info(`case volumeChange called, volume is ${volume}`);
98                addCnt(countArr);
99            });
100            break;
101        case 'endOfStream':
102            avPlayer.on('endOfStream', () => {
103                console.info(`case endOfStream called`);
104                addCnt(countArr);
105            });
106            break;
107        case 'speedDone':
108            avPlayer.on('speedDone', (speedMode) => {
109                console.info(`case speedDone called, speedMode is ${speedMode}`);
110                addCnt(countArr);
111            });
112            break;
113        case 'bitrateDone':
114            avPlayer.on('bitrateDone', (bitrate) => {
115                console.info(`case bitrateDone called, bitrate is ${bitrate}`);
116            });
117            break;
118        case 'timeUpdate':
119            avPlayer.on('timeUpdate', (time) => {
120                console.info('case timeUpdate callback, time:' + time);
121            });
122            break;
123        case 'bufferingUpdate':
124            avPlayer.on('bufferingUpdate', (infoType, value) => {
125            });
126            break;
127        case  'durationUpdate':
128            avPlayer.on('durationUpdate', (duration) => {
129                console.info('case durationUpdate called,duration:' + duration);
130                addCnt(countArr);
131            });
132            break;
133        case 'startRenderFrame':
134            avPlayer.on('startRenderFrame', () => {
135                console.info('case startRenderFrame called');
136                addCnt(countArr);
137            });
138            break;
139        case 'videoSizeChange':
140            avPlayer.on('videoSizeChange', (w, h) => {
141                console.info(`case videoSizeChange called, weight is ${w}, height is ${h}`);
142                addCnt(countArr);
143            });
144            break;
145        case  'audioInterrupt':
146            avPlayer.on('audioInterrupt', (info) => {
147                console.info(`case audioInterrupt called, info is ${info}`);
148            });
149            break;
150        case  'availableBitrates':
151            avPlayer.on('availableBitrates', (bitrates) => {
152                for (let i = 0; i < bitrates.length; i++) {
153                    console.info('case availableBitrates : '  + bitrates[i]);
154                }
155                addCnt(countArr);
156            });
157            break;
158        default:
159            break;
160    }
161}
162
163export function offCallback(avPlayer, typeArr)
164{
165    if (avPlayer == null) {
166        return;
167    }
168    for (let i = 0; i < typeArr.length; i++) {
169        switch (typeArr[i]) {
170            case 'stateChange':
171                avPlayer.off('stateChange');
172                break;
173            case 'volumeChange':
174                avPlayer.off('volumeChange');
175                break;
176            case 'endOfStream':
177                avPlayer.off('endOfStream');
178                break;
179            case 'seekDone':
180                avPlayer.off('seekDone');
181                break;
182            case 'speedDone':
183                avPlayer.off('speedDone');
184                break;
185            case 'speedDone':
186                avPlayer.off('speedDone');
187                break;
188            case 'timeUpdate':
189                avPlayer.off('timeUpdate');
190                break;
191            case 'durationUpdate':
192                avPlayer.off('durationUpdate');
193                break;
194            case 'bufferingUpdate':
195                avPlayer.off('bufferingUpdate');
196                break;
197            case 'startRenderFrame':
198                avPlayer.off('startRenderFrame');
199                break;
200            case 'videoSizeChange':
201                avPlayer.off('videoSizeChange');
202                break;
203            case 'audioInterrupt':
204                avPlayer.off('audioInterrupt');
205                break;
206            case 'availableBitrates':
207                avPlayer.off('availableBitrates');
208                break;
209            case 'error':
210                avPlayer.off('error');
211                break;
212            default:
213                break;
214        }
215    }
216}
217
218export function setAVPlayerFunCb(src, avPlayer, playTest, playTime, done) {
219    let volumeCnt = [0];
220    let endOfStreamCnt = [0];
221    let speedDoneCnt = [0];
222    let videoSizeCnt = [0];
223    let startRenderFrameCnt = [0];
224    let durationUpdateCnt = [0];
225    let seekDoneCnt = [0];
226    let prepareCnt = 0;
227    let playCnt = 0;
228    let completedCnt = 0;
229    let surfaceID = globalThis.value;
230    console.info(`case setAVPlayerFunCb in, surfaceID is ${surfaceID}`);
231    avPlayer.on('stateChange', async (state, reason) => {
232        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
233        if (reason == media.StateChangeReason.BACKGROUND) {
234            console.info(`case media.StateChangeReason.BACKGROUND`);
235            await avPlayer.release().then(() => {
236            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
237        }
238        console.info(`case state is ${state}`);
239        switch (state) {
240            case AV_PLAYER_STATE.INITIALIZED:
241                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED);
242                avPlayer.surfaceId = surfaceID;
243                try{
244                    avPlayer.audioRendererInfo = {
245                        content:audio.AudioRendererInfo.CONTENT_TYPE_MUSIC,
246                        usage:audio.AudioRendererInfo.STREAM_USAGE_MEDIA,
247                    }
248                }catch(e){
249                    console.error(`case stateChange error, e is ${e} ,message:${e.message}`);
250                }
251                // step 1, 13: initialized -> prepared
252                toPreparePromise(avPlayer, playTest);
253                break;
254            case AV_PLAYER_STATE.PREPARED:
255                prepareCnt++;
256                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
257                checkPlayTest(avPlayer, playTest);
258                expect(avPlayer.currentTime).assertEqual(0);
259                if (prepareCnt == 1) {
260                    // step 2: prepared -> playing
261                    avPlayer.play().then(() => {
262                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
263                } else {
264                    // step 14: prepared -> seek
265                    avPlayer.seek(avPlayer.duration);
266                }
267                break;
268            case AV_PLAYER_STATE.PLAYING:
269                playCnt++;
270                if (playCnt == 1) {
271                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
272                    // step 3: playing -> seek duration/3
273                    await mediaTestBase.msleepAsync(playTime);
274                    avPlayer.seek(avPlayer.duration / 3);
275                } else if (playCnt == 2) {
276                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
277                    //  step 7: playing -> seek duration when loop true
278                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
279                } else if (playCnt == 3) {
280                    // step 10: playing -> stop
281                    avPlayer.stop().then(() => {
282                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
283                }
284                break;
285            case AV_PLAYER_STATE.PAUSED:
286                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
287                // step 5: pause -> seek 0
288                avPlayer.loop = true;
289                avPlayer.seek(0, media.SeekMode.SEEK_NEXT_SYNC);
290                break;
291            case AV_PLAYER_STATE.COMPLETED:
292                completedCnt++;
293                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
294                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED);
295                if (completedCnt == 1 && seekDoneCnt[0] < 5) {
296                    // step 9: completed -> play
297                    avPlayer.play();
298                } else {
299                    // step 16: completed -> reset
300                    avPlayer.reset().then(() => {
301                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
302                        // step 17: reset -> release
303                        avPlayer.release().then(() => {
304                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
305                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
306                }
307                break;
308            case AV_PLAYER_STATE.STOPPED:
309                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
310                // step 11: stop -> reset
311                avPlayer.reset().then(() => {
312                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
313                    // step 12: reset -> initialized
314                    setSource(avPlayer, src);
315                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
316                break;
317            case AV_PLAYER_STATE.RELEASED:
318                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
319                // step 18: release -> done
320                avPlayer = null;
321                expect(volumeCnt[0]).assertLarger(0);
322                expect(endOfStreamCnt[0]).assertLarger(0);
323                expect(seekDoneCnt[0]).assertLarger(0);
324                expect(speedDoneCnt[0]).assertLarger(0);
325                expect(completedCnt).assertLarger(0);
326                if (playTest.width != 0) {
327                    expect(startRenderFrameCnt[0]).assertLarger(0);
328                    expect(videoSizeCnt[0]).assertLarger(0);
329                } else {
330                    expect(startRenderFrameCnt[0]).assertEqual(0);
331                    expect(videoSizeCnt[0]).assertEqual(0);
332                }
333                expect(durationUpdateCnt[0]).assertLarger(0)
334                done();
335                break;
336            case AV_PLAYER_STATE.ERROR:
337                expect().assertFail();
338                avPlayer.release().then(() => {
339                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
340                break;
341            default:
342                break;
343        }
344    });
345    avPlayer.on('seekDone', async (seekDoneTime) => {
346        seekDoneCnt[0]++;
347        console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`);
348        switch (seekDoneCnt[0]) {
349            case 2:
350                // step 6: seek(paused) -> play
351                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
352                avPlayer.play();
353                avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_2_00_X);
354                avPlayer.setVolume(0.5);
355                break;
356            case 1:
357                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
358                // step 4: seek(playing) -> pause
359                avPlayer.pause().then(() => {
360                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
361                break;
362            case 3:
363            case 4:
364            case 5:
365                let nowTime = avPlayer.currentTime;
366                if (avPlayer.state == AV_PLAYER_STATE.PREPARED) {
367                    // step 15: prepared -> play
368                    avPlayer.play();
369                }
370                if (nowTime > avPlayer.duration / 2) {
371                    avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
372                    await mediaTestBase.msleepAsync(avPlayer.duration - nowTime + playTime);
373                }
374                if (avPlayer.loop == true) {
375                    // step 8: playing -> seek duration when loop false
376                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
377                    avPlayer.loop = false;
378                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
379                }
380                break;
381        }
382    });
383    setCallback(avPlayer, 'volumeChange', volumeCnt);
384    setCallback(avPlayer, 'endOfStream', endOfStreamCnt);
385    setCallback(avPlayer, 'speedDone', speedDoneCnt);
386    setCallback(avPlayer, 'bitrateDone', null);
387    setCallback(avPlayer, 'timeUpdate', null);
388    setCallback(avPlayer, 'bufferingUpdate', null);
389    setCallback(avPlayer, 'durationUpdate', durationUpdateCnt);
390    setCallback(avPlayer, 'startRenderFrame', startRenderFrameCnt);
391    setCallback(avPlayer, 'videoSizeChange', videoSizeCnt);
392    setCallback(avPlayer, 'audioInterrupt', null);
393    setCallback(avPlayer, 'availableBitrates', null);
394    avPlayer.on('error', async (err) => {
395        console.error(`case error called, errMessage is ${err.message}`);
396        expect().assertFail();
397        await avPlayer.release().then(() => {
398            avPlayer = null;
399            done();
400        });
401    });
402}
403
404export function sleep(ms) {
405    return new Promise(resolve => setTimeout(resolve, ms));
406}
407
408function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done) {
409    let playPauseCount = 0;
410    let surfaceID = globalThis.value;
411    console.info(`case setAVPlayerPlayAndPauseWithCallBack in, surfaceID is ${surfaceID}`);
412    avPlayer.on('stateChange', async (state, reason) => {
413        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
414        console.info(`case state is ${state}`);
415        switch (state) {
416            case AV_PLAYER_STATE.INITIALIZED:
417                avPlayer.surfaceId = surfaceID;
418                console.info('playPauseLoopWithCallBack play state is INITIALIZED')
419                preparePromise(avPlayer);
420                break;
421            case AV_PLAYER_STATE.PREPARED:
422            // step 1: initialized -> prepared -> play
423                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
424                console.info('playPauseLoopWithCallBack play state is PREPARED')
425                avPlayer.play()
426                break;
427            case AV_PLAYER_STATE.PLAYING:
428                avPlayer.loop = true;
429                console.info('playPauseLoopWithCallBack play state is PLAYING')
430                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
431                playPauseCount++;
432                mediaTestBase.msleepAsync(playTime);
433                if(playPauseCount == 1001){
434                    // step 4: playing -> stop -> release
435                    avPlayer.stop().then(() => {
436                        console.info('playPauseLoopWithCallBack avPlayer from play to stop')
437                        avPlayer.release().then(() => {
438                            console.info('playPauseLoopWithCallBack avPlayer from stop to release')
439                            done();
440                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
441                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
442                }else{
443                    // step 2: playing -> pause loop
444                    avPlayer.pause().then(() => {
445                        console.info('playPauseLoopWithCallBack avPlayer from play to pause,time is :' + playPauseCount)
446                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
447                }
448                break;
449            case AV_PLAYER_STATE.PAUSED:
450                console.info('playPauseLoopWithCallBack play state is PAUSED')
451                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
452            // step 3: pause -> playing loop
453                avPlayer.play().then(() => {
454                    console.info('playPauseLoopWithCallBack avPlayer from pause to play,time is :' + playPauseCount)
455                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
456                break;
457            case AV_PLAYER_STATE.ERROR:
458                expect().assertFail();
459                avPlayer.release().then(() => {
460                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
461                break;
462            default:
463                break;
464        }
465    });
466    avPlayer.on('error', async (err) => {
467        console.error(`case error called, errMessage is ${err.message}`);
468        expect().assertFail();
469        await avPlayer.release().then(() => {
470            avPlayer = null;
471            done();
472        });
473    });
474}
475
476async function idle(src, avPlayer) {
477    console.info(`case media source: ${src}`)
478    await media.createAVPlayer().then((video) => {
479        if (typeof(video) != 'undefined') {
480            console.info('case createAVPlayer success');
481            avPlayer = video;
482        } else {
483            console.error('case createAVPlayer failed');
484            expect().assertFail();
485        }
486    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
487    return avPlayer;
488}
489
490export async function avPlayerWithCallBack(src, avPlayer, playTime, done) {
491    avPlayer = await idle(src, avPlayer)
492    await setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done);
493    await setSource(avPlayer, src);
494}
495
496let createToReleaseLoopCount = 0;
497async function createToReleaseLoop(src, avPlayer, done) {
498    let surfaceID = globalThis.value;
499    console.info(`case createToReleaseLoop in, surfaceID is ${surfaceID}`);
500    avPlayer.on('stateChange', async (state, reason) => {
501        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
502        console.info(`case state is ${state}`);
503        switch (state) {
504            case AV_PLAYER_STATE.IDLE:
505                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
506                setSource(avPlayer, src);
507                break;
508            case AV_PLAYER_STATE.INITIALIZED:
509                avPlayer.surfaceId = surfaceID;
510                console.info('createToReleaseLoop play state is INITIALIZED')
511            // step 1: initialized -> prepared -> play
512                avPlayer.release()
513                break;
514            case AV_PLAYER_STATE.RELEASED:
515                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
516                createToReleaseLoopCount++
517                if(createToReleaseLoopCount==1001){
518                    done();
519                }else{
520                    avPlayer = await idle(src, avPlayer)
521                    await createToReleaseLoop(src, avPlayer, done)
522                    await setSource(avPlayer, src);
523                }
524                break;
525            case AV_PLAYER_STATE.ERROR:
526                expect().assertFail();
527                avPlayer.release().then(() => {
528                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
529                break;
530            default:
531                break;
532        }
533    });
534    avPlayer.on('error', async (err) => {
535        console.error(`case error called, errMessage is ${err.message}`);
536        expect().assertFail();
537        await avPlayer.release().then(() => {
538            avPlayer = null;
539            done();
540        });
541    });
542}
543
544export async function createToRelease(src, avPlayer, done) {
545    let surfaceID = globalThis.value;
546    avPlayer = await idle(src, avPlayer)
547    await createToReleaseLoop(src, avPlayer, done)
548    await setSource(avPlayer, src);
549    console.info('CreateToRelease setSource');
550}
551
552export async function playToCompleted(src, avPlayer, done) {
553    avPlayer = await idle(src, avPlayer)
554    await playToCompletedLoop(src, avPlayer, done);
555    await setSource(avPlayer, src);
556}
557
558async function playToCompletedLoop(src, avPlayer, done) {
559    let playToCompletedCount = 0;
560    let surfaceID = globalThis.value;
561    console.info(`case playToCompletedLoop in, surfaceID is ${surfaceID}`);
562    avPlayer.on('stateChange', async (state, reason) => {
563        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
564        console.info(`case state is ${state}`);
565        switch (state) {
566            case AV_PLAYER_STATE.INITIALIZED:
567                avPlayer.surfaceId = surfaceID;
568                console.info('playToCompletedLoop play state is INITIALIZED')
569            // step 1: initialized -> prepared -> play
570                await preparePromise(avPlayer);
571                await sleep(2000);
572                avPlayer.play()
573                break;
574            case AV_PLAYER_STATE.PLAYING:
575                avPlayer.loop = false;
576                console.info('playToCompletedLoop play state is PLAYING')
577                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
578                playToCompletedCount++;
579                if(playToCompletedCount == 1001){
580                    // step 4: playing -> stop -> release
581                    avPlayer.stop().then(() => {
582                        console.info('playToCompletedLoop avPlayer from play to stop')
583                        avPlayer.release().then(() => {
584                            console.info('playToCompletedLoop avPlayer from stop to release')
585                            done();
586                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
587                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
588                }else{
589                    // step 2: playing -> seek loop
590                    avPlayer.seek(10034, media.SeekMode.SEEK_NEXT_SYNC)
591                    console.info('playToCompletedLoop avPlayer from play to seek,time is :' + playToCompletedCount)
592                }
593                break;
594            case AV_PLAYER_STATE.COMPLETED:
595                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
596                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED);
597                console.info('playToCompletedLoop avPlayer from COMPLETED to play')
598            // step 3: COMPLETED -> play loop
599                avPlayer.play();
600                break;
601            case AV_PLAYER_STATE.ERROR:
602                expect().assertFail();
603                avPlayer.release().then(() => {
604                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
605                break;
606            default:
607                break;
608        }
609    });
610    avPlayer.on('error', async (err) => {
611        console.error(`case error called, errMessage is ${err.message}`);
612        expect().assertFail();
613        await avPlayer.release().then(() => {
614            avPlayer = null;
615            done();
616        });
617    });
618}
619
620export async function seekLoop(src, avPlayer, done) {
621    let surfaceID = globalThis.value;
622    avPlayer = await idle(src, avPlayer)
623    await setSource(avPlayer, src);
624    console.info('seekLoop setSource');
625    await sleep(20);
626    if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) {
627        avPlayer.surfaceId = surfaceID;
628        console.info('seekLoop case prepare success');
629        await preparePromise(avPlayer);
630        await sleep(2000);
631    }
632    await avPlayer.play().then(() => {
633        console.info('seekLoop play success');
634        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
635    }, (err) => {
636        console.error('seekLoop play filed,error message is :' + err.message)
637    })
638    await seekLoopWithCallback(avPlayer)
639    console.info('seekLoop avPlayer from play to seek')
640    // play seek loop 1000 times
641    await avPlayer.stop().then(() => {
642        console.info('seekLoopWithCallback avPlayer from play to stop')
643    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
644    await avPlayer.release().then(() => {
645        console.info('seekLoopWithCallback avPlayer from stop to release')
646        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
647        done();
648    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
649}
650
651async function seekLoopWithCallback(avPlayer) {
652    for (let loopTime = 0; loopTime < 5000; loopTime += 5) {
653        await new Promise(resolve => {
654            avPlayer.on('seekDone', seekDoneTime => {
655                console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`);
656                resolve();
657            });
658            avPlayer.seek(loopTime);
659            console.info(`case seekLoopWithCallback loopTime is ${loopTime}`);
660        });
661    }
662}
663
664async function seekLoopWithoutCallbackLoop(src, avPlayer, done) {
665    let seekLoopWithoutCallbackLoop = 0;
666    let surfaceID = globalThis.value;
667    console.info(`case seekLoopWithoutCallbackLoop in, surfaceID is ${surfaceID}`);
668    avPlayer.on('stateChange', async (state, reason) => {
669        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
670        console.info(`case state is ${state}`);
671        switch (state) {
672            case AV_PLAYER_STATE.INITIALIZED:
673                avPlayer.surfaceId = surfaceID;
674                console.info('seekLoopWithoutCallbackLoop play state is INITIALIZED')
675            // step 1: prepare
676                preparePromise(avPlayer);
677                break;
678            case AV_PLAYER_STATE.PREPARED:
679                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
680            // step 2: sop
681                avPlayer.play()
682                break;
683            case AV_PLAYER_STATE.PLAYING:
684                console.info('seekLoopWithoutCallbackLoop play state is PLAYING')
685                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
686            // step 5: PLAYING-IDLE
687                for(var loopTime = 0;loopTime < 1000; loopTime++){
688                    avPlayer.seek(loopTime)
689                    console.info(`case seekLoopWithoutCallbackLoop loopTime is ${loopTime}`);
690                    if(loopTime==999){
691                        avPlayer.stop().then(() => {
692                            console.info('seekLoopWithoutCallbackLoop avPlayer from play to stop')
693                            avPlayer.release().then(() => {
694                                console.info('seekLoopWithoutCallbackLoop avPlayer from stop to release')
695                                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
696                                done();
697                            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
698                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
699                    }
700                }
701                break;
702            case AV_PLAYER_STATE.ERROR:
703                expect().assertFail();
704                avPlayer.release().then(() => {
705                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
706                break;
707            default:
708                break;
709        }
710    });
711    avPlayer.on('error', async (err) => {
712        console.error(`case error called, errMessage is ${err.message}`);
713        expect().assertFail();
714        await avPlayer.release().then(() => {
715            avPlayer = null;
716            done();
717        });
718    });
719}
720
721export async function seekLoopWithoutCallback(src, avPlayer, done) {
722    avPlayer = await idle(src, avPlayer)
723    await seekLoopWithoutCallbackLoop(src, avPlayer, done)
724    await setSource(avPlayer, src);
725    console.info('seekLoopWithoutCallback setSource');
726}
727
728async function prepareToStopLoop(src, avPlayer, done) {
729    let prepareToStopLoopCount = 0;
730    let surfaceID = globalThis.value;
731    console.info(`case prepareToStopLoop in, surfaceID is ${surfaceID}`);
732    avPlayer.on('stateChange', async (state, reason) => {
733        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
734        console.info(`case state is ${state}`);
735        switch (state) {
736            case AV_PLAYER_STATE.INITIALIZED:
737                avPlayer.surfaceId = surfaceID;
738                console.info('prepareToStopLoop play state is INITIALIZED')
739            // step 1: prepare
740                preparePromise(avPlayer);
741                break;
742            case AV_PLAYER_STATE.PREPARED:
743                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
744            // step 2: sop
745                avPlayer.stop()
746                break;
747            case AV_PLAYER_STATE.STOPPED:
748                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
749                prepareToStopLoopCount++
750                if(prepareToStopLoopCount==1001){
751            // end: release
752                    avPlayer.release().then(() => {
753                        console.info('prepareToStopLoop avPlayer from stop to release')
754                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
755                        done();
756                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
757                }else {
758                    preparePromise(avPlayer);
759                }
760                break;
761            case AV_PLAYER_STATE.ERROR:
762                expect().assertFail();
763                avPlayer.release().then(() => {
764                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
765                break;
766            default:
767                break;
768        }
769    });
770    avPlayer.on('error', async (err) => {
771        console.error(`case error called, errMessage is ${err.message}`);
772        expect().assertFail();
773        await avPlayer.release().then(() => {
774            avPlayer = null;
775            done();
776        });
777    });
778}
779
780export async function prepareToStop(src, avPlayer, done) {
781    avPlayer = await idle(src, avPlayer)
782    await prepareToStopLoop(src, avPlayer, done)
783    setSource(avPlayer, src);
784    console.info('prepareToStopLoop setSource');
785}
786
787async function prepareToResetLoop(src, avPlayer, done) {
788    let prepareToResetLoopCount = 0;
789    let surfaceID = globalThis.value;
790    console.info(`case prepareToResetLoop in, surfaceID is ${surfaceID}`);
791    avPlayer.on('stateChange', async (state, reason) => {
792        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
793        console.info(`case state is ${state}`);
794        switch (state) {
795            // step 1: create-Idle
796            case AV_PLAYER_STATE.IDLE:
797                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
798                prepareToResetLoopCount++;
799                if(prepareToResetLoopCount == 1001){
800                    // end: release
801                    avPlayer.release().then(() => {
802                        console.info('prepareToResetLoop avPlayer from stop to release')
803                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
804                        done();
805                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
806                }else{
807            // step 2: idle-INITIALIZED
808                    setSource(avPlayer, src);
809                    console.info('prepareToResetLoop avPlayer from play to seek,time is :' + prepareToResetLoopCount)
810                }
811                break;
812            case AV_PLAYER_STATE.INITIALIZED:
813                avPlayer.surfaceId = surfaceID;
814                console.info('prepareToResetLoop play state is INITIALIZED')
815            // step 3: INITIALIZED-PREPARED
816                preparePromise(avPlayer);
817                break;
818            case AV_PLAYER_STATE.PREPARED:
819                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
820            // step 4: PREPARED-PLAYING
821                avPlayer.play()
822                break;
823            case AV_PLAYER_STATE.PLAYING:
824                console.info('prepareToResetLoop play state is PLAYING')
825                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
826            // step 5: PLAYING-IDLE
827                avPlayer.reset()
828                break;
829            case AV_PLAYER_STATE.ERROR:
830                expect().assertFail();
831                avPlayer.release().then(() => {
832                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
833                break;
834            default:
835                break;
836        }
837    });
838    avPlayer.on('error', async (err) => {
839        console.error(`case error called, errMessage is ${err.message}`);
840        expect().assertFail();
841        await avPlayer.release().then(() => {
842            avPlayer = null;
843            done();
844        });
845    });
846}
847
848export async function prepareToReset(src, avPlayer, done) {
849    avPlayer = await idle(src, avPlayer)
850    // url -> prepare -> play -> reset loop 1000 times
851    await prepareToResetLoop(src, avPlayer, done)
852    await setSource(avPlayer, src);
853}
854
855let createToReleaseLoopCount2 = 0;
856async function createToReleaseLoop2(src, avPlayer, done) {
857    let surfaceID = globalThis.value;
858    console.info(`case createToReleaseLoop2 in, surfaceID is ${surfaceID}`);
859    avPlayer.on('stateChange', async (state, reason) => {
860        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
861        console.info(`case state is ${state}`);
862        switch (state) {
863            case AV_PLAYER_STATE.IDLE:
864                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
865                setSource(avPlayer, src);
866                break;
867            case AV_PLAYER_STATE.INITIALIZED:
868                avPlayer.surfaceId = surfaceID;
869                console.info('createToReleaseLoop2 play state is INITIALIZED')
870                preparePromise(avPlayer);
871                break;
872            case AV_PLAYER_STATE.PREPARED:
873                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
874            // step 4: PREPARED-PLAYING
875                avPlayer.play()
876                break;
877            case AV_PLAYER_STATE.PLAYING:
878                console.info('createToReleaseLoop2 play state is PLAYING')
879                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
880                avPlayer.release()
881                break;
882            case AV_PLAYER_STATE.RELEASED:
883                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
884                createToReleaseLoopCount2++
885                if(createToReleaseLoopCount2==1001){
886                    done();
887                }else{
888                    avPlayer = await idle(src, avPlayer)
889                    await createToReleaseLoop2(src, avPlayer, done)
890                    await setSource(avPlayer, src);
891                }
892                break;
893            case AV_PLAYER_STATE.ERROR:
894                expect().assertFail();
895                avPlayer.release().then(() => {
896                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
897                break;
898            default:
899                break;
900        }
901    });
902    avPlayer.on('error', async (err) => {
903        console.error(`case error called, errMessage is ${err.message}`);
904        expect().assertFail();
905        await avPlayer.release().then(() => {
906            avPlayer = null;
907            done();
908        });
909    });
910}
911
912export async function createToRelease2(src, avPlayer, done) {
913    avPlayer = await idle(src, avPlayer)
914    await createToReleaseLoop2(src, avPlayer, done)
915    await setSource(avPlayer, src);
916    console.info('createToRelease2 setSource');
917}
918
919let createLoopTime = 0;
920let createTotalTime = 0;
921let createStart;
922export async function createTimeWithCallback(src, avPlayer, done) {
923    avPlayer = await idle(src, avPlayer)
924    createStart = Date.now();
925    console.info(`createTimeWithCallback createStart time is : ${createStart}`)
926    createTimeCallback(src, avPlayer, done)
927}
928
929function createTimeCallback(src, avPlayer, done){
930    let end;
931    let execution;
932    avPlayer.on('stateChange', async (state, reason) => {
933        console.info(`createTimeCallback stateChange called, state is ${state}, reason is ${reason}`);
934        console.info(`createTimeCallback state is ${state}`);
935        switch (state) {
936            case AV_PLAYER_STATE.IDLE:
937                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
938                end = Date.now();
939                console.info(`createTimeCallback end time is : ${end}`)
940                execution = parseInt(end - createStart)
941                createTotalTime = createTotalTime + execution;
942                console.info("createTimeCallback execution time  is :" + execution)
943                createLoopTime++;
944                avPlayer.release()
945            case AV_PLAYER_STATE.RELEASED:
946                console.info('createTimeCallback play state is release')
947                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
948                if(createLoopTime == 10){
949                    let avg = createTotalTime/10;
950                    console.info("createTimeCallback avg time  is :" + avg)
951                    createLoopTime = 0;
952                    createTotalTime = 0;
953                    done();
954                }else{
955                    avPlayer = null;
956                    createTimeWithCallback(src, avPlayer, done)
957                }
958                break;
959            default:
960                break;
961        }
962    });
963}
964
965export async function createTimeWithoutCallback(src, avPlayer, done) {
966    let totalTime = 0;
967    for(var i = 0;i < 10;i++){
968        let start = Date.now();
969        console.info(`createTimeWithoutCallback start time is : ${start}`)
970        avPlayer = await idle(src, avPlayer)
971        let end = Date.now()
972        let execution = parseInt(end - start)
973        console.info("createTimeWithoutCallback execution time  is :" + execution)
974        totalTime = totalTime + execution;
975        await avPlayer.release().then(() => {
976            console.info('createTimeWithoutCallback avPlayer is release')
977            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
978        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
979    }
980    let avg = totalTime/10;
981    console.info("createTimeWithoutCallback avg time  is :" + avg)
982    done();
983}
984
985export async function prepareTimeWithoutCallback(src, avPlayer, done) {
986    let totalTime = 0;
987    let surfaceID = globalThis.value;
988    for(var i = 0;i < 10;i++){
989        avPlayer = await idle(src, avPlayer)
990        await setSource(avPlayer, src);
991        console.info('prepareTimeWithoutCallback setSource');
992        await sleep(20)
993        avPlayer.surfaceId = surfaceID;
994        let start = Date.now();
995        console.info(`prepareTimeWithoutCallback start time is : ${start}`)
996        let end;
997        await avPlayer.prepare().then(() => {
998            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
999            console.info('prepareTimeWithoutCallback avPlayer state is prepared')
1000            end = Date.now()
1001            console.info(`prepareTimeWithoutCallback end time is : ${end}`)
1002        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1003        let execution = parseInt(end - start)
1004        console.info("prepareTimeWithoutCallback execution time  is :" + execution)
1005        totalTime = totalTime + execution;
1006        await avPlayer.release().then(() => {
1007            console.info('prepareTimeWithoutCallback avPlayer is release')
1008            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1009        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1010    }
1011    let avg = totalTime/10;
1012    console.info("prepareTimeWithoutCallback avg time  is :" + avg)
1013    done();
1014}
1015
1016export async function prepareTimeWithCallback(src, avPlayer, done) {
1017    avPlayer = await idle(src, avPlayer)
1018    await prepareTimeCallback(src, avPlayer, done)
1019    await setSource(avPlayer, src);
1020}
1021
1022async function prepareTimeCallback(src, avPlayer, done) {
1023    let surfaceID = globalThis.value;
1024    let start;
1025    let end;
1026    let execution;
1027    let loopTime = 0;
1028    let totalTime = 0;
1029    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1030    avPlayer.on('stateChange', async (state, reason) => {
1031        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1032        console.info(`case state is ${state}`);
1033        switch (state) {
1034            case AV_PLAYER_STATE.IDLE:
1035                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
1036                if(loopTime == 10){
1037                    avPlayer.release().then(() => {
1038                        console.info('prepareTimeWithCallback avPlayer is release')
1039                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1040                        avPlayer = null;
1041                        let avg = totalTime/10;
1042                        console.info("prepareTimeWithCallback avg time is :" + avg)
1043                        done();
1044                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1045                }else{
1046                    setSource(avPlayer, src)
1047                }
1048            case AV_PLAYER_STATE.INITIALIZED:
1049                avPlayer.surfaceId = surfaceID;
1050                console.info('prepareTimeWithCallback play state is INITIALIZED')
1051            // step 1: initialized -> prepared
1052                start = Date.now();
1053                console.info(`prepareTimeWithCallback start time is : ${start}`)
1054                avPlayer.prepare()
1055                break;
1056            case AV_PLAYER_STATE.PREPARED:
1057                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1058                console.info('prepareTimeWithCallback avPlayer state is prepared')
1059                end = Date.now();
1060                console.info(`prepareTimeWithCallback end time is : ${end}`)
1061                execution = parseInt(end - start)
1062                console.info("prepareTimeWithCallback execution time  is :" + execution)
1063                totalTime = totalTime + execution;
1064                loopTime++;
1065                avPlayer.reset()
1066                break;
1067            default:
1068                break;
1069        }
1070    });
1071}
1072
1073export async function playTimeWithoutCallback(src, avPlayer, done) {
1074    let totalTime = 0;
1075    let surfaceID = globalThis.value;
1076    for(var i = 0;i < 10;i++){
1077        avPlayer = await idle(src, avPlayer)
1078        await setSource(avPlayer, src);
1079        console.info('playTimeWithoutCallback setSource');
1080        await sleep(20)
1081        avPlayer.surfaceId = surfaceID;
1082        await avPlayer.prepare().then(() => {
1083            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1084            console.info('playTimeWithoutCallback avPlayer state is prepared')
1085        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1086        let start = Date.now();
1087        let end;
1088        console.info(`playTimeWithoutCallback start time is : ${start}`)
1089        await avPlayer.play().then(() => {
1090            end = Date.now();
1091            console.info(`playTimeWithoutCallback end time is : ${end}`)
1092            console.info('playTimeWithoutCallback play success');
1093            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1094        }, (err) => {
1095            console.error('playTimeWithoutCallback play filed,error message is :' + err.message)
1096        })
1097        let execution = parseInt(end - start)
1098        console.info("playTimeWithoutCallback execution time  is :" + execution)
1099        totalTime = totalTime + execution;
1100        await avPlayer.release().then(() => {
1101            console.info('playTimeWithoutCallback avPlayer is release')
1102            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1103            avPlayer = null;
1104        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1105    }
1106    let avg = totalTime/10;
1107    console.info("playTimeWithoutCallback avg time  is :" + avg)
1108    done();
1109}
1110
1111export async function playTimeWithCallback(src, avPlayer, done) {
1112    avPlayer = await idle(src, avPlayer)
1113    await playTimeCallback(avPlayer, done)
1114    await setSource(avPlayer, src);
1115}
1116
1117export function playTimeCallback(avPlayer, done) {
1118    let surfaceID = globalThis.value;
1119    let start;
1120    let end;
1121    let execution;
1122    let loopTime = 0;
1123    let totalTime = 0;
1124    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1125    avPlayer.on('stateChange', async (state, reason) => {
1126        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1127        console.info(`case state is ${state}`);
1128        switch (state) {
1129            case AV_PLAYER_STATE.INITIALIZED:
1130                avPlayer.surfaceId = surfaceID;
1131                console.info('playTimeCallback play state is INITIALIZED')
1132            // step 1: initialized -> prepared
1133                avPlayer.prepare((err) => {
1134                    if (err != null) {
1135                        console.error(`case prepare error, errMessage is ${err.message}`);
1136                        expect().assertFail();
1137                        done();
1138                    } else {
1139                        console.info('playTimeCallback play state is prepared')
1140                    }
1141                });
1142                break;
1143            case AV_PLAYER_STATE.PREPARED:
1144                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1145                console.info('playTimeCallback avPlayer state is prepared')
1146                start = Date.now();
1147                console.info(`playTimeCallback start time is : ${start}`)
1148            // step 2: prapared -> play
1149                avPlayer.play()
1150                break;
1151            case AV_PLAYER_STATE.PLAYING:
1152                console.info('playTimeCallback play state is PLAYING')
1153                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1154                end = Date.now();
1155                console.info(`playTimeCallback end time is : ${end}`)
1156                execution = parseInt(end - start)
1157                console.info("playTimeCallback execution time  is :" + execution)
1158                totalTime = totalTime + execution;
1159                loopTime++;
1160                if(loopTime == 10){
1161                    avPlayer.release().then(() => {
1162                        console.info('playTimeCallback avPlayer is release')
1163                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1164                        avPlayer = null;
1165                        let avg = totalTime/10;
1166                        console.info("playTimeWithCallback avg time is :" + avg)
1167                        done();
1168                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1169                }else{
1170            // step 3: playing -> pause loop
1171                    setTimeout( () => {
1172                        avPlayer.pause()
1173                    }, 200);
1174                }
1175                break;
1176            case AV_PLAYER_STATE.PAUSED:
1177                console.info('playTimeWithCallback play state is PAUSED')
1178                expect(avPlayer.state).assertEqual('paused');
1179                start = Date.now();
1180                console.info(`playTimeCallback start time is : ${start}`)
1181                avPlayer.play()
1182                break;
1183            default:
1184                break;
1185        }
1186    });
1187}
1188
1189export async function pauseTimeWithoutCallback(src, avPlayer, done) {
1190    let totalTime = 0;
1191    let surfaceID = globalThis.value;
1192    for(var i = 0;i < 10;i++){
1193        let execution;
1194        let end;
1195        avPlayer = await idle(src, avPlayer)
1196        await setSource(avPlayer, src);
1197        console.info('pauseTimeWithoutCallback setSource');
1198        await sleep(20)
1199        avPlayer.surfaceId = surfaceID;
1200        await avPlayer.prepare().then(() => {
1201            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1202            console.info('pauseTimeWithoutCallback avPlayer state is prepared')
1203        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1204        await avPlayer.play().then(() => {
1205            console.info('pauseTimeWithoutCallback play success');
1206            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1207        }, (err) => {
1208            console.error('pauseTimeWithoutCallback play filed,error message is :' + err.message)
1209        })
1210        let start = Date.now();
1211
1212        console.info(`pauseTimeWithoutCallback start time is : ${start}`)
1213        await avPlayer.pause().then(() => {
1214            console.info('pauseTimeWithoutCallback pause success');
1215            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
1216            end = Date.now();
1217            console.info(`pauseTimeWithoutCallback end time is : ${end}`)
1218            execution = parseInt(end - start)
1219            console.info("pauseTimeWithoutCallback execution time  is :" + execution)
1220        }, (err) => {
1221            console.error('pauseTimeWithoutCallback pause filed,error message is :' + err.message)
1222        })
1223        totalTime = totalTime + execution;
1224        await avPlayer.release().then(() => {
1225            console.info('pauseTimeWithoutCallback avPlayer is release')
1226            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1227        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1228    }
1229    let avg = totalTime/10;
1230    console.info("pauseTimeWithoutCallback avg time  is :" + avg)
1231    done();
1232}
1233
1234export async function pauseTimeWithCallback(src, avPlayer, done) {
1235    avPlayer = await idle(src, avPlayer)
1236    await pauseTimeCallback(avPlayer, done)
1237    await setSource(avPlayer, src);
1238}
1239
1240function pauseTimeCallback(avPlayer, done) {
1241    let surfaceID = globalThis.value;
1242    let start;
1243    let end;
1244    let execution;
1245    let loopTime = 0;
1246    let totalTime = 0;
1247    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1248    avPlayer.on('stateChange', async (state, reason) => {
1249        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1250        console.info(`case state is ${state}`);
1251        switch (state) {
1252            case AV_PLAYER_STATE.INITIALIZED:
1253                avPlayer.surfaceId = surfaceID;
1254                console.info('pauseTimeCallback play state is INITIALIZED')
1255            // step 1: initialized -> prepared
1256                avPlayer.prepare((err) => {
1257                    if (err != null) {
1258                        console.error(`case prepare error, errMessage is ${err.message}`);
1259                        expect().assertFail();
1260                        done();
1261                    } else {
1262                        console.info('pauseTimeCallback play state is prepared')
1263                    }
1264                });
1265                break;
1266            case AV_PLAYER_STATE.PREPARED:
1267                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1268                console.info('pauseTimeCallback avPlayer state is prepared')
1269                avPlayer.play()
1270                break;
1271            case AV_PLAYER_STATE.PLAYING:
1272                console.info('pauseTimeCallback play state is PLAYING')
1273                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1274                setTimeout( () => {
1275                    start = Date.now();
1276                    console.info(`pauseTimeCallback start time is : ${start}`)
1277                    avPlayer.pause()
1278                }, 200);
1279                break;
1280            case AV_PLAYER_STATE.PAUSED:
1281                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
1282                end = Date.now();
1283                console.info(`pauseTimeCallback end time is : ${end}`)
1284                execution = parseInt(end - start)
1285                console.info("pauseTimeCallback execution time  is :" + execution)
1286                totalTime = totalTime + execution;
1287                loopTime++;
1288                if(loopTime == 10){
1289                    avPlayer.release().then(() => {
1290                        console.info('pauseTimeCallback avPlayer is release')
1291                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1292                        avPlayer = null;
1293                        let avg = totalTime/10;
1294                        console.info("pauseTimeCallback avg time is :" + avg)
1295                        done();
1296                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1297                }else{
1298                    avPlayer.play()
1299                }
1300                break;
1301            default:
1302                break;
1303        }
1304    });
1305}
1306
1307export async function stopTimeWithoutCallback(src, avPlayer, done) {
1308    let totalTime = 0;
1309    let surfaceID = globalThis.value;
1310    for(var i = 0;i < 10;i++){
1311        avPlayer = await idle(src, avPlayer)
1312        await setSource(avPlayer, src);
1313        console.info('stopTimeWithoutCallback setSource');
1314        await sleep(20)
1315        avPlayer.surfaceId = surfaceID;
1316        await avPlayer.prepare().then(() => {
1317            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1318            console.info('stopTimeWithoutCallback avPlayer state is prepared')
1319        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1320        await avPlayer.play().then(() => {
1321            console.info('stopTimeWithoutCallback play success');
1322            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1323        }, (err) => {
1324            console.error('stopTimeWithoutCallback play filed,error message is :' + err.message)
1325        })
1326        let start = Date.now();
1327        console.info(`stopTimeWithoutCallback start time is : ${start}`)
1328        let end;
1329        await avPlayer.stop().then(() => {
1330            end = Date.now();
1331            console.info(`stopTimeWithoutCallback end time is : ${end}`)
1332            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
1333            console.info('stopTimeWithoutCallback avPlayer state is stop')
1334        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1335        let execution = parseInt(end - start)
1336        console.info("stopTimeWithoutCallback execution time  is :" + execution)
1337        totalTime = totalTime + execution;
1338        await avPlayer.release().then(() => {
1339            console.info('stopTimeWithoutCallback avPlayer is release')
1340            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1341        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1342    }
1343    let avg = totalTime/10;
1344    console.info("stopTimeWithoutCallback avg time  is :" + avg)
1345    done();
1346}
1347
1348export async function stopTimeWithCallback(src, avPlayer, done) {
1349    avPlayer = await idle(src, avPlayer)
1350    await stopTimeCallback(src, avPlayer, done)
1351    await setSource(avPlayer, src);
1352}
1353
1354function stopTimeCallback(src, avPlayer, done) {
1355    let surfaceID = globalThis.value;
1356    let start;
1357    let end;
1358    let execution;
1359    let loopTime = 0;
1360    let totalTime = 0;
1361    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1362    avPlayer.on('stateChange', async (state, reason) => {
1363        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1364        console.info(`case state is ${state}`);
1365        switch (state) {
1366            case AV_PLAYER_STATE.IDLE:
1367                setSource(avPlayer, src);
1368                break;
1369            case AV_PLAYER_STATE.INITIALIZED:
1370                avPlayer.surfaceId = surfaceID;
1371                console.info('stopTimeCallback play state is INITIALIZED')
1372            // step 1: initialized -> prepared
1373                avPlayer.prepare((err) => {
1374                    if (err != null) {
1375                        console.error(`case prepare error, errMessage is ${err.message}`);
1376                        expect().assertFail();
1377                        done();
1378                    } else {
1379                        console.info('stopTimeCallback play state is prepared')
1380                    }
1381                });
1382                break;
1383            case AV_PLAYER_STATE.PREPARED:
1384                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1385                console.info('stopTimeCallback avPlayer state is prepared')
1386                start = Date.now();
1387                console.info(`stopTimeCallback start time is : ${start}`)
1388                loopTime++;
1389                avPlayer.stop()
1390                break;
1391            case AV_PLAYER_STATE.STOPPED:
1392                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
1393                end = Date.now();
1394                console.info(`stopTimeCallback end time is : ${end}`)
1395                execution = parseInt(end - start)
1396                console.info("stopTimeCallback execution time  is :" + execution)
1397                totalTime = totalTime + execution;
1398                if(loopTime == 10){
1399                    avPlayer.release().then(() => {
1400                        console.info('stopTimeCallback avPlayer is release')
1401                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1402                        avPlayer = null;
1403                        let avg = totalTime/10;
1404                        console.info("stopTimeCallback avg time is :" + avg)
1405                        done();
1406                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1407                }else{
1408                    avPlayer.reset()
1409                }
1410                break;
1411            default:
1412                break;
1413        }
1414    });
1415}
1416
1417export async function resetTimeWithoutCallback(src, avPlayer, done) {
1418    let totalTime = 0;
1419    let surfaceID = globalThis.value;
1420    for(var i = 0;i < 10;i++){
1421        avPlayer = await idle(src, avPlayer)
1422        await setSource(avPlayer, src);
1423        console.info('resetTimeWithoutCallback setSource');
1424        await sleep(20)
1425        avPlayer.surfaceId = surfaceID;
1426        await avPlayer.prepare().then(() => {
1427            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1428            console.info('resetTimeWithoutCallback avPlayer state is prepared')
1429        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1430        let end;
1431        await avPlayer.play().then(() => {
1432            console.info('resetTimeWithoutCallback play success');
1433            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1434        }, (err) => {
1435            console.error('resetTimeWithoutCallback play filed,error message is :' + err.message)
1436        })
1437        let start = Date.now();
1438        console.info(`resetTimeWithoutCallback start time is : ${start}`)
1439        await avPlayer.reset().then(() => {
1440            end = Date.now();
1441            console.info(`resetTimeWithoutCallback end time is : ${end}`)
1442            console.info('reset success');
1443            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
1444        }, (err) => {
1445            console.error('reset filed,error message is :' + err.message)
1446        })
1447        let execution = parseInt(end - start)
1448        console.info("resetTimeWithoutCallback execution time  is :" + execution)
1449        totalTime = totalTime + execution;
1450        await avPlayer.release().then(() => {
1451            console.info('resetTimeWithoutCallback avPlayer is release')
1452            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1453        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1454    }
1455    let avg = totalTime/10;
1456    console.info("resetTimeWithoutCallback avg time  is :" + avg)
1457    done();
1458}
1459
1460export async function resetTimeWithCallback(src, avPlayer, done) {
1461    avPlayer = await idle(src, avPlayer)
1462    await resetTimeCallback(src, avPlayer, done)
1463    await setSource(avPlayer, src);
1464}
1465
1466function resetTimeCallback(src, avPlayer, done) {
1467    let surfaceID = globalThis.value;
1468    let start;
1469    let end;
1470    let execution;
1471    let loopTime = 0;
1472    let totalTime = 0;
1473    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1474    avPlayer.on('stateChange', async (state, reason) => {
1475        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1476        console.info(`case state is ${state}`);
1477        switch (state) {
1478            case AV_PLAYER_STATE.IDLE:
1479                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
1480                end = Date.now();
1481                console.info(`resetTimeCallback end time is : ${end}`)
1482                execution = parseInt(end - start)
1483                console.info("resetTimeCallback execution time  is :" + execution)
1484                totalTime = totalTime + execution;
1485                loopTime++;
1486                if(loopTime == 10){
1487                    avPlayer.release().then(() => {
1488                        console.info('resetTimeCallback avPlayer is release')
1489                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1490                        avPlayer = null;
1491                        let avg = totalTime/10;
1492                        console.info("resetTimeCallback avg time is :" + avg)
1493                        done();
1494                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1495                }else{
1496                    setSource(avPlayer, src)
1497                }
1498                break;
1499            case AV_PLAYER_STATE.INITIALIZED:
1500                avPlayer.surfaceId = surfaceID;
1501                console.info('resetTimeCallback play state is INITIALIZED')
1502                start = Date.now();
1503                console.info(`resetTimeCallback start time is : ${start}`)
1504                avPlayer.reset().then(() => {
1505                    console.info('reset success');
1506                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1507                break;
1508            default:
1509                break;
1510        }
1511    });
1512}
1513
1514export async function releaseTimeWithoutCallback(src, avPlayer, done) {
1515    let totalTime = 0;
1516    let surfaceID = globalThis.value;
1517    for(var i = 0;i < 10;i++){
1518        avPlayer = await idle(src, avPlayer)
1519        await setSource(avPlayer, src);
1520        console.info('releaseTimeWithoutCallback setSource');
1521        await sleep(20)
1522        avPlayer.surfaceId = surfaceID;
1523        let start = Date.now();
1524        console.info(`releaseTimeWithoutCallback start time is : ${start}`)
1525        let end;
1526        await avPlayer.release().then(() => {
1527            console.info('releaseTimeWithoutCallback avPlayer is release')
1528            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1529        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1530        end = Date.now();
1531        console.info(`releaseTimeWithoutCallback end time is : ${end}`)
1532        let execution = parseInt(end - start)
1533        console.info("releaseTimeWithoutCallback execution time  is :" + execution)
1534        totalTime = totalTime + execution;
1535    }
1536    let avg = totalTime/10;
1537    console.info("releaseTimeWithoutCallback avg time  is :" + avg)
1538    done();
1539}
1540
1541let releaseTotalTime = 0;
1542let releaseLoop = 0;
1543export async function releaseTimeWithCallback(src, avPlayer, done) {
1544    avPlayer = await idle(src, avPlayer)
1545    await releaseTimeCallback(src, avPlayer, done)
1546    await setSource(avPlayer, src);
1547}
1548
1549function releaseTimeCallback(src, avPlayer, done) {
1550    let surfaceID = globalThis.value;
1551    let start;
1552    let end;
1553    let execution;
1554    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1555    avPlayer.on('stateChange', async (state, reason) => {
1556        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1557        console.info(`case state is ${state}`);
1558        switch (state) {
1559            case AV_PLAYER_STATE.INITIALIZED:
1560                avPlayer.surfaceId = surfaceID;
1561                console.info('releaseTimeCallback play state is INITIALIZED')
1562                start = Date.now();
1563                console.info(`releaseTimeCallback start time is : ${start}`)
1564                avPlayer.release()
1565                break;
1566            case AV_PLAYER_STATE.RELEASED:
1567                console.info('releaseTimeCallback play state is release')
1568                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1569                end = Date.now();
1570                console.info(`releaseTimeCallback end time is : ${end}`)
1571                execution = parseInt(end - start)
1572                console.info("releaseTimeCallback execution time  is :" + execution)
1573                releaseTotalTime = releaseTotalTime + execution;
1574                releaseLoop++;
1575                if(releaseLoop == 10){
1576                    let avg = releaseTotalTime/10;
1577                    console.info("releaseTimeCallback avg time  is :" + avg)
1578                    releaseTotalTime = 0;
1579                    releaseLoop = 0;
1580                    done();
1581                }else{
1582                    avPlayer = null;
1583                    releaseTimeWithCallback(src, avPlayer, done)
1584                }
1585                break;
1586            default:
1587                break;
1588        }
1589    });
1590}
1591
1592export function getTotalTime(releaseTotalTime){
1593    return releaseTotalTime;
1594}
1595
1596export async function seekTimeWithoutCallback(src, avPlayer, done) {
1597    let totalTime = 0;
1598    let surfaceID = globalThis.value;
1599    for(var i = 0;i < 10;i++){
1600        avPlayer = await idle(src, avPlayer)
1601        await setSource(avPlayer, src);
1602        console.info('seekTimeWithoutCallback setSource');
1603        await sleep(20)
1604        avPlayer.surfaceId = surfaceID;
1605        await avPlayer.prepare().then(() => {
1606            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1607            console.info('seekTimeWithoutCallback avPlayer state is prepared')
1608        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1609        let end;
1610        await avPlayer.play().then(() => {
1611            console.info('seekTimeWithoutCallback play success');
1612            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1613        }, (err) => {
1614            console.error('seekTimeWithoutCallback play filed,error message is :' + err.message)
1615        })
1616        let start = Date.now();
1617        console.info(`seekTimeWithoutCallback start time is : ${start}`)
1618        await avPlayer.seek(100)
1619        end = Date.now();
1620        console.info(`seekTimeWithoutCallback end time is : ${end}`)
1621        let execution = parseInt(end - start)
1622        console.info("seekTimeWithoutCallback execution time  is :" + execution)
1623        totalTime = totalTime + execution;
1624        await avPlayer.release().then(() => {
1625            console.info('seekTimeWithoutCallback avPlayer is release')
1626            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1627        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1628    }
1629    let avg = totalTime/10;
1630    console.info("seekTimeWithoutCallback avg time  is :" + avg)
1631    done();
1632}
1633
1634export async function seekTimeWithCallback(src, avPlayer, done) {
1635    avPlayer = await idle(src, avPlayer)
1636    await seekTimeCallback(avPlayer, done)
1637    await setSource(avPlayer, src);
1638}
1639
1640function seekTimeCallback(avPlayer, done) {
1641    let surfaceID = globalThis.value;
1642    let start;
1643    let end;
1644    let execution;
1645    let loopTime = 0;
1646    let totalTime = 0;
1647    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1648    avPlayer.on('stateChange', async (state, reason) => {
1649        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1650        console.info(`case state is ${state}`);
1651        switch (state) {
1652            case AV_PLAYER_STATE.INITIALIZED:
1653                avPlayer.surfaceId = surfaceID;
1654                console.info('seekTimeCallback play state is INITIALIZED')
1655                avPlayer.prepare((err) => {
1656                    if (err != null) {
1657                        console.error(`case prepare error, errMessage is ${err.message}`);
1658                        expect().assertFail();
1659                        done();
1660                    } else {
1661                        console.info('seekTimeCallback play state is prepared')
1662                    }
1663                });
1664                break;
1665            case AV_PLAYER_STATE.PREPARED:
1666                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1667                console.info('seekTimeCallback avPlayer state is prepared')
1668                avPlayer.play()
1669                break;
1670            case AV_PLAYER_STATE.PLAYING:
1671                console.info('seekTimeCallback play state is PLAYING')
1672                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1673                start = Date.now();
1674                console.info(`seekTimeCallback start time is : ${start}`)
1675                loopTime+=20;
1676                if(loopTime == 220){
1677                    avPlayer.release().then(() => {
1678                        console.info('seekTimeCallback avPlayer is release')
1679                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1680                        avPlayer = null;
1681                        let avg = totalTime/10;
1682                        console.info("seekTimeCallback avg time is :" + avg)
1683                        done();
1684                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1685                }else{
1686                    avPlayer.seek(loopTime)
1687                }
1688                break;
1689            case AV_PLAYER_STATE.PAUSED:
1690                console.info('seekTimeCallback play state is PAUSED')
1691                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
1692                avPlayer.play().then(() => {
1693                    console.info('seekTimeCallback avPlayer from pause to play')
1694                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1695                break;
1696            default:
1697                break;
1698        }
1699    });
1700    avPlayer.on('seekDone', async (seekDoneTime) => {
1701        end = Date.now();
1702        console.info(`seekTimeCallback end time is : ${end}`)
1703        execution = parseInt(end - start)
1704        console.info("seekTimeCallback execution time  is :" + execution)
1705        totalTime = totalTime + execution;
1706        console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`);
1707        avPlayer.pause()
1708    });
1709}
1710
1711export async function getTrackDescriptionTimeWithoutCallback(src, avPlayer, done) {
1712    let totalTime = 0;
1713    let surfaceID = globalThis.value;
1714    for(var i = 0;i < 10;i++){
1715        avPlayer = await idle(src, avPlayer)
1716        await setSource(avPlayer, src);
1717        console.info('getTrackDescriptionTimeWithoutCallback setSource');
1718        await sleep(20)
1719        avPlayer.surfaceId = surfaceID;
1720        await avPlayer.prepare().then(() => {
1721            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1722            console.info('getTrackDescriptionTimeWithoutCallback avPlayer state is prepared')
1723        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1724        await avPlayer.play().then(() => {
1725            console.info('getTrackDescriptionTimeWithoutCallback play success');
1726            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1727        }, (err) => {
1728            console.error('getTrackDescriptionTimeWithoutCallback play filed,error message is :' + err.message)
1729        })
1730        let arrayDescription;
1731        let start = Date.now();
1732        console.info(`getTrackDescriptionTimeWithoutCallback start time is : ${start}`)
1733        let end;
1734        await avPlayer.getTrackDescription().then((arrList) => {
1735            if (arrList != null) {
1736                arrayDescription = arrList;
1737            } else {
1738                console.log('video getTrackDescription fail');
1739            }
1740        }).catch((error) => {
1741            console.info(`video catchCallback, error:${error}`);
1742        });
1743        end = Date.now();
1744        console.info(`getTrackDescriptionTimeWithoutCallback end time is : ${end}`)
1745        let execution = parseInt(end - start)
1746        console.info("getTrackDescriptionTimeWithoutCallback execution time  is :" + execution)
1747        totalTime = totalTime + execution;
1748        await avPlayer.release().then(() => {
1749            console.info('getTrackDescriptionTimeWithoutCallback avPlayer is release')
1750            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1751        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1752    }
1753    let avg = totalTime/10;
1754    console.info("getTrackDescriptionTimeWithoutCallback avg time  is :" + avg)
1755    done();
1756}
1757
1758export async function getTrackDescriptionTimeWithCallback(src, avPlayer, done) {
1759    avPlayer = await idle(src, avPlayer)
1760    await getTrackDescriptionTimeCallback(avPlayer, done)
1761    await setSource(avPlayer, src);
1762}
1763
1764function getTrackDescriptionTimeCallback(avPlayer, done) {
1765    let surfaceID = globalThis.value;
1766    let start;
1767    let end;
1768    let execution;
1769    let loopTime = 0;
1770    let totalTime = 0;
1771    let arrayDescription;
1772    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1773    avPlayer.on('stateChange', async (state, reason) => {
1774        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1775        console.info(`case state is ${state}`);
1776        switch (state) {
1777            case AV_PLAYER_STATE.INITIALIZED:
1778                avPlayer.surfaceId = surfaceID;
1779                console.info('getTrackDescriptionTimeCallback play state is INITIALIZED')
1780                avPlayer.prepare((err) => {
1781                    if (err != null) {
1782                        console.error(`case prepare error, errMessage is ${err.message}`);
1783                        expect().assertFail();
1784                        done();
1785                    } else {
1786                        console.info('getTrackDescriptionTimeCallback play state is prepared')
1787                    }
1788                });
1789                break;
1790            case AV_PLAYER_STATE.PREPARED:
1791                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1792                console.info('getTrackDescriptionTimeCallback avPlayer state is prepared')
1793                avPlayer.play()
1794                break;
1795            case AV_PLAYER_STATE.PLAYING:
1796                console.info('getTrackDescriptionTimeCallback play state is PLAYING')
1797                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1798                start = Date.now();
1799                console.info(`getTrackDescriptionTimeCallback start time is : ${start}`)
1800                if(loopTime == 10){
1801                    avPlayer.release().then(() => {
1802                        console.info('getTrackDescriptionTimeCallback avPlayer is release')
1803                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1804                        avPlayer = null;
1805                        let avg = totalTime/10;
1806                        console.info("getTrackDescriptionTimeCallback avg time is :" + avg)
1807                        done();
1808                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1809                }else{
1810                    loopTime++;
1811                    avPlayer.getTrackDescription().then((arrList) => {
1812                        if (arrList != null) {
1813                            arrayDescription = arrList;
1814                            end = Date.now();
1815                            console.info(`getTrackDescriptionTimeCallback end time is : ${end}`)
1816                            execution = parseInt(end - start)
1817                            console.info("getTrackDescriptionTimeCallback execution time  is :" + execution)
1818                            totalTime = totalTime + execution;
1819
1820                        } else {
1821                            console.log('video getTrackDescription fail');
1822                        }
1823                    }).catch((error) => {
1824                        console.info(`video catchCallback, error:${error}`);
1825                    });
1826                    setTimeout( () => {
1827                        avPlayer.pause()
1828                    }, 200);
1829                }
1830                break;
1831            case AV_PLAYER_STATE.PAUSED:
1832                console.info('getTrackDescriptionTimeCallback play state is PAUSED')
1833                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
1834                avPlayer.play().then(() => {
1835                    console.info('getTrackDescriptionTimeCallback avPlayer from pause to play')
1836                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1837                break;
1838            default:
1839                break;
1840        }
1841    });
1842}
1843
1844export async function setSpeedTimeWithoutCallback(src, avPlayer, done) {
1845    let totalTime = 0;
1846    let surfaceID = globalThis.value;
1847    for(var i = 0;i < 10;i++){
1848        avPlayer = await idle(src, avPlayer)
1849        await setSource(avPlayer, src);
1850        console.info('setSpeedTimeWithoutCallback setSource');
1851        await sleep(20)
1852        avPlayer.surfaceId = surfaceID;
1853        await avPlayer.prepare().then(() => {
1854            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1855            console.info('setSpeedTimeWithoutCallback avPlayer state is prepared')
1856        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1857        let start = Date.now();
1858        console.info(`setSpeedTimeWithoutCallback start time is : ${start}`)
1859        await avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
1860        let end = Date.now();
1861        console.info(`setSpeedTimeWithoutCallback end time is : ${end}`)
1862        let execution = parseInt(end - start)
1863        console.info("setSpeedTimeWithoutCallback execution time  is :" + execution)
1864        totalTime = totalTime + execution;
1865        await avPlayer.release().then(() => {
1866            console.info('setSpeedTimeWithoutCallback avPlayer is release')
1867            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1868        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1869    }
1870    let avg = totalTime/10;
1871    console.info("setSpeedTimeWithoutCallback avg time  is :" + avg)
1872    done();
1873}
1874
1875export async function setSpeedTimeWithCallback(src, avPlayer, done) {
1876    avPlayer = await idle(src, avPlayer)
1877    await setSpeedTimeCallback(avPlayer, done)
1878    await setSource(avPlayer, src);
1879}
1880
1881function setSpeedTimeCallback(avPlayer, done) {
1882    let surfaceID = globalThis.value;
1883    let start;
1884    let end;
1885    let execution;
1886    let loopTime = 0;
1887    let totalTime = 0;
1888    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
1889    avPlayer.on('stateChange', async (state, reason) => {
1890        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
1891        console.info(`case state is ${state}`);
1892        switch (state) {
1893            case AV_PLAYER_STATE.INITIALIZED:
1894                avPlayer.surfaceId = surfaceID;
1895                console.info('setSpeedTimeCallback play state is INITIALIZED')
1896            // step 1: initialized -> prepared
1897                avPlayer.prepare((err) => {
1898                    if (err != null) {
1899                        console.error(`case prepare error, errMessage is ${err.message}`);
1900                        expect().assertFail();
1901                        done();
1902                    } else {
1903                        console.info('setSpeedTimeCallback play state is prepared')
1904                    }
1905                });
1906                break;
1907            case AV_PLAYER_STATE.PREPARED:
1908                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1909                console.info('setSpeedTimeCallback avPlayer state is prepared')
1910                avPlayer.play()
1911                break;
1912            case AV_PLAYER_STATE.PLAYING:
1913                console.info('setSpeedTimeCallback play state is PLAYING')
1914                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
1915                if(loopTime == 10){
1916                    avPlayer.release().then(() => {
1917                        console.info('setSpeedTimeCallback avPlayer is release')
1918                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1919                        let avg = totalTime/10;
1920                        console.info("setSpeedTimeCallback avg time  is :" + avg)
1921                        done();
1922                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1923                }else{
1924                    start = Date.now();
1925                    console.info(`setSpeedTimeCallback start time is : ${start}`)
1926                    loopTime++
1927                    avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
1928                }
1929                break;
1930            case AV_PLAYER_STATE.PAUSED:
1931                console.info('setSpeedTimeCallback play state is PAUSED')
1932                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
1933                avPlayer.play().then(() => {
1934                    console.info('setSpeedTimeCallback avPlayer from pause to play')
1935                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1936                break;
1937            default:
1938                break;
1939        }
1940    });
1941    avPlayer.on('speedDone', async (speed) => {
1942        end = Date.now();
1943        console.info(`setSpeedTimeCallback end time is : ${end}`)
1944        execution = parseInt(end - start)
1945        console.info("setSpeedTimeCallback execution time  is :" + execution)
1946        totalTime = totalTime + execution;
1947        console.info('speedDone success,and speed value is:' + speed)
1948        avPlayer.pause()
1949    });
1950}
1951
1952export async function setBitrateTimeWithoutCallback(src, avPlayer, done) {
1953    let totalTime = 0;
1954    let surfaceID = globalThis.value;
1955    for(var i = 0;i < 10;i++){
1956        avPlayer = await idle(src, avPlayer)
1957        await setSource(avPlayer, src);
1958        console.info('setBitrateTimeWithoutCallback setSource');
1959        await sleep(20)
1960        avPlayer.surfaceId = surfaceID;
1961        await avPlayer.prepare().then(() => {
1962            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1963            console.info('setBitrateTimeWithoutCallback avPlayer state is prepared')
1964        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1965        let start = Date.now();
1966        console.info(`setBitrateTimeWithoutCallback start time is : ${start}`)
1967        let bitrate = 96000
1968        await avPlayer.setBitrate(bitrate)
1969        let end = Date.now();
1970        console.info(`setBitrateTimeWithoutCallback end time is : ${end}`)
1971        let execution = parseInt(end - start)
1972        console.info("setBitrateTimeWithoutCallback execution time  is :" + execution)
1973        totalTime = totalTime + execution;
1974        await avPlayer.release().then(() => {
1975            console.info('setBitrateTimeWithoutCallback avPlayer is release')
1976            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
1977        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1978    }
1979    let avg = totalTime/10;
1980    console.info("setBitrateTimeWithoutCallback avg time  is :" + avg)
1981    done();
1982}
1983
1984export async function setVolumeTimeWithoutCallback(src, avPlayer, done) {
1985    let totalTime = 0;
1986    let surfaceID = globalThis.value;
1987    for(var i = 0;i < 10;i++){
1988        avPlayer = await idle(src, avPlayer)
1989        await setSource(avPlayer, src);
1990        console.info('setVolumeTimeWithoutCallback setSource');
1991        await sleep(20)
1992        avPlayer.surfaceId = surfaceID;
1993        await avPlayer.prepare().then(() => {
1994            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
1995            console.info('setVolumeTimeWithoutCallback avPlayer state is prepared')
1996        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
1997        let start = Date.now();
1998        console.info(`setVolumeTimeWithoutCallback start time is : ${start}`)
1999        let volume = 1.0
2000        avPlayer.setVolume(volume)
2001        let end = Date.now();
2002        console.info(`setVolumeTimeWithoutCallback end time is : ${end}`)
2003        let execution = parseInt(end - start)
2004        console.info("setVolumeTimeWithoutCallback execution time  is :" + execution)
2005        totalTime = totalTime + execution;
2006        await avPlayer.release().then(() => {
2007            console.info('setVolumeTimeWithoutCallback avPlayer is release')
2008            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
2009        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2010    }
2011    let avg = totalTime/10;
2012    console.info("setVolumeTimeWithoutCallback avg time  is :" + avg)
2013    done();
2014}
2015
2016export async function setVolumeTimeWithCallback(src, avPlayer, done) {
2017    avPlayer = await idle(src, avPlayer)
2018    await setVolumeTimeCallback(avPlayer, done)
2019    await setSource(avPlayer, src);
2020}
2021
2022function setVolumeTimeCallback(avPlayer, done) {
2023    let surfaceID = globalThis.value;
2024    let start;
2025    let end;
2026    let execution;
2027    let loopTime = 0;
2028    let totalTime = 0;
2029    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
2030    avPlayer.on('stateChange', async (state, reason) => {
2031        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
2032        console.info(`case state is ${state}`);
2033        switch (state) {
2034            case AV_PLAYER_STATE.INITIALIZED:
2035                avPlayer.surfaceId = surfaceID;
2036                console.info('setVolumeTimeCallback play state is INITIALIZED')
2037            // step 1: initialized -> prepared
2038                avPlayer.prepare((err) => {
2039                    if (err != null) {
2040                        console.error(`case prepare error, errMessage is ${err.message}`);
2041                        expect().assertFail();
2042                        done();
2043                    } else {
2044                        console.info('setVolumeTimeCallback play state is prepared')
2045                    }
2046                });
2047                break;
2048            case AV_PLAYER_STATE.PREPARED:
2049                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
2050                console.info('setVolumeTimeCallback avPlayer state is prepared')
2051                avPlayer.play()
2052                break;
2053            case AV_PLAYER_STATE.PLAYING:
2054                console.info('setVolumeTimeCallback play state is PLAYING')
2055                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
2056                if(loopTime == 10){
2057                    avPlayer.release().then(() => {
2058                        console.info('setVolumeTimeCallback avPlayer is release')
2059                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
2060                        let avg = totalTime/10;
2061                        console.info("setVolumeTimeCallback avg time  is :" + avg)
2062                        done();
2063                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2064                }else{
2065                    start = Date.now();
2066                    console.info(`setVolumeTimeCallback start time is : ${start}`)
2067                    loopTime++
2068                    let volume = 1.0
2069                    avPlayer.setVolume(volume)
2070                }
2071                break;
2072            case AV_PLAYER_STATE.PAUSED:
2073                console.info('setVolumeTimeCallback play state is PAUSED')
2074                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
2075                avPlayer.play().then(() => {
2076                    console.info('setVolumeTimeCallback avPlayer from pause to play')
2077                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2078                break;
2079            default:
2080                break;
2081        }
2082    });
2083    avPlayer.on('volumeChange', (vol) => {
2084        end = Date.now();
2085        console.info(`setVolumeTimeCallback end time is : ${end}`)
2086        execution = parseInt(end - start)
2087        console.info("setVolumeTimeCallback execution time  is :" + execution)
2088        totalTime = totalTime + execution;
2089        console.info('volumeChange success,and new volume is :' + vol)
2090        avPlayer.pause()
2091    });
2092}
2093
2094export async function firstFrameTime(src, avPlayer,  done) {
2095    let surfaceID = globalThis.value;
2096    let start;
2097    avPlayer = await idle(src, avPlayer)
2098    await setSource(avPlayer, src);
2099    console.info('firstFrameTime setSource');
2100    await sleep(20)
2101    avPlayer.surfaceId = surfaceID;
2102    await avPlayer.prepare().then(() => {
2103        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
2104        console.info('firstFrameTime avPlayer state is prepared')
2105    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2106    await avPlayer.on('startRenderFrame', () => {
2107        console.info('startRenderFrame success')
2108        let end = Date.now();
2109        console.info(`firstFrameTime end time is : ${end}`)
2110        let execution = parseInt(end - start)
2111        console.info("firstFrameTime execution time  is :" + execution)
2112        sleep(100)
2113        avPlayer.release().then(() => {
2114            console.info('firstFrameTime avPlayer is release')
2115            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
2116            avPlayer = null;
2117            done();
2118        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2119    })
2120    start = Date.now();
2121    console.info(`firstFrameTime start time is : ${start}`)
2122    await avPlayer.play().then(() => {
2123        console.info('firstFrameTime play success');
2124    }, (err) => {
2125        console.error('firstFrameTime play filed,error message is :' + err.message)
2126    })
2127}
2128
2129async function playToPauseLoop(avPlayer){
2130    await avPlayer.play().then(() => {
2131        console.info('playToPauseLoop play success');
2132        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
2133    }, (err) => {
2134        console.error('playToPauseLoop play filed,error message is :' + err.message)
2135    })
2136    if(avPlayer.state == AV_PLAYER_STATE.PLAYING){
2137        avPlayer.loop = true;
2138        await mediaTestBase.msleepAsync(2);
2139        console.info('playToPauseLoop avPlayer from play to pause')
2140    }
2141    await avPlayer.pause().then(() => {
2142        console.info('playToPauseLoop pause success');
2143        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
2144    }, (err) => {
2145        console.error('playToPauseLoop pause filed,error message is :' + err.message)
2146    })
2147}
2148
2149export async function avPlayerWithoutCallBack(src, avPlayer, done) {
2150    let surfaceID = globalThis.value;
2151    console.info(`case avPlayerWithoutCallBack Initialized in, surfaceID is ${surfaceID}`);
2152    avPlayer = await idle(src, avPlayer)
2153    setSource(avPlayer, src);
2154    console.info('avPlayerWithoutCallBack setSource');
2155    await sleep(20);
2156    if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) {
2157        avPlayer.surfaceId = surfaceID;
2158        await preparePromise(avPlayer);
2159        await sleep(2000);
2160    }
2161    if(avPlayer.state == AV_PLAYER_STATE.PREPARED){
2162        console.info('avPlayerWithoutCallBack avPlayer from PREPARED to play')
2163        // play to pause loop 1000 times
2164        for(var i = 0;i < 1000; i++){
2165            await playToPauseLoop(avPlayer)
2166            console.info(`case avPlayerWithoutCallBack playToPauseLoop is ${i}`);
2167        }
2168    }
2169    await avPlayer.stop().then(() => {
2170        console.info('avPlayerWithoutCallBack avPlayer from play to stop')
2171        avPlayer.release().then(() => {
2172            console.info('avPlayerWithoutCallBack avPlayer from stop to release')
2173            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
2174            done();
2175        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2176    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2177}
2178
2179function setAVPlayerPlay(src, avPlayer, done) {
2180    let surfaceID = globalThis.value;
2181    console.info(`case setAVPlayerPlay in, surfaceID is ${surfaceID}`);
2182    avPlayer.on('stateChange', async (state, reason) => {
2183        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
2184        console.info(`case state is ${state}`);
2185        switch (state) {
2186            case AV_PLAYER_STATE.INITIALIZED:
2187                avPlayer.surfaceId = surfaceID;
2188                console.info('setAVPlayerPlay play state is INITIALIZED')
2189            // step 1: initialized -> prepared -> play
2190                avPlayer.prepare().then(() => {
2191                    avPlayer.play()
2192                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2193                break;
2194            case AV_PLAYER_STATE.PLAYING:
2195                console.info('setAVPlayerPlay play state is PLAYING')
2196                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
2197                if(avPlayer.duration > 3000){
2198                    mediaTestBase.msleepAsync(3000);
2199                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC)
2200                }else{
2201                    mediaTestBase.msleepAsync(500);
2202                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC)
2203                }
2204                break;
2205            case AV_PLAYER_STATE.COMPLETED:
2206                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
2207                expect(avPlayer.state).assertEqual('completed');
2208                avPlayer.release().then(() => {
2209                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2210                break;
2211            case AV_PLAYER_STATE.RELEASED:
2212                expect(avPlayer.state).assertEqual('released');
2213                avPlayer = null;
2214                done();
2215                break;
2216            case AV_PLAYER_STATE.ERROR:
2217                console.info(`case error called, AV_PLAYER_STATE.ERROR, ignore`);
2218                avPlayer.release().then(() => {
2219                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2220                break;
2221            default:
2222                break;
2223        }
2224    });
2225    avPlayer.on('error', async (err) => {
2226        console.error(`case error called, errMessage is ${err.message}`);
2227        if (error.code == media.AVErrorCode9.AVERR_UNSUPPORT_FORMAT){
2228            console.info(`case error called, AVERR_UNSUPPORT_FORMAT, ignore`);
2229        } else {
2230            expect().assertFail();
2231        }
2232        await avPlayer.release().then(() => {
2233            avPlayer = null;
2234            done();
2235        });
2236    });
2237}
2238
2239export async function avPlayerPlay(src, avPlayer, done) {
2240    avPlayer = await idle(src, avPlayer)
2241    await setAVPlayerPlay(src, avPlayer, done);
2242    await setSource(avPlayer, src);
2243}
2244
2245export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) {
2246    console.info(`case media source: ${src}`)
2247    await media.createAVPlayer().then((video) => {
2248        if (typeof(video) != 'undefined') {
2249            console.info('case createAVPlayer success');
2250            avPlayer = video;
2251            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
2252        } else {
2253            console.error('case createAVPlayer failed');
2254            expect().assertFail();
2255            done();
2256        }
2257    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2258    setAVPlayerFunCb(src, avPlayer, playTest, playTime, done);
2259    setSource(avPlayer, src);
2260}
2261
2262export function setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done) {
2263    let volumeCnt = [0];
2264    let endOfStreamCnt = 0;
2265    let seekDoneCnt = 0;
2266    let speedDoneCnt = [0];
2267    let playCnt = 0;
2268    let surfaceID = globalThis.value;
2269    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
2270    avPlayer.on('stateChange', async (state, reason) => {
2271        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
2272        if (reason == media.StateChangeReason.BACKGROUND) {
2273            avPlayer.release().then(() => {
2274            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2275        }
2276        switch (state) {
2277            case AV_PLAYER_STATE.INITIALIZED:
2278                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED);
2279                avPlayer.surfaceId = surfaceID;
2280                console.info('case initialized -> prepared');
2281                // step 1,10: initialized -> prepared
2282                avPlayer.prepare((err) => {
2283                    avPlayer.loop = true;
2284                    if (err != null) {
2285                        console.error(`case prepare error, errMessage is ${err.message}`);
2286                        expect().assertFail();
2287                        done();
2288                    } else {
2289                        checkPlayTest(avPlayer, playTest);
2290                    }
2291                });
2292                break;
2293            case AV_PLAYER_STATE.PREPARED:
2294                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
2295                checkPlayTest(avPlayer, playTest);
2296                expect(avPlayer.currentTime).assertEqual(0);
2297                offCallback(avPlayer, ['volumeChange']);
2298                // step 2,11: prepared -> seek 0
2299                avPlayer.seek(0, 2);  // 2: CLOSEST SYNC
2300                break;
2301            case AV_PLAYER_STATE.PLAYING:
2302                playCnt++;
2303                if (playCnt == 1) {
2304                    // step 4: seek + pause
2305                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
2306                    avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_PREV_SYNC);
2307                    avPlayer.pause((err) => {
2308                        if (err != null) {
2309                            mediaTestBase.assertErr('pause', err, done);
2310                        }
2311                    });
2312                } else if (playCnt == 3) {
2313                    // step 12: seek duration
2314                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC);
2315                    avPlayer.stop((err) => {
2316                        if (err == null) {
2317                            avPlayer.release((err) => {
2318                                if (err != null) {
2319                                    mediaTestBase.assertErr('release', err, done);
2320                                }
2321                            })
2322                        }  else {
2323                            mediaTestBase.assertErr('stop', err, done);
2324                        }
2325                    });
2326                }
2327                break;
2328            case AV_PLAYER_STATE.RELEASED:
2329                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
2330                // step 18: release -> done
2331                avPlayer = null;
2332                expect(volumeCnt[0]).assertEqual(0);
2333                expect(endOfStreamCnt).assertLarger(0);
2334                done();
2335                break;
2336            case AV_PLAYER_STATE.ERROR:
2337                expect().assertFail();
2338                avPlayer.release().then(() => {
2339                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
2340                break;
2341            default:
2342                break;
2343        }
2344    });
2345
2346    avPlayer.on('endOfStream', () => {
2347        console.info(`case endOfStream called`);
2348        endOfStreamCnt++;
2349        // step 9: seek + reset
2350        avPlayer.seek(avPlayer.duration / 2, 3); // 3: CLOSEST
2351        avPlayer.reset((err) => {
2352            if (err == null) {
2353                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
2354                console.info('case reset success!!');
2355                setSource(avPlayer, src);
2356            }  else {
2357                mediaTestBase.assertErr('reset', err, done);
2358            }
2359        });
2360    });
2361    avPlayer.on('seekDone', async (seekDoneTime) => {
2362        seekDoneCnt++;
2363        console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`);
2364        switch (seekDoneCnt) {
2365            case 1:
2366                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
2367                // step 3: seek(prepared) -> play
2368                avPlayer.play((err) => {
2369                    if (err != null) {
2370                        mediaTestBase.assertErr('play', err, done);
2371                    }
2372                });
2373                break;
2374            case 2:
2375                // step 5: seek + play
2376                avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_NEXT_SYNC);
2377                avPlayer.play();
2378                break;
2379            case 3:
2380                // step 6: seek  + setVolume
2381                avPlayer.setVolume(0.5);
2382                avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_CLOSEST_SYNC);
2383                avPlayer.play();
2384                break;
2385            case 4:
2386                // step 7: seek + seek
2387                avPlayer.seek(avPlayer.duration / 2);
2388                avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
2389                avPlayer.play();
2390                break;
2391            case 5:
2392                // step 8: seek duration
2393                avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC);
2394                break;
2395            default:
2396                avPlayer.play();
2397                break;
2398        }
2399    });
2400    setCallback(avPlayer, 'volumeChange', volumeCnt);
2401    setCallback(avPlayer, 'speedDone', speedDoneCnt);
2402    setCallback(avPlayer, 'bitrateDone', null);
2403    setCallback(avPlayer, 'timeUpdate', null);
2404    setCallback(avPlayer, 'bufferingUpdate', null);
2405    setCallback(avPlayer, 'durationUpdate', null);
2406    setCallback(avPlayer, 'startRenderFrame', null);
2407    setCallback(avPlayer, 'videoSizeChange', null);
2408    setCallback(avPlayer, 'audioInterrupt', null);
2409    setCallback(avPlayer, 'availableBitrates', null);
2410    avPlayer.on('error', async (err) => {
2411        console.error(`case error called, errMessage is ${err.message}`);
2412    });
2413}
2414
2415export async function testAVPlayerSeek(src, avPlayer, playTest, playTime, done) {
2416    console.info(`case media source: ${src}`)
2417    media.createAVPlayer((err, video) => {
2418        console.info(`case media err: ${err}`)
2419        if (typeof(video) != 'undefined') {
2420            console.info('case createAVPlayer success');
2421            avPlayer = video;
2422            setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done);
2423            setSource(avPlayer, src);
2424        }
2425        if (err != null) {
2426            console.error(`case createAVPlayer error, errMessage is ${err.message}`);
2427            expect().assertFail();
2428            done();
2429        }
2430    });
2431}
2432