xref: /test/xts/acts/multimedia/media/media_js_standard/AVPlayerTestBase.js

/*
 * Copyright (C) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import media from '@ohos.multimedia.media'
import * as mediaTestBase from './MediaTestBase.js';

export const AV_PLAYER_STATE = {
    IDLE : 'idle',
    INITIALIZED : 'initialized',
    PREPARED : 'prepared',
    PLAYING : 'playing',
    PAUSED : 'paused',
    COMPLETED : 'completed',
    STOPPED : 'stopped',
    RELEASED : 'released',
    ERROR : 'error',
}

let playTest = {
    width: 0,
    height: 0,
    duration: -1
}
export {playTest};

export function setSource(avPlayer, src) {
    if (typeof(avPlayer) == 'undefined') {
        console.error('case avPlayer is undefined');
        return;
    }
    if (typeof(src) == 'string') {
        console.info('case src test');
        avPlayer.url = src;
    } else {
        console.info('case fdsrc test');
        avPlayer.fdSrc = src;
    }
}

export function setSubtitle(avPlayer, src) {
    if (typeof(avPlayer) === 'undefined') {
        console.error('case avPlayer is undefined');
        return;
    }
    if (typeof(src) === 'string') {
        console.info('case src test');
        avPlayer.addSubtitleFromUrl(src);
    } else {
        console.info('case fdsrc test');
        avPlayer.addSubtitleFromFd(src.fd, src.offset, src.length);
    }
}

function checkPlayTest(avPlayer, playTest) {
    if (avPlayer == null) {
        return;
    }
    expect(Math.abs(avPlayer.duration - playTest.duration)).assertLess(500);
    if (playTest.width > 0) {
        expect(avPlayer.width).assertEqual(playTest.width);
        expect(avPlayer.height).assertEqual(playTest.height);
    }
}

function toPreparePromise(avPlayer, playTest) {
    if (typeof(avPlayer) == 'undefined') {
        return;
    }
    avPlayer.prepare().then(() => {
        console.info('case prepare called');
        console.info('case avPlayer.duration: ' + avPlayer.duration);
        checkPlayTest(avPlayer, playTest);
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
}

async function preparePromise(avPlayer) {
    if (typeof(avPlayer) == 'undefined') {
        return;
    }
    await avPlayer.prepare().then(() => {
        console.info('case prepare called');
        console.info('case avPlayer.duration: ' + avPlayer.duration);
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
}

function addCnt(countArr) {
    if (countArr != null) {
        countArr[0]++;
    }
}

export function setCallback(avPlayer, type, countArr) {
    if (avPlayer == null) {
        return;
    }
    switch (type) {
        case 'volumeChange':
            avPlayer.on('volumeChange', (volume) => {
                console.info(`case volumeChange called, volume is ${volume}`);
                addCnt(countArr);
            });
            break;
        case 'endOfStream':
            avPlayer.on('endOfStream', () => {
                console.info(`case endOfStream called`);
                addCnt(countArr);
            });
            break;
        case 'speedDone':
            avPlayer.on('speedDone', (speedMode) => {
                console.info(`case speedDone called, speedMode is ${speedMode}`);
                addCnt(countArr);
            });
            break;
        case 'bitrateDone':
            avPlayer.on('bitrateDone', (bitrate) => {
                console.info(`case bitrateDone called, bitrate is ${bitrate}`);
            });
            break;
        case 'timeUpdate':
            avPlayer.on('timeUpdate', (time) => {
                console.info('case timeUpdate callback, time:' + time);
            });
            break;
        case 'bufferingUpdate':
            avPlayer.on('bufferingUpdate', (infoType, value) => {
            });
            break;
        case  'durationUpdate':
            avPlayer.on('durationUpdate', (duration) => {
                console.info('case durationUpdate called,duration:' + duration);
                addCnt(countArr);
            });
            break;
        case 'startRenderFrame':
            avPlayer.on('startRenderFrame', () => {
                console.info('case startRenderFrame called');
                addCnt(countArr);
            });
            break;
        case 'videoSizeChange':
            avPlayer.on('videoSizeChange', (w, h) => {
                console.info(`case videoSizeChange called, weight is ${w}, height is ${h}`);
                addCnt(countArr);
            });
            break;
        case  'audioInterrupt':
            avPlayer.on('audioInterrupt', (info) => {
                console.info(`case audioInterrupt called, info is ${info}`);
            });
            break;
        case  'availableBitrates':
            avPlayer.on('availableBitrates', (bitrates) => {
                for (let i = 0; i < bitrates.length; i++) {
                    console.info('case availableBitrates : '  + bitrates[i]);
                }
                addCnt(countArr);
            });
            break;
        default:
            break;
    }
}

export function offCallback(avPlayer, typeArr)
{
    if (avPlayer == null) {
        return;
    }
    for (let i = 0; i < typeArr.length; i++) {
        switch (typeArr[i]) {
            case 'stateChange':
                avPlayer.off('stateChange');
                break;
            case 'volumeChange':
                avPlayer.off('volumeChange');
                break;
            case 'endOfStream':
                avPlayer.off('endOfStream');
                break;
            case 'seekDone':
                avPlayer.off('seekDone');
                break;
            case 'speedDone':
                avPlayer.off('speedDone');
                break;
            case 'speedDone':
                avPlayer.off('speedDone');
                break;
            case 'timeUpdate':
                avPlayer.off('timeUpdate');
                break;
            case 'durationUpdate':
                avPlayer.off('durationUpdate');
                break;
            case 'bufferingUpdate':
                avPlayer.off('bufferingUpdate');
                break;
            case 'startRenderFrame':
                avPlayer.off('startRenderFrame');
                break;
            case 'videoSizeChange':
                avPlayer.off('videoSizeChange');
                break;
            case 'audioInterrupt':
                avPlayer.off('audioInterrupt');
                break;
            case 'availableBitrates':
                avPlayer.off('availableBitrates');
                break;
            case 'error':
                avPlayer.off('error');
                break;
            default:
                break;
        }
    }
}

export function setAVPlayerFunCb(src, avPlayer, playTest, playTime, done) {
    let volumeCnt = [0];
    let endOfStreamCnt = [0];
    let speedDoneCnt = [0];
    let videoSizeCnt = [0];
    let startRenderFrameCnt = [0];
    let durationUpdateCnt = [0];
    let seekDoneCnt = [0];
    let prepareCnt = 0;
    let playCnt = 0;
    let completedCnt = 0;
    let surfaceID = globalThis.value;
    console.info(`case setAVPlayerFunCb in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        if (reason == media.StateChangeReason.BACKGROUND) {
            console.info(`case media.StateChangeReason.BACKGROUND`);
            await avPlayer.release().then(() => {
            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        }
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED);
                avPlayer.surfaceId = surfaceID;
                try{
                    avPlayer.audioRendererInfo = {
                        content:audio.AudioRendererInfo.CONTENT_TYPE_MUSIC,
                        usage:audio.AudioRendererInfo.STREAM_USAGE_MEDIA,
                    }
                }catch(e){
                    console.error(`case stateChange error, e is ${e} ,message:${e.message}`);
                }
                // step 1, 13: initialized -> prepared
                toPreparePromise(avPlayer, playTest);
                break;
            case AV_PLAYER_STATE.PREPARED:
                prepareCnt++;
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                checkPlayTest(avPlayer, playTest);
                expect(avPlayer.currentTime).assertEqual(0);
                if (prepareCnt == 1) {
                    // step 2: prepared -> playing
                    avPlayer.play().then(() => {
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                } else {
                    // step 14: prepared -> seek
                    avPlayer.seek(avPlayer.duration);
                }
                break;
            case AV_PLAYER_STATE.PLAYING:
                playCnt++;
                if (playCnt == 1) {
                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                    // step 3: playing -> seek duration/3
                    await mediaTestBase.msleepAsync(playTime);
                    avPlayer.seek(avPlayer.duration / 3);
                } else if (playCnt == 2) {
                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                    //  step 7: playing -> seek duration when loop true
                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
                } else if (playCnt == 3) {
                    // step 10: playing -> stop
                    avPlayer.stop().then(() => {
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                // step 5: pause -> seek 0
                avPlayer.loop = true;
                avPlayer.seek(0, media.SeekMode.SEEK_NEXT_SYNC);
                break;
            case AV_PLAYER_STATE.COMPLETED:
                completedCnt++;
                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED);
                if (completedCnt == 1 && seekDoneCnt[0] < 5) {
                    // step 9: completed -> play
                    avPlayer.play();
                } else {
                    // step 16: completed -> reset
                    avPlayer.reset().then(() => {
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                        // step 17: reset -> release
                        avPlayer.release().then(() => {
                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }
                break;
            case AV_PLAYER_STATE.STOPPED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
                // step 11: stop -> reset
                avPlayer.reset().then(() => {
                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                    // step 12: reset -> initialized
                    setSource(avPlayer, src);
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            case AV_PLAYER_STATE.RELEASED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                // step 18: release -> done
                avPlayer = null;
                expect(volumeCnt[0]).assertLarger(0);
                expect(endOfStreamCnt[0]).assertLarger(0);
                expect(seekDoneCnt[0]).assertLarger(0);
                expect(speedDoneCnt[0]).assertLarger(0);
                expect(completedCnt).assertLarger(0);
                if (playTest.width != 0) {
                    expect(startRenderFrameCnt[0]).assertLarger(0);
                    expect(videoSizeCnt[0]).assertLarger(0);
                } else {
                    expect(startRenderFrameCnt[0]).assertEqual(0);
                    expect(videoSizeCnt[0]).assertEqual(0);
                }
                expect(durationUpdateCnt[0]).assertLarger(0)
                done();
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('seekDone', async (seekDoneTime) => {
        seekDoneCnt[0]++;
        console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`);
        switch (seekDoneCnt[0]) {
            case 2:
                // step 6: seek(paused) -> play
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                avPlayer.play();
                avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_2_00_X);
                avPlayer.setVolume(0.5);
                break;
            case 1:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                // step 4: seek(playing) -> pause
                avPlayer.pause().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            case 3:
            case 4:
            case 5:
                let nowTime = avPlayer.currentTime;
                if (avPlayer.state == AV_PLAYER_STATE.PREPARED) {
                    // step 15: prepared -> play
                    avPlayer.play();
                }
                if (nowTime > avPlayer.duration / 2) {
                    avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
                    await mediaTestBase.msleepAsync(avPlayer.duration - nowTime + playTime);
                }
                if (avPlayer.loop == true) {
                    // step 8: playing -> seek duration when loop false
                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                    avPlayer.loop = false;
                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
                }
                break;
        }
    });
    setCallback(avPlayer, 'volumeChange', volumeCnt);
    setCallback(avPlayer, 'endOfStream', endOfStreamCnt);
    setCallback(avPlayer, 'speedDone', speedDoneCnt);
    setCallback(avPlayer, 'bitrateDone', null);
    setCallback(avPlayer, 'timeUpdate', null);
    setCallback(avPlayer, 'bufferingUpdate', null);
    setCallback(avPlayer, 'durationUpdate', durationUpdateCnt);
    setCallback(avPlayer, 'startRenderFrame', startRenderFrameCnt);
    setCallback(avPlayer, 'videoSizeChange', videoSizeCnt);
    setCallback(avPlayer, 'audioInterrupt', null);
    setCallback(avPlayer, 'availableBitrates', null);
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

function setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done) {
    let playPauseCount = 0;
    let surfaceID = globalThis.value;
    console.info(`case setAVPlayerPlayAndPauseWithCallBack in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('playPauseLoopWithCallBack play state is INITIALIZED')
                preparePromise(avPlayer);
                break;
            case AV_PLAYER_STATE.PREPARED:
            // step 1: initialized -> prepared -> play
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('playPauseLoopWithCallBack play state is PREPARED')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                avPlayer.loop = true;
                console.info('playPauseLoopWithCallBack play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                playPauseCount++;
                mediaTestBase.msleepAsync(playTime);
                if(playPauseCount == 1001){
                    // step 4: playing -> stop -> release
                    avPlayer.stop().then(() => {
                        console.info('playPauseLoopWithCallBack avPlayer from play to stop')
                        avPlayer.release().then(() => {
                            console.info('playPauseLoopWithCallBack avPlayer from stop to release')
                            done();
                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    // step 2: playing -> pause loop
                    avPlayer.pause().then(() => {
                        console.info('playPauseLoopWithCallBack avPlayer from play to pause,time is :' + playPauseCount)
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('playPauseLoopWithCallBack play state is PAUSED')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
            // step 3: pause -> playing loop
                avPlayer.play().then(() => {
                    console.info('playPauseLoopWithCallBack avPlayer from pause to play,time is :' + playPauseCount)
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

async function idle(src, avPlayer) {
    console.info(`case media source: ${src}`)
    await media.createAVPlayer().then((video) => {
        if (typeof(video) != 'undefined') {
            console.info('case createAVPlayer success');
            avPlayer = video;
        } else {
            console.error('case createAVPlayer failed');
            expect().assertFail();
        }
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    return avPlayer;
}

export async function avPlayerWithCallBack(src, avPlayer, playTime, done) {
    avPlayer = await idle(src, avPlayer)
    await setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done);
    await setSource(avPlayer, src);
}

let createToReleaseLoopCount = 0;
async function createToReleaseLoop(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    console.info(`case createToReleaseLoop in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                setSource(avPlayer, src);
                break;
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('createToReleaseLoop play state is INITIALIZED')
            // step 1: initialized -> prepared -> play
                avPlayer.release()
                break;
            case AV_PLAYER_STATE.RELEASED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                createToReleaseLoopCount++
                if(createToReleaseLoopCount==1001){
                    done();
                }else{
                    avPlayer = await idle(src, avPlayer)
                    await createToReleaseLoop(src, avPlayer, done)
                    await setSource(avPlayer, src);
                }
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function createToRelease(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    avPlayer = await idle(src, avPlayer)
    await createToReleaseLoop(src, avPlayer, done)
    await setSource(avPlayer, src);
    console.info('CreateToRelease setSource');
}

export async function playToCompleted(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await playToCompletedLoop(src, avPlayer, done);
    await setSource(avPlayer, src);
}

async function playToCompletedLoop(src, avPlayer, done) {
    let playToCompletedCount = 0;
    let surfaceID = globalThis.value;
    console.info(`case playToCompletedLoop in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('playToCompletedLoop play state is INITIALIZED')
            // step 1: initialized -> prepared -> play
                await preparePromise(avPlayer);
                await sleep(2000);
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                avPlayer.loop = false;
                console.info('playToCompletedLoop play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                playToCompletedCount++;
                if(playToCompletedCount == 1001){
                    // step 4: playing -> stop -> release
                    avPlayer.stop().then(() => {
                        console.info('playToCompletedLoop avPlayer from play to stop')
                        avPlayer.release().then(() => {
                            console.info('playToCompletedLoop avPlayer from stop to release')
                            done();
                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    // step 2: playing -> seek loop
                    avPlayer.seek(10034, media.SeekMode.SEEK_NEXT_SYNC)
                    console.info('playToCompletedLoop avPlayer from play to seek,time is :' + playToCompletedCount)
                }
                break;
            case AV_PLAYER_STATE.COMPLETED:
                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED);
                console.info('playToCompletedLoop avPlayer from COMPLETED to play')
            // step 3: COMPLETED -> play loop
                avPlayer.play();
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function seekLoop(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    avPlayer = await idle(src, avPlayer)
    await setSource(avPlayer, src);
    console.info('seekLoop setSource');
    await sleep(20);
    if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) {
        avPlayer.surfaceId = surfaceID;
        console.info('seekLoop case prepare success');
        await preparePromise(avPlayer);
        await sleep(2000);
    }
    await avPlayer.play().then(() => {
        console.info('seekLoop play success');
        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
    }, (err) => {
        console.error('seekLoop play filed,error message is :' + err.message)
    })
    await seekLoopWithCallback(avPlayer)
    console.info('seekLoop avPlayer from play to seek')
    // play seek loop 1000 times
    await avPlayer.stop().then(() => {
        console.info('seekLoopWithCallback avPlayer from play to stop')
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    await avPlayer.release().then(() => {
        console.info('seekLoopWithCallback avPlayer from stop to release')
        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        done();
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
}

async function seekLoopWithCallback(avPlayer) {
    for (let loopTime = 0; loopTime < 5000; loopTime += 5) {
        await new Promise(resolve => {
            avPlayer.on('seekDone', seekDoneTime => {
                console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`);
                resolve();
            });
            avPlayer.seek(loopTime);
            console.info(`case seekLoopWithCallback loopTime is ${loopTime}`);
        });
    }
}

async function seekLoopWithoutCallbackLoop(src, avPlayer, done) {
    let seekLoopWithoutCallbackLoop = 0;
    let surfaceID = globalThis.value;
    console.info(`case seekLoopWithoutCallbackLoop in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('seekLoopWithoutCallbackLoop play state is INITIALIZED')
            // step 1: prepare
                preparePromise(avPlayer);
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            // step 2: sop
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('seekLoopWithoutCallbackLoop play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
            // step 5: PLAYING-IDLE
                for(var loopTime = 0;loopTime < 1000; loopTime++){
                    avPlayer.seek(loopTime)
                    console.info(`case seekLoopWithoutCallbackLoop loopTime is ${loopTime}`);
                    if(loopTime==999){
                        avPlayer.stop().then(() => {
                            console.info('seekLoopWithoutCallbackLoop avPlayer from play to stop')
                            avPlayer.release().then(() => {
                                console.info('seekLoopWithoutCallbackLoop avPlayer from stop to release')
                                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                                done();
                            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                    }
                }
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function seekLoopWithoutCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await seekLoopWithoutCallbackLoop(src, avPlayer, done)
    await setSource(avPlayer, src);
    console.info('seekLoopWithoutCallback setSource');
}

async function prepareToStopLoop(src, avPlayer, done) {
    let prepareToStopLoopCount = 0;
    let surfaceID = globalThis.value;
    console.info(`case prepareToStopLoop in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('prepareToStopLoop play state is INITIALIZED')
            // step 1: prepare
                preparePromise(avPlayer);
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            // step 2: sop
                avPlayer.stop()
                break;
            case AV_PLAYER_STATE.STOPPED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
                prepareToStopLoopCount++
                if(prepareToStopLoopCount==1001){
            // end: release
                    avPlayer.release().then(() => {
                        console.info('prepareToStopLoop avPlayer from stop to release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else {
                    preparePromise(avPlayer);
                }
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function prepareToStop(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await prepareToStopLoop(src, avPlayer, done)
    setSource(avPlayer, src);
    console.info('prepareToStopLoop setSource');
}

async function prepareToResetLoop(src, avPlayer, done) {
    let prepareToResetLoopCount = 0;
    let surfaceID = globalThis.value;
    console.info(`case prepareToResetLoop in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            // step 1: create-Idle
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                prepareToResetLoopCount++;
                if(prepareToResetLoopCount == 1001){
                    // end: release
                    avPlayer.release().then(() => {
                        console.info('prepareToResetLoop avPlayer from stop to release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
            // step 2: idle-INITIALIZED
                    setSource(avPlayer, src);
                    console.info('prepareToResetLoop avPlayer from play to seek,time is :' + prepareToResetLoopCount)
                }
                break;
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('prepareToResetLoop play state is INITIALIZED')
            // step 3: INITIALIZED-PREPARED
                preparePromise(avPlayer);
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            // step 4: PREPARED-PLAYING
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('prepareToResetLoop play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
            // step 5: PLAYING-IDLE
                avPlayer.reset()
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function prepareToReset(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    // url -> prepare -> play -> reset loop 1000 times
    await prepareToResetLoop(src, avPlayer, done)
    await setSource(avPlayer, src);
}

let createToReleaseLoopCount2 = 0;
async function createToReleaseLoop2(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    console.info(`case createToReleaseLoop2 in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                setSource(avPlayer, src);
                break;
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('createToReleaseLoop2 play state is INITIALIZED')
                preparePromise(avPlayer);
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            // step 4: PREPARED-PLAYING
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('createToReleaseLoop2 play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                avPlayer.release()
                break;
            case AV_PLAYER_STATE.RELEASED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                createToReleaseLoopCount2++
                if(createToReleaseLoopCount2==1001){
                    done();
                }else{
                    avPlayer = await idle(src, avPlayer)
                    await createToReleaseLoop2(src, avPlayer, done)
                    await setSource(avPlayer, src);
                }
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function createToRelease2(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await createToReleaseLoop2(src, avPlayer, done)
    await setSource(avPlayer, src);
    console.info('createToRelease2 setSource');
}

let createLoopTime = 0;
let createTotalTime = 0;
let createStart;
export async function createTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    createStart = Date.now();
    console.info(`createTimeWithCallback createStart time is : ${createStart}`)
    createTimeCallback(src, avPlayer, done)
}

function createTimeCallback(src, avPlayer, done){
    let end;
    let execution;
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`createTimeCallback stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`createTimeCallback state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                end = Date.now();
                console.info(`createTimeCallback end time is : ${end}`)
                execution = parseInt(end - createStart)
                createTotalTime = createTotalTime + execution;
                console.info("createTimeCallback execution time  is :" + execution)
                createLoopTime++;
                avPlayer.release()
            case AV_PLAYER_STATE.RELEASED:
                console.info('createTimeCallback play state is release')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                if(createLoopTime == 10){
                    let avg = createTotalTime/10;
                    console.info("createTimeCallback avg time  is :" + avg)
                    createLoopTime = 0;
                    createTotalTime = 0;
                    done();
                }else{
                    avPlayer = null;
                    createTimeWithCallback(src, avPlayer, done)
                }
                break;
            default:
                break;
        }
    });
}

export async function createTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    for(var i = 0;i < 10;i++){
        let start = Date.now();
        console.info(`createTimeWithoutCallback start time is : ${start}`)
        avPlayer = await idle(src, avPlayer)
        let end = Date.now()
        let execution = parseInt(end - start)
        console.info("createTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('createTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("createTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function prepareTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('prepareTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        let start = Date.now();
        console.info(`prepareTimeWithoutCallback start time is : ${start}`)
        let end;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('prepareTimeWithoutCallback avPlayer state is prepared')
            end = Date.now()
            console.info(`prepareTimeWithoutCallback end time is : ${end}`)
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let execution = parseInt(end - start)
        console.info("prepareTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('prepareTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("prepareTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function prepareTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await prepareTimeCallback(src, avPlayer, done)
    await setSource(avPlayer, src);
}

async function prepareTimeCallback(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('prepareTimeWithCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("prepareTimeWithCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    setSource(avPlayer, src)
                }
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('prepareTimeWithCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                start = Date.now();
                console.info(`prepareTimeWithCallback start time is : ${start}`)
                avPlayer.prepare()
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('prepareTimeWithCallback avPlayer state is prepared')
                end = Date.now();
                console.info(`prepareTimeWithCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("prepareTimeWithCallback execution time  is :" + execution)
                totalTime = totalTime + execution;
                loopTime++;
                avPlayer.reset()
                break;
            default:
                break;
        }
    });
}

export async function playTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('playTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('playTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let start = Date.now();
        let end;
        console.info(`playTimeWithoutCallback start time is : ${start}`)
        await avPlayer.play().then(() => {
            end = Date.now();
            console.info(`playTimeWithoutCallback end time is : ${end}`)
            console.info('playTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('playTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let execution = parseInt(end - start)
        console.info("playTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('playTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
            avPlayer = null;
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("playTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function playTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await playTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

export function playTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('playTimeCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('playTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('playTimeCallback avPlayer state is prepared')
                start = Date.now();
                console.info(`playTimeCallback start time is : ${start}`)
            // step 2: prapared -> play
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('playTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                end = Date.now();
                console.info(`playTimeCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("playTimeCallback execution time  is :" + execution)
                totalTime = totalTime + execution;
                loopTime++;
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('playTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("playTimeWithCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
            // step 3: playing -> pause loop
                    setTimeout( () => {
                        avPlayer.pause()
                    }, 200);
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('playTimeWithCallback play state is PAUSED')
                expect(avPlayer.state).assertEqual('paused');
                start = Date.now();
                console.info(`playTimeCallback start time is : ${start}`)
                avPlayer.play()
                break;
            default:
                break;
        }
    });
}

export async function pauseTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        let execution;
        let end;
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('pauseTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('pauseTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        await avPlayer.play().then(() => {
            console.info('pauseTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('pauseTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let start = Date.now();

        console.info(`pauseTimeWithoutCallback start time is : ${start}`)
        await avPlayer.pause().then(() => {
            console.info('pauseTimeWithoutCallback pause success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
            end = Date.now();
            console.info(`pauseTimeWithoutCallback end time is : ${end}`)
            execution = parseInt(end - start)
            console.info("pauseTimeWithoutCallback execution time  is :" + execution)
        }, (err) => {
            console.error('pauseTimeWithoutCallback pause filed,error message is :' + err.message)
        })
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('pauseTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("pauseTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function pauseTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await pauseTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

function pauseTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('pauseTimeCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('pauseTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('pauseTimeCallback avPlayer state is prepared')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('pauseTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                setTimeout( () => {
                    start = Date.now();
                    console.info(`pauseTimeCallback start time is : ${start}`)
                    avPlayer.pause()
                }, 200);
                break;
            case AV_PLAYER_STATE.PAUSED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                end = Date.now();
                console.info(`pauseTimeCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("pauseTimeCallback execution time  is :" + execution)
                totalTime = totalTime + execution;
                loopTime++;
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('pauseTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("pauseTimeCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    avPlayer.play()
                }
                break;
            default:
                break;
        }
    });
}

export async function stopTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('stopTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('stopTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        await avPlayer.play().then(() => {
            console.info('stopTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('stopTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let start = Date.now();
        console.info(`stopTimeWithoutCallback start time is : ${start}`)
        let end;
        await avPlayer.stop().then(() => {
            end = Date.now();
            console.info(`stopTimeWithoutCallback end time is : ${end}`)
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
            console.info('stopTimeWithoutCallback avPlayer state is stop')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let execution = parseInt(end - start)
        console.info("stopTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('stopTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("stopTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function stopTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await stopTimeCallback(src, avPlayer, done)
    await setSource(avPlayer, src);
}

function stopTimeCallback(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                setSource(avPlayer, src);
                break;
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('stopTimeCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('stopTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('stopTimeCallback avPlayer state is prepared')
                start = Date.now();
                console.info(`stopTimeCallback start time is : ${start}`)
                loopTime++;
                avPlayer.stop()
                break;
            case AV_PLAYER_STATE.STOPPED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED);
                end = Date.now();
                console.info(`stopTimeCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("stopTimeCallback execution time  is :" + execution)
                totalTime = totalTime + execution;
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('stopTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("stopTimeCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    avPlayer.reset()
                }
                break;
            default:
                break;
        }
    });
}

export async function resetTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('resetTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('resetTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let end;
        await avPlayer.play().then(() => {
            console.info('resetTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('resetTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let start = Date.now();
        console.info(`resetTimeWithoutCallback start time is : ${start}`)
        await avPlayer.reset().then(() => {
            end = Date.now();
            console.info(`resetTimeWithoutCallback end time is : ${end}`)
            console.info('reset success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
        }, (err) => {
            console.error('reset filed,error message is :' + err.message)
        })
        let execution = parseInt(end - start)
        console.info("resetTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('resetTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("resetTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function resetTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await resetTimeCallback(src, avPlayer, done)
    await setSource(avPlayer, src);
}

function resetTimeCallback(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.IDLE:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                end = Date.now();
                console.info(`resetTimeCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("resetTimeCallback execution time  is :" + execution)
                totalTime = totalTime + execution;
                loopTime++;
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('resetTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("resetTimeCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    setSource(avPlayer, src)
                }
                break;
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('resetTimeCallback play state is INITIALIZED')
                start = Date.now();
                console.info(`resetTimeCallback start time is : ${start}`)
                avPlayer.reset().then(() => {
                    console.info('reset success');
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
}

export async function releaseTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('releaseTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        let start = Date.now();
        console.info(`releaseTimeWithoutCallback start time is : ${start}`)
        let end;
        await avPlayer.release().then(() => {
            console.info('releaseTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        end = Date.now();
        console.info(`releaseTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("releaseTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
    }
    let avg = totalTime/10;
    console.info("releaseTimeWithoutCallback avg time  is :" + avg)
    done();
}

let releaseTotalTime = 0;
let releaseLoop = 0;
export async function releaseTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await releaseTimeCallback(src, avPlayer, done)
    await setSource(avPlayer, src);
}

function releaseTimeCallback(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('releaseTimeCallback play state is INITIALIZED')
                start = Date.now();
                console.info(`releaseTimeCallback start time is : ${start}`)
                avPlayer.release()
                break;
            case AV_PLAYER_STATE.RELEASED:
                console.info('releaseTimeCallback play state is release')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                end = Date.now();
                console.info(`releaseTimeCallback end time is : ${end}`)
                execution = parseInt(end - start)
                console.info("releaseTimeCallback execution time  is :" + execution)
                releaseTotalTime = releaseTotalTime + execution;
                releaseLoop++;
                if(releaseLoop == 10){
                    let avg = releaseTotalTime/10;
                    console.info("releaseTimeCallback avg time  is :" + avg)
                    releaseTotalTime = 0;
                    releaseLoop = 0;
                    done();
                }else{
                    avPlayer = null;
                    releaseTimeWithCallback(src, avPlayer, done)
                }
                break;
            default:
                break;
        }
    });
}

export function getTotalTime(releaseTotalTime){
    return releaseTotalTime;
}

export async function seekTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('seekTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('seekTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let end;
        await avPlayer.play().then(() => {
            console.info('seekTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('seekTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let start = Date.now();
        console.info(`seekTimeWithoutCallback start time is : ${start}`)
        await avPlayer.seek(100)
        end = Date.now();
        console.info(`seekTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("seekTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('seekTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("seekTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function seekTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await seekTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

function seekTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('seekTimeCallback play state is INITIALIZED')
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('seekTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('seekTimeCallback avPlayer state is prepared')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('seekTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                start = Date.now();
                console.info(`seekTimeCallback start time is : ${start}`)
                loopTime+=20;
                if(loopTime == 220){
                    avPlayer.release().then(() => {
                        console.info('seekTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("seekTimeCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    avPlayer.seek(loopTime)
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('seekTimeCallback play state is PAUSED')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                avPlayer.play().then(() => {
                    console.info('seekTimeCallback avPlayer from pause to play')
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('seekDone', async (seekDoneTime) => {
        end = Date.now();
        console.info(`seekTimeCallback end time is : ${end}`)
        execution = parseInt(end - start)
        console.info("seekTimeCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`);
        avPlayer.pause()
    });
}

export async function getTrackDescriptionTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('getTrackDescriptionTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('getTrackDescriptionTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        await avPlayer.play().then(() => {
            console.info('getTrackDescriptionTimeWithoutCallback play success');
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
        }, (err) => {
            console.error('getTrackDescriptionTimeWithoutCallback play filed,error message is :' + err.message)
        })
        let arrayDescription;
        let start = Date.now();
        console.info(`getTrackDescriptionTimeWithoutCallback start time is : ${start}`)
        let end;
        await avPlayer.getTrackDescription().then((arrList) => {
            if (arrList != null) {
                arrayDescription = arrList;
            } else {
                console.log('video getTrackDescription fail');
            }
        }).catch((error) => {
            console.info(`video catchCallback, error:${error}`);
        });
        end = Date.now();
        console.info(`getTrackDescriptionTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("getTrackDescriptionTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('getTrackDescriptionTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("getTrackDescriptionTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function getTrackDescriptionTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await getTrackDescriptionTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

function getTrackDescriptionTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    let arrayDescription;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('getTrackDescriptionTimeCallback play state is INITIALIZED')
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('getTrackDescriptionTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('getTrackDescriptionTimeCallback avPlayer state is prepared')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('getTrackDescriptionTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                start = Date.now();
                console.info(`getTrackDescriptionTimeCallback start time is : ${start}`)
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('getTrackDescriptionTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        avPlayer = null;
                        let avg = totalTime/10;
                        console.info("getTrackDescriptionTimeCallback avg time is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    loopTime++;
                    avPlayer.getTrackDescription().then((arrList) => {
                        if (arrList != null) {
                            arrayDescription = arrList;
                            end = Date.now();
                            console.info(`getTrackDescriptionTimeCallback end time is : ${end}`)
                            execution = parseInt(end - start)
                            console.info("getTrackDescriptionTimeCallback execution time  is :" + execution)
                            totalTime = totalTime + execution;

                        } else {
                            console.log('video getTrackDescription fail');
                        }
                    }).catch((error) => {
                        console.info(`video catchCallback, error:${error}`);
                    });
                    setTimeout( () => {
                        avPlayer.pause()
                    }, 200);
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('getTrackDescriptionTimeCallback play state is PAUSED')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                avPlayer.play().then(() => {
                    console.info('getTrackDescriptionTimeCallback avPlayer from pause to play')
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
}

export async function setSpeedTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('setSpeedTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('setSpeedTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let start = Date.now();
        console.info(`setSpeedTimeWithoutCallback start time is : ${start}`)
        await avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
        let end = Date.now();
        console.info(`setSpeedTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("setSpeedTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('setSpeedTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("setSpeedTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function setSpeedTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await setSpeedTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

function setSpeedTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('setSpeedTimeCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('setSpeedTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('setSpeedTimeCallback avPlayer state is prepared')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('setSpeedTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('setSpeedTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        let avg = totalTime/10;
                        console.info("setSpeedTimeCallback avg time  is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    start = Date.now();
                    console.info(`setSpeedTimeCallback start time is : ${start}`)
                    loopTime++
                    avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X);
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('setSpeedTimeCallback play state is PAUSED')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                avPlayer.play().then(() => {
                    console.info('setSpeedTimeCallback avPlayer from pause to play')
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('speedDone', async (speed) => {
        end = Date.now();
        console.info(`setSpeedTimeCallback end time is : ${end}`)
        execution = parseInt(end - start)
        console.info("setSpeedTimeCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        console.info('speedDone success,and speed value is:' + speed)
        avPlayer.pause()
    });
}

export async function setBitrateTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('setBitrateTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('setBitrateTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let start = Date.now();
        console.info(`setBitrateTimeWithoutCallback start time is : ${start}`)
        let bitrate = 96000
        await avPlayer.setBitrate(bitrate)
        let end = Date.now();
        console.info(`setBitrateTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("setBitrateTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('setBitrateTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("setBitrateTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function setVolumeTimeWithoutCallback(src, avPlayer, done) {
    let totalTime = 0;
    let surfaceID = globalThis.value;
    for(var i = 0;i < 10;i++){
        avPlayer = await idle(src, avPlayer)
        await setSource(avPlayer, src);
        console.info('setVolumeTimeWithoutCallback setSource');
        await sleep(20)
        avPlayer.surfaceId = surfaceID;
        await avPlayer.prepare().then(() => {
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
            console.info('setVolumeTimeWithoutCallback avPlayer state is prepared')
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        let start = Date.now();
        console.info(`setVolumeTimeWithoutCallback start time is : ${start}`)
        let volume = 1.0
        avPlayer.setVolume(volume)
        let end = Date.now();
        console.info(`setVolumeTimeWithoutCallback end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("setVolumeTimeWithoutCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        await avPlayer.release().then(() => {
            console.info('setVolumeTimeWithoutCallback avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }
    let avg = totalTime/10;
    console.info("setVolumeTimeWithoutCallback avg time  is :" + avg)
    done();
}

export async function setVolumeTimeWithCallback(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await setVolumeTimeCallback(avPlayer, done)
    await setSource(avPlayer, src);
}

function setVolumeTimeCallback(avPlayer, done) {
    let surfaceID = globalThis.value;
    let start;
    let end;
    let execution;
    let loopTime = 0;
    let totalTime = 0;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('setVolumeTimeCallback play state is INITIALIZED')
            // step 1: initialized -> prepared
                avPlayer.prepare((err) => {
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        console.info('setVolumeTimeCallback play state is prepared')
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                console.info('setVolumeTimeCallback avPlayer state is prepared')
                avPlayer.play()
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('setVolumeTimeCallback play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                if(loopTime == 10){
                    avPlayer.release().then(() => {
                        console.info('setVolumeTimeCallback avPlayer is release')
                        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                        let avg = totalTime/10;
                        console.info("setVolumeTimeCallback avg time  is :" + avg)
                        done();
                    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                }else{
                    start = Date.now();
                    console.info(`setVolumeTimeCallback start time is : ${start}`)
                    loopTime++
                    let volume = 1.0
                    avPlayer.setVolume(volume)
                }
                break;
            case AV_PLAYER_STATE.PAUSED:
                console.info('setVolumeTimeCallback play state is PAUSED')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
                avPlayer.play().then(() => {
                    console.info('setVolumeTimeCallback avPlayer from pause to play')
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('volumeChange', (vol) => {
        end = Date.now();
        console.info(`setVolumeTimeCallback end time is : ${end}`)
        execution = parseInt(end - start)
        console.info("setVolumeTimeCallback execution time  is :" + execution)
        totalTime = totalTime + execution;
        console.info('volumeChange success,and new volume is :' + vol)
        avPlayer.pause()
    });
}

export async function firstFrameTime(src, avPlayer,  done) {
    let surfaceID = globalThis.value;
    let start;
    avPlayer = await idle(src, avPlayer)
    await setSource(avPlayer, src);
    console.info('firstFrameTime setSource');
    await sleep(20)
    avPlayer.surfaceId = surfaceID;
    await avPlayer.prepare().then(() => {
        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
        console.info('firstFrameTime avPlayer state is prepared')
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    await avPlayer.on('startRenderFrame', () => {
        console.info('startRenderFrame success')
        let end = Date.now();
        console.info(`firstFrameTime end time is : ${end}`)
        let execution = parseInt(end - start)
        console.info("firstFrameTime execution time  is :" + execution)
        sleep(100)
        avPlayer.release().then(() => {
            console.info('firstFrameTime avPlayer is release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
            avPlayer = null;
            done();
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    })
    start = Date.now();
    console.info(`firstFrameTime start time is : ${start}`)
    await avPlayer.play().then(() => {
        console.info('firstFrameTime play success');
    }, (err) => {
        console.error('firstFrameTime play filed,error message is :' + err.message)
    })
}

async function playToPauseLoop(avPlayer){
    await avPlayer.play().then(() => {
        console.info('playToPauseLoop play success');
        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
    }, (err) => {
        console.error('playToPauseLoop play filed,error message is :' + err.message)
    })
    if(avPlayer.state == AV_PLAYER_STATE.PLAYING){
        avPlayer.loop = true;
        await mediaTestBase.msleepAsync(2);
        console.info('playToPauseLoop avPlayer from play to pause')
    }
    await avPlayer.pause().then(() => {
        console.info('playToPauseLoop pause success');
        expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED);
    }, (err) => {
        console.error('playToPauseLoop pause filed,error message is :' + err.message)
    })
}

export async function avPlayerWithoutCallBack(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    console.info(`case avPlayerWithoutCallBack Initialized in, surfaceID is ${surfaceID}`);
    avPlayer = await idle(src, avPlayer)
    setSource(avPlayer, src);
    console.info('avPlayerWithoutCallBack setSource');
    await sleep(20);
    if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) {
        avPlayer.surfaceId = surfaceID;
        await preparePromise(avPlayer);
        await sleep(2000);
    }
    if(avPlayer.state == AV_PLAYER_STATE.PREPARED){
        console.info('avPlayerWithoutCallBack avPlayer from PREPARED to play')
        // play to pause loop 1000 times
        for(var i = 0;i < 1000; i++){
            await playToPauseLoop(avPlayer)
            console.info(`case avPlayerWithoutCallBack playToPauseLoop is ${i}`);
        }
    }
    await avPlayer.stop().then(() => {
        console.info('avPlayerWithoutCallBack avPlayer from play to stop')
        avPlayer.release().then(() => {
            console.info('avPlayerWithoutCallBack avPlayer from stop to release')
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
            done();
        }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
}

function setAVPlayerPlay(src, avPlayer, done) {
    let surfaceID = globalThis.value;
    console.info(`case setAVPlayerPlay in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        console.info(`case state is ${state}`);
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                avPlayer.surfaceId = surfaceID;
                console.info('setAVPlayerPlay play state is INITIALIZED')
            // step 1: initialized -> prepared -> play
                avPlayer.prepare().then(() => {
                    avPlayer.play()
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            case AV_PLAYER_STATE.PLAYING:
                console.info('setAVPlayerPlay play state is PLAYING')
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                if(avPlayer.duration > 3000){
                    mediaTestBase.msleepAsync(3000);
                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC)
                }else{
                    mediaTestBase.msleepAsync(500);
                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC)
                }
                break;
            case AV_PLAYER_STATE.COMPLETED:
                expect(avPlayer.currentTime).assertEqual(avPlayer.duration);
                expect(avPlayer.state).assertEqual('completed');
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            case AV_PLAYER_STATE.RELEASED:
                expect(avPlayer.state).assertEqual('released');
                avPlayer = null;
                done();
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
        expect().assertFail();
        await avPlayer.release().then(() => {
            avPlayer = null;
            done();
        });
    });
}

export async function avPlayerPlay(src, avPlayer, done) {
    avPlayer = await idle(src, avPlayer)
    await setAVPlayerPlay(src, avPlayer, done);
    await setSource(avPlayer, src);
}

export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) {
    console.info(`case media source: ${src}`)
    await media.createAVPlayer().then((video) => {
        if (typeof(video) != 'undefined') {
            console.info('case createAVPlayer success');
            avPlayer = video;
            expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
        } else {
            console.error('case createAVPlayer failed');
            expect().assertFail();
            done();
        }
    }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
    setAVPlayerFunCb(src, avPlayer, playTest, playTime, done);
    setSource(avPlayer, src);
}

export function setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done) {
    let volumeCnt = [0];
    let endOfStreamCnt = 0;
    let seekDoneCnt = 0;
    let speedDoneCnt = [0];
    let playCnt = 0;
    let surfaceID = globalThis.value;
    console.info(`case setCallback in, surfaceID is ${surfaceID}`);
    avPlayer.on('stateChange', async (state, reason) => {
        console.info(`case stateChange called, state is ${state}, reason is ${reason}`);
        if (reason == media.StateChangeReason.BACKGROUND) {
            avPlayer.release().then(() => {
            }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
        }
        switch (state) {
            case AV_PLAYER_STATE.INITIALIZED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED);
                avPlayer.surfaceId = surfaceID;
                console.info('case initialized -> prepared');
                // step 1,10: initialized -> prepared
                avPlayer.prepare((err) => {
                    avPlayer.loop = true;
                    if (err != null) {
                        console.error(`case prepare error, errMessage is ${err.message}`);
                        expect().assertFail();
                        done();
                    } else {
                        checkPlayTest(avPlayer, playTest);
                    }
                });
                break;
            case AV_PLAYER_STATE.PREPARED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                checkPlayTest(avPlayer, playTest);
                expect(avPlayer.currentTime).assertEqual(0);
                offCallback(avPlayer, ['volumeChange']);
                // step 2,11: prepared -> seek 0
                avPlayer.seek(0, 2);  // 2: CLOSEST SYNC
                break;
            case AV_PLAYER_STATE.PLAYING:
                playCnt++;
                if (playCnt == 1) {
                    // step 4: seek + pause
                    expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING);
                    avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_PREV_SYNC);
                    avPlayer.pause((err) => {
                        if (err != null) {
                            mediaTestBase.assertErr('pause', err, done);
                        }
                    });
                } else if (playCnt == 3) {
                    // step 12: seek duration
                    avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC);
                    avPlayer.stop((err) => {
                        if (err == null) {
                            avPlayer.release((err) => {
                                if (err != null) {
                                    mediaTestBase.assertErr('release', err, done);
                                }
                            })
                        }  else {
                            mediaTestBase.assertErr('stop', err, done);
                        }
                    });
                }
                break;
            case AV_PLAYER_STATE.RELEASED:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED);
                // step 18: release -> done
                avPlayer = null;
                expect(volumeCnt[0]).assertEqual(0);
                expect(endOfStreamCnt).assertLarger(0);
                done();
                break;
            case AV_PLAYER_STATE.ERROR:
                expect().assertFail();
                avPlayer.release().then(() => {
                }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback);
                break;
            default:
                break;
        }
    });

    avPlayer.on('endOfStream', () => {
        console.info(`case endOfStream called`);
        endOfStreamCnt++;
        // step 9: seek + reset
        avPlayer.seek(avPlayer.duration / 2, 3); // 3: CLOSEST
        avPlayer.reset((err) => {
            if (err == null) {
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE);
                console.info('case reset success!!');
                setSource(avPlayer, src);
            }  else {
                mediaTestBase.assertErr('reset', err, done);
            }
        });
    });
    avPlayer.on('seekDone', async (seekDoneTime) => {
        seekDoneCnt++;
        console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`);
        switch (seekDoneCnt) {
            case 1:
                expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED);
                // step 3: seek(prepared) -> play
                avPlayer.play((err) => {
                    if (err != null) {
                        mediaTestBase.assertErr('play', err, done);
                    }
                });
                break;
            case 2:
                // step 5: seek + play
                avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_NEXT_SYNC);
                avPlayer.play();
                break;
            case 3:
                // step 6: seek  + setVolume
                avPlayer.setVolume(0.5);
                avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_CLOSEST_SYNC);
                avPlayer.play();
                break;
            case 4:
                // step 7: seek + seek
                avPlayer.seek(avPlayer.duration / 2);
                avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC);
                avPlayer.play();
                break;
            case 5:
                // step 8: seek duration
                avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC);
                break;
            default:
                avPlayer.play();
                break;
        }
    });
    setCallback(avPlayer, 'volumeChange', volumeCnt);
    setCallback(avPlayer, 'speedDone', speedDoneCnt);
    setCallback(avPlayer, 'bitrateDone', null);
    setCallback(avPlayer, 'timeUpdate', null);
    setCallback(avPlayer, 'bufferingUpdate', null);
    setCallback(avPlayer, 'durationUpdate', null);
    setCallback(avPlayer, 'startRenderFrame', null);
    setCallback(avPlayer, 'videoSizeChange', null);
    setCallback(avPlayer, 'audioInterrupt', null);
    setCallback(avPlayer, 'availableBitrates', null);
    avPlayer.on('error', async (err) => {
        console.error(`case error called, errMessage is ${err.message}`);
    });
}

export async function testAVPlayerSeek(src, avPlayer, playTest, playTime, done) {
    console.info(`case media source: ${src}`)
    media.createAVPlayer((err, video) => {
        console.info(`case media err: ${err}`)
        if (typeof(video) != 'undefined') {
            console.info('case createAVPlayer success');
            avPlayer = video;
            setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done);
            setSource(avPlayer, src);
        }
        if (err != null) {
            console.error(`case createAVPlayer error, errMessage is ${err.message}`);
            expect().assertFail();
            done();
        }
    });
}