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