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