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 // step 1: initialized -> prepared -> play 420 await preparePromise(avPlayer); 421 await sleep(2000); 422 avPlayer.play() 423 break; 424 case AV_PLAYER_STATE.PLAYING: 425 avPlayer.loop = true; 426 console.info('playPauseLoopWithCallBack play state is PLAYING') 427 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 428 playPauseCount++; 429 await mediaTestBase.msleepAsync(playTime); 430 if(playPauseCount == 1001){ 431 // step 4: playing -> stop -> release 432 avPlayer.stop().then(() => { 433 console.info('playPauseLoopWithCallBack avPlayer from play to stop') 434 avPlayer.release().then(() => { 435 console.info('playPauseLoopWithCallBack avPlayer from stop to release') 436 done(); 437 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 438 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 439 }else{ 440 // step 2: playing -> pause loop 441 avPlayer.pause().then(() => { 442 console.info('playPauseLoopWithCallBack avPlayer from play to pause,time is :' + playPauseCount) 443 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 444 } 445 break; 446 case AV_PLAYER_STATE.PAUSED: 447 console.info('playPauseLoopWithCallBack play state is PAUSED') 448 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 449 // step 3: pause -> playing loop 450 avPlayer.play().then(() => { 451 console.info('playPauseLoopWithCallBack avPlayer from pause to play,time is :' + playPauseCount) 452 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 453 break; 454 case AV_PLAYER_STATE.ERROR: 455 expect().assertFail(); 456 avPlayer.release().then(() => { 457 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 458 break; 459 default: 460 break; 461 } 462 }); 463 avPlayer.on('error', async (err) => { 464 console.error(`case error called, errMessage is ${err.message}`); 465 expect().assertFail(); 466 await avPlayer.release().then(() => { 467 avPlayer = null; 468 done(); 469 }); 470 }); 471} 472 473async function idle(src, avPlayer) { 474 console.info(`case media source: ${src}`) 475 await media.createAVPlayer().then((video) => { 476 if (typeof(video) != 'undefined') { 477 console.info('case createAVPlayer success'); 478 avPlayer = video; 479 } else { 480 console.error('case createAVPlayer failed'); 481 expect().assertFail(); 482 } 483 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 484 return avPlayer; 485} 486 487export async function avPlayerWithCallBack(src, avPlayer, playTime, done) { 488 avPlayer = await idle(src, avPlayer) 489 setAVPlayerPlayAndPauseWithCallBack(src, avPlayer, playTime, done); 490 await setSource(avPlayer, src); 491} 492 493async function playToPauseLoop(avPlayer){ 494 await avPlayer.play().then(() => { 495 console.info('playToPauseLoop play success'); 496 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 497 }, (err) => { 498 console.error('playToPauseLoop play filed,error message is :' + err.message) 499 }) 500 if(avPlayer.state == AV_PLAYER_STATE.PLAYING){ 501 avPlayer.loop = true; 502 await mediaTestBase.msleepAsync(2); 503 console.info('playToPauseLoop avPlayer from play to pause') 504 } 505 await avPlayer.pause().then(() => { 506 console.info('playToPauseLoop pause success'); 507 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 508 }, (err) => { 509 console.error('playToPauseLoop pause filed,error message is :' + err.message) 510 }) 511} 512 513export async function createToRelease(src, avPlayer, done) { 514 for(var i = 0;i < 1000; i++){ 515 let surfaceID = globalThis.value; 516 avPlayer = await idle(src, avPlayer) 517 await setSource(avPlayer, src); 518 console.info('CreateToRelease setSource'); 519 await sleep(20) 520 avPlayer.surfaceId = surfaceID; 521 await avPlayer.release().then(() => { 522 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 523 console.info('CreateToRelease avPlayer from stop to release') 524 console.info(`case CreateToRelease loop is ${i}`); 525 avPlayer = null; 526 if(i == 999){ 527 done(); 528 } 529 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 530 } 531} 532 533export async function playToCompleted(src, avPlayer, done) { 534 avPlayer = await idle(src, avPlayer) 535 playToCompletedLoop(src, avPlayer, done); 536 await setSource(avPlayer, src); 537} 538 539async function playToCompletedLoop(src, avPlayer, done) { 540 let playToCompletedCount = 0; 541 let surfaceID = globalThis.value; 542 console.info(`case playToCompletedLoop in, surfaceID is ${surfaceID}`); 543 avPlayer.on('stateChange', async (state, reason) => { 544 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 545 console.info(`case state is ${state}`); 546 switch (state) { 547 case AV_PLAYER_STATE.INITIALIZED: 548 avPlayer.surfaceId = surfaceID; 549 console.info('playToCompletedLoop play state is INITIALIZED') 550 // step 1: initialized -> prepared -> play 551 await preparePromise(avPlayer); 552 await sleep(2000); 553 avPlayer.play() 554 break; 555 case AV_PLAYER_STATE.PLAYING: 556 avPlayer.loop = false; 557 console.info('playToCompletedLoop play state is PLAYING') 558 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 559 playToCompletedCount++; 560 if(playToCompletedCount == 1001){ 561 // step 4: playing -> stop -> release 562 avPlayer.stop().then(() => { 563 console.info('playToCompletedLoop avPlayer from play to stop') 564 avPlayer.release().then(() => { 565 console.info('playToCompletedLoop avPlayer from stop to release') 566 done(); 567 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 568 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 569 }else{ 570 // step 2: playing -> seek loop 571 avPlayer.seek(10034, media.SeekMode.SEEK_NEXT_SYNC) 572 console.info('playToCompletedLoop avPlayer from play to seek,time is :' + playToCompletedCount) 573 } 574 break; 575 case AV_PLAYER_STATE.COMPLETED: 576 expect(avPlayer.currentTime).assertEqual(avPlayer.duration); 577 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); 578 console.info('playToCompletedLoop avPlayer from COMPLETED to play') 579 // step 3: COMPLETED -> play loop 580 avPlayer.play(); 581 break; 582 case AV_PLAYER_STATE.ERROR: 583 expect().assertFail(); 584 avPlayer.release().then(() => { 585 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 586 break; 587 default: 588 break; 589 } 590 }); 591 avPlayer.on('error', async (err) => { 592 console.error(`case error called, errMessage is ${err.message}`); 593 expect().assertFail(); 594 await avPlayer.release().then(() => { 595 avPlayer = null; 596 done(); 597 }); 598 }); 599} 600 601export async function seekLoop(src, avPlayer, done) { 602 let surfaceID = globalThis.value; 603 avPlayer = await idle(src, avPlayer) 604 seekLoopWithCallback(avPlayer); 605 await setSource(avPlayer, src); 606 console.info('seekLoop setSource'); 607 await sleep(20); 608 if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { 609 avPlayer.surfaceId = surfaceID; 610 console.info('seekLoop case prepare success'); 611 await preparePromise(avPlayer); 612 await sleep(2000); 613 } 614 await avPlayer.play().then(() => { 615 console.info('seekLoop play success'); 616 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 617 }, (err) => { 618 console.error('seekLoop play filed,error message is :' + err.message) 619 }) 620 await seekLoopWithCallback(avPlayer) 621 console.info('seekLoop avPlayer from play to seek') 622 // play seek loop 1000 times 623 await avPlayer.stop().then(() => { 624 console.info('seekLoopWithCallback avPlayer from play to stop') 625 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 626 await avPlayer.release().then(() => { 627 console.info('seekLoopWithCallback avPlayer from stop to release') 628 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 629 done(); 630 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 631} 632 633async function seekLoopWithCallback(avPlayer) { 634 for (let loopTime = 0; loopTime < 5000; loopTime += 5) { 635 await new Promise(resolve => { 636 avPlayer.on('seekDone', seekDoneTime => { 637 console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`); 638 resolve(); 639 }); 640 avPlayer.seek(loopTime); 641 console.info(`case seekLoopWithCallback loopTime is ${loopTime}`); 642 }); 643 } 644} 645 646export async function seekLoopWithoutCallback(src, avPlayer, done) { 647 let surfaceID = globalThis.value; 648 console.info(`case Initialized in, surfaceID is ${surfaceID}`); 649 avPlayer = await idle(src, avPlayer) 650 await setSource(avPlayer, src); 651 console.info('seekLoopWithoutCallback setSource'); 652 await sleep(20); 653 if(avPlayer.state == 'initialized') { 654 avPlayer.surfaceId = surfaceID; 655 await preparePromise(avPlayer); 656 await sleep(2000); 657 } 658 await avPlayer.play().then(() => { 659 console.info('seekLoopWithoutCallback play success'); 660 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 661 }, (err) => { 662 console.error('seekLoopWithoutCallback play filed,error message is :' + err.message) 663 }) 664 if(avPlayer.state == AV_PLAYER_STATE.PLAYING){ 665 console.info('seekLoopWithoutCallback avPlayer from play to seek') 666 // play seek loop 1000 times 667 for(var loopTime = 0;loopTime < 1000; loopTime++){ 668 avPlayer.seek(loopTime) 669 console.info(`case seekLoopWithoutCallback loopTime is ${loopTime}`); 670 } 671 } 672 await avPlayer.stop().then(() => { 673 console.info('seekLoopWithoutCallback avPlayer from play to stop') 674 avPlayer.release().then(() => { 675 console.info('seekLoopWithoutCallback avPlayer from stop to release') 676 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 677 done(); 678 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 679 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 680} 681 682export async function prepareToStopLoop(src, avPlayer, done) { 683 let surfaceID = globalThis.value; 684 console.info(`case prepareToStopLoop Initialized in, surfaceID is ${surfaceID}`); 685 avPlayer = await idle(src, avPlayer) 686 setSource(avPlayer, src); 687 console.info('prepareToStopLoop setSource'); 688 await sleep(20); 689 if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { 690 avPlayer.surfaceId = surfaceID; 691 } 692 // prepare to stop loop 1000 times 693 for(var i = 0;i < 1000; i++){ 694 await avPlayer.prepare().then(() => { 695 expect(avPlayer.state).assertEqual('prepared'); 696 console.info('prepareToStopLoop avPlayer state is prepared') 697 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 698 699 console.info('prepareToStopLoop avPlayer from prepare to stop') 700 701 await avPlayer.stop().then(() => { 702 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); 703 console.info('prepareToStopLoop avPlayer state is stop') 704 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 705 706 console.info(`case PrepareToStopLoop is ${i}`); 707 } 708 await avPlayer.release().then(() => { 709 console.info('prepareToStopLoop avPlayer from stop to release') 710 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 711 done(); 712 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 713} 714 715export async function prepareToResetLoop(src, avPlayer, done) { 716 let surfaceID = globalThis.value; 717 console.info(`case prepareToResetLoop Initialized in, surfaceID is ${surfaceID}`); 718 avPlayer = await idle(src, avPlayer) 719 // url -> prepare -> play -> reset loop 1000 times 720 for(var i = 0;i < 1000; i++){ 721 await setSource(avPlayer, src); 722 console.info('prepareToResetLoop setSource'); 723 console.info('prepareToResetLoop avPlayer state is :' + avPlayer.state) 724 await sleep(20) 725 avPlayer.surfaceId = surfaceID; 726 await avPlayer.prepare().then(() => { 727 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 728 console.info('prepareToResetLoop avPlayer state is prepared') 729 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 730 731 await avPlayer.play().then(() => { 732 console.info('prepareToResetLoop play success'); 733 expect(avPlayer.state).assertEqual('playing'); 734 }, (err) => { 735 console.error('prepareToResetLoop play filed,error message is :' + err.message) 736 }) 737 738 await avPlayer.reset().then(() => { 739 expect(avPlayer.state).assertEqual('idle'); 740 console.info('prepareToResetLoop avPlayer state is reset') 741 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 742 743 console.info(`case prepareToReset loop is ${i}`); 744 } 745 746 await avPlayer.release().then(() => { 747 console.info('prepareToResetLoop avPlayer from stop to release') 748 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 749 done(); 750 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 751} 752 753export async function createToReleaseLoop(src, avPlayer, done) { 754 for(var i = 0;i < 1000; i++){ 755 let surfaceID = globalThis.value; 756 console.info(`case createToReleaseLoop Initialized in, surfaceID is ${surfaceID}`); 757 avPlayer = await idle(src, avPlayer) 758 // url -> prepare -> play -> reset loop 1000 times 759 await setSource(avPlayer, src); 760 console.info('createToReleaseLoop setSource'); 761 await sleep(20) 762 avPlayer.surfaceId = surfaceID; 763 await avPlayer.prepare().then(() => { 764 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 765 console.info('createToReleaseLoop avPlayer state is prepared') 766 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 767 768 await avPlayer.play().then(() => { 769 console.info('createToReleaseLoop play success'); 770 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 771 }, (err) => { 772 console.error('createToReleaseLoop play filed,error message is :' + err.message) 773 }) 774 await avPlayer.release().then(() => { 775 console.info('createToReleaseLoop avPlayer from stop to release') 776 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 777 if(i==999){ 778 done(); 779 } 780 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 781 console.info(`case createToReleaseLoop loop is ${i}`); 782 } 783} 784 785let createLoopTime = 0; 786let createTotalTime = 0; 787let createStart; 788export async function createTimeWithCallback(src, avPlayer, done) { 789 avPlayer = await idle(src, avPlayer) 790 createStart = Date.now(); 791 console.info(`createTimeWithCallback createStart time is : ${createStart}`) 792 createTimeCallback(src, avPlayer, done) 793} 794 795function createTimeCallback(src, avPlayer, done){ 796 let end; 797 let execution; 798 avPlayer.on('stateChange', async (state, reason) => { 799 console.info(`createTimeCallback stateChange called, state is ${state}, reason is ${reason}`); 800 console.info(`createTimeCallback state is ${state}`); 801 switch (state) { 802 case AV_PLAYER_STATE.IDLE: 803 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 804 end = Date.now(); 805 console.info(`createTimeCallback end time is : ${end}`) 806 execution = parseInt(end - createStart) 807 createTotalTime = createTotalTime + execution; 808 console.info("createTimeCallback execution time is :" + execution) 809 createLoopTime++; 810 avPlayer.release() 811 case AV_PLAYER_STATE.RELEASED: 812 console.info('createTimeCallback play state is release') 813 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 814 if(createLoopTime == 10){ 815 let avg = createTotalTime/10; 816 console.info("createTimeCallback avg time is :" + avg) 817 createLoopTime = 0; 818 createTotalTime = 0; 819 done(); 820 }else{ 821 avPlayer = null; 822 createTimeWithCallback(src, avPlayer, done) 823 } 824 break; 825 default: 826 break; 827 } 828 }); 829} 830 831export async function createTimeWithoutCallback(src, avPlayer, done) { 832 let totalTime = 0; 833 for(var i = 0;i < 10;i++){ 834 let start = Date.now(); 835 console.info(`createTimeWithoutCallback start time is : ${start}`) 836 avPlayer = await idle(src, avPlayer) 837 let end = Date.now() 838 let execution = parseInt(end - start) 839 console.info("createTimeWithoutCallback execution time is :" + execution) 840 totalTime = totalTime + execution; 841 await avPlayer.release().then(() => { 842 console.info('createTimeWithoutCallback avPlayer is release') 843 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 844 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 845 } 846 let avg = totalTime/10; 847 console.info("createTimeWithoutCallback avg time is :" + avg) 848 done(); 849} 850 851export async function prepareTimeWithoutCallback(src, avPlayer, done) { 852 let totalTime = 0; 853 let surfaceID = globalThis.value; 854 for(var i = 0;i < 10;i++){ 855 avPlayer = await idle(src, avPlayer) 856 await setSource(avPlayer, src); 857 console.info('prepareTimeWithoutCallback setSource'); 858 await sleep(20) 859 avPlayer.surfaceId = surfaceID; 860 let start = Date.now(); 861 console.info(`prepareTimeWithoutCallback start time is : ${start}`) 862 let end; 863 await avPlayer.prepare().then(() => { 864 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 865 console.info('prepareTimeWithoutCallback avPlayer state is prepared') 866 end = Date.now() 867 console.info(`prepareTimeWithoutCallback end time is : ${end}`) 868 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 869 let execution = parseInt(end - start) 870 console.info("prepareTimeWithoutCallback execution time is :" + execution) 871 totalTime = totalTime + execution; 872 await avPlayer.release().then(() => { 873 console.info('prepareTimeWithoutCallback avPlayer is release') 874 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 875 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 876 } 877 let avg = totalTime/10; 878 console.info("prepareTimeWithoutCallback avg time is :" + avg) 879 done(); 880} 881 882export async function prepareTimeWithCallback(src, avPlayer, done) { 883 avPlayer = await idle(src, avPlayer) 884 prepareTimeCallback(src, avPlayer, done) 885 await setSource(avPlayer, src); 886} 887 888async function prepareTimeCallback(src, avPlayer, done) { 889 let surfaceID = globalThis.value; 890 let start; 891 let end; 892 let execution; 893 let loopTime = 0; 894 let totalTime = 0; 895 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 896 avPlayer.on('stateChange', async (state, reason) => { 897 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 898 console.info(`case state is ${state}`); 899 switch (state) { 900 case AV_PLAYER_STATE.IDLE: 901 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 902 if(loopTime == 10){ 903 avPlayer.release().then(() => { 904 console.info('prepareTimeWithCallback avPlayer is release') 905 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 906 avPlayer = null; 907 let avg = totalTime/10; 908 console.info("prepareTimeWithCallback avg time is :" + avg) 909 done(); 910 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 911 }else{ 912 setSource(avPlayer, src) 913 } 914 case AV_PLAYER_STATE.INITIALIZED: 915 avPlayer.surfaceId = surfaceID; 916 console.info('prepareTimeWithCallback play state is INITIALIZED') 917 // step 1: initialized -> prepared 918 start = Date.now(); 919 console.info(`prepareTimeWithCallback start time is : ${start}`) 920 avPlayer.prepare() 921 break; 922 case AV_PLAYER_STATE.PREPARED: 923 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 924 console.info('prepareTimeWithCallback avPlayer state is prepared') 925 end = Date.now(); 926 console.info(`prepareTimeWithCallback end time is : ${end}`) 927 execution = parseInt(end - start) 928 console.info("prepareTimeWithCallback execution time is :" + execution) 929 totalTime = totalTime + execution; 930 loopTime++; 931 avPlayer.reset() 932 break; 933 default: 934 break; 935 } 936 }); 937} 938 939export async function playTimeWithoutCallback(src, avPlayer, done) { 940 let totalTime = 0; 941 let surfaceID = globalThis.value; 942 for(var i = 0;i < 10;i++){ 943 avPlayer = await idle(src, avPlayer) 944 await setSource(avPlayer, src); 945 console.info('playTimeWithoutCallback setSource'); 946 await sleep(20) 947 avPlayer.surfaceId = surfaceID; 948 await avPlayer.prepare().then(() => { 949 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 950 console.info('playTimeWithoutCallback avPlayer state is prepared') 951 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 952 let start = Date.now(); 953 let end; 954 console.info(`playTimeWithoutCallback start time is : ${start}`) 955 await avPlayer.play().then(() => { 956 end = Date.now(); 957 console.info(`playTimeWithoutCallback end time is : ${end}`) 958 console.info('playTimeWithoutCallback play success'); 959 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 960 }, (err) => { 961 console.error('playTimeWithoutCallback play filed,error message is :' + err.message) 962 }) 963 let execution = parseInt(end - start) 964 console.info("playTimeWithoutCallback execution time is :" + execution) 965 totalTime = totalTime + execution; 966 await avPlayer.release().then(() => { 967 console.info('playTimeWithoutCallback avPlayer is release') 968 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 969 avPlayer = null; 970 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 971 } 972 let avg = totalTime/10; 973 console.info("playTimeWithoutCallback avg time is :" + avg) 974 done(); 975} 976 977export async function playTimeWithCallback(src, avPlayer, done) { 978 avPlayer = await idle(src, avPlayer) 979 playTimeCallback(avPlayer, done) 980 await setSource(avPlayer, src); 981} 982 983export function playTimeCallback(avPlayer, done) { 984 let surfaceID = globalThis.value; 985 let start; 986 let end; 987 let execution; 988 let loopTime = 0; 989 let totalTime = 0; 990 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 991 avPlayer.on('stateChange', async (state, reason) => { 992 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 993 console.info(`case state is ${state}`); 994 switch (state) { 995 case AV_PLAYER_STATE.INITIALIZED: 996 avPlayer.surfaceId = surfaceID; 997 console.info('playTimeCallback play state is INITIALIZED') 998 // step 1: initialized -> prepared 999 avPlayer.prepare((err) => { 1000 if (err != null) { 1001 console.error(`case prepare error, errMessage is ${err.message}`); 1002 expect().assertFail(); 1003 done(); 1004 } else { 1005 console.info('playTimeCallback play state is prepared') 1006 } 1007 }); 1008 await sleep(2000); 1009 break; 1010 case AV_PLAYER_STATE.PREPARED: 1011 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1012 console.info('playTimeCallback avPlayer state is prepared') 1013 start = Date.now(); 1014 console.info(`playTimeCallback start time is : ${start}`) 1015 // step 2: prapared -> play 1016 avPlayer.play() 1017 break; 1018 case AV_PLAYER_STATE.PLAYING: 1019 console.info('playTimeCallback play state is PLAYING') 1020 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1021 end = Date.now(); 1022 console.info(`playTimeCallback end time is : ${end}`) 1023 execution = parseInt(end - start) 1024 console.info("playTimeCallback execution time is :" + execution) 1025 totalTime = totalTime + execution; 1026 loopTime++; 1027 if(loopTime == 10){ 1028 avPlayer.release().then(() => { 1029 console.info('playTimeCallback avPlayer is release') 1030 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1031 avPlayer = null; 1032 let avg = totalTime/10; 1033 console.info("playTimeWithCallback avg time is :" + avg) 1034 done(); 1035 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1036 }else{ 1037 avPlayer.pause() 1038 } 1039 break; 1040 case AV_PLAYER_STATE.PAUSED: 1041 console.info('playTimeWithCallback play state is PAUSED') 1042 expect(avPlayer.state).assertEqual('paused'); 1043 start = Date.now(); 1044 console.info(`playTimeCallback start time is : ${start}`) 1045 // step 3: pause -> playing loop 1046 avPlayer.play().then(() => { 1047 console.info('playTimeWithCallback avPlayer from pause to play') 1048 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1049 break; 1050 default: 1051 break; 1052 } 1053 }); 1054} 1055 1056export async function pauseTimeWithoutCallback(src, avPlayer, done) { 1057 let totalTime = 0; 1058 let surfaceID = globalThis.value; 1059 for(var i = 0;i < 10;i++){ 1060 let execution; 1061 let end; 1062 avPlayer = await idle(src, avPlayer) 1063 await setSource(avPlayer, src); 1064 console.info('pauseTimeWithoutCallback setSource'); 1065 await sleep(20) 1066 avPlayer.surfaceId = surfaceID; 1067 await avPlayer.prepare().then(() => { 1068 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1069 console.info('pauseTimeWithoutCallback avPlayer state is prepared') 1070 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1071 await avPlayer.play().then(() => { 1072 console.info('pauseTimeWithoutCallback play success'); 1073 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1074 }, (err) => { 1075 console.error('pauseTimeWithoutCallback play filed,error message is :' + err.message) 1076 }) 1077 let start = Date.now(); 1078 1079 console.info(`pauseTimeWithoutCallback start time is : ${start}`) 1080 await avPlayer.pause().then(() => { 1081 console.info('pauseTimeWithoutCallback pause success'); 1082 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1083 end = Date.now(); 1084 console.info(`pauseTimeWithoutCallback end time is : ${end}`) 1085 execution = parseInt(end - start) 1086 console.info("pauseTimeWithoutCallback execution time is :" + execution) 1087 }, (err) => { 1088 console.error('pauseTimeWithoutCallback pause filed,error message is :' + err.message) 1089 }) 1090 totalTime = totalTime + execution; 1091 await avPlayer.release().then(() => { 1092 console.info('pauseTimeWithoutCallback avPlayer is release') 1093 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1094 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1095 } 1096 let avg = totalTime/10; 1097 console.info("pauseTimeWithoutCallback avg time is :" + avg) 1098 done(); 1099} 1100 1101export async function pauseTimeWithCallback(src, avPlayer, done) { 1102 avPlayer = await idle(src, avPlayer) 1103 pauseTimeCallback(avPlayer, done) 1104 await setSource(avPlayer, src); 1105} 1106 1107function pauseTimeCallback(avPlayer, done) { 1108 let surfaceID = globalThis.value; 1109 let start; 1110 let end; 1111 let execution; 1112 let loopTime = 0; 1113 let totalTime = 0; 1114 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1115 avPlayer.on('stateChange', async (state, reason) => { 1116 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1117 console.info(`case state is ${state}`); 1118 switch (state) { 1119 case AV_PLAYER_STATE.INITIALIZED: 1120 avPlayer.surfaceId = surfaceID; 1121 console.info('pauseTimeCallback play state is INITIALIZED') 1122 // step 1: initialized -> prepared 1123 avPlayer.prepare((err) => { 1124 if (err != null) { 1125 console.error(`case prepare error, errMessage is ${err.message}`); 1126 expect().assertFail(); 1127 done(); 1128 } else { 1129 console.info('pauseTimeCallback play state is prepared') 1130 } 1131 }); 1132 await sleep(2000); 1133 break; 1134 case AV_PLAYER_STATE.PREPARED: 1135 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1136 console.info('pauseTimeCallback avPlayer state is prepared') 1137 avPlayer.play() 1138 break; 1139 case AV_PLAYER_STATE.PLAYING: 1140 console.info('pauseTimeCallback play state is PLAYING') 1141 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1142 start = Date.now(); 1143 console.info(`pauseTimeCallback start time is : ${start}`) 1144 avPlayer.pause(); 1145 break; 1146 case AV_PLAYER_STATE.PAUSED: 1147 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1148 end = Date.now(); 1149 console.info(`pauseTimeCallback end time is : ${end}`) 1150 execution = parseInt(end - start) 1151 console.info("pauseTimeCallback execution time is :" + execution) 1152 totalTime = totalTime + execution; 1153 loopTime++; 1154 if(loopTime == 10){ 1155 avPlayer.release().then(() => { 1156 console.info('pauseTimeCallback avPlayer is release') 1157 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1158 avPlayer = null; 1159 let avg = totalTime/10; 1160 console.info("pauseTimeCallback avg time is :" + avg) 1161 done(); 1162 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1163 }else{ 1164 avPlayer.play() 1165 } 1166 break; 1167 default: 1168 break; 1169 } 1170 }); 1171} 1172 1173export async function stopTimeWithoutCallback(src, avPlayer, done) { 1174 let totalTime = 0; 1175 let surfaceID = globalThis.value; 1176 for(var i = 0;i < 10;i++){ 1177 avPlayer = await idle(src, avPlayer) 1178 await setSource(avPlayer, src); 1179 console.info('stopTimeWithoutCallback setSource'); 1180 await sleep(20) 1181 avPlayer.surfaceId = surfaceID; 1182 await avPlayer.prepare().then(() => { 1183 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1184 console.info('stopTimeWithoutCallback avPlayer state is prepared') 1185 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1186 await avPlayer.play().then(() => { 1187 console.info('stopTimeWithoutCallback play success'); 1188 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1189 }, (err) => { 1190 console.error('stopTimeWithoutCallback play filed,error message is :' + err.message) 1191 }) 1192 let start = Date.now(); 1193 console.info(`stopTimeWithoutCallback start time is : ${start}`) 1194 let end; 1195 await avPlayer.stop().then(() => { 1196 end = Date.now(); 1197 console.info(`stopTimeWithoutCallback end time is : ${end}`) 1198 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); 1199 console.info('stopTimeWithoutCallback avPlayer state is stop') 1200 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1201 let execution = parseInt(end - start) 1202 console.info("stopTimeWithoutCallback execution time is :" + execution) 1203 totalTime = totalTime + execution; 1204 await avPlayer.release().then(() => { 1205 console.info('stopTimeWithoutCallback avPlayer is release') 1206 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1207 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1208 } 1209 let avg = totalTime/10; 1210 console.info("stopTimeWithoutCallback avg time is :" + avg) 1211 done(); 1212} 1213 1214export async function stopTimeWithCallback(src, avPlayer, done) { 1215 avPlayer = await idle(src, avPlayer) 1216 stopTimeCallback(src, avPlayer, done) 1217 await setSource(avPlayer, src); 1218} 1219 1220function stopTimeCallback(src, avPlayer, done) { 1221 let surfaceID = globalThis.value; 1222 let start; 1223 let end; 1224 let execution; 1225 let loopTime = 0; 1226 let totalTime = 0; 1227 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1228 avPlayer.on('stateChange', async (state, reason) => { 1229 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1230 console.info(`case state is ${state}`); 1231 switch (state) { 1232 case AV_PLAYER_STATE.IDLE: 1233 setSource(avPlayer, src); 1234 break; 1235 case AV_PLAYER_STATE.INITIALIZED: 1236 avPlayer.surfaceId = surfaceID; 1237 console.info('stopTimeCallback play state is INITIALIZED') 1238 // step 1: initialized -> prepared 1239 avPlayer.prepare((err) => { 1240 if (err != null) { 1241 console.error(`case prepare error, errMessage is ${err.message}`); 1242 expect().assertFail(); 1243 done(); 1244 } else { 1245 console.info('stopTimeCallback play state is prepared') 1246 } 1247 }); 1248 await sleep(2000); 1249 break; 1250 case AV_PLAYER_STATE.PREPARED: 1251 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1252 console.info('stopTimeCallback avPlayer state is prepared') 1253 start = Date.now(); 1254 console.info(`stopTimeCallback start time is : ${start}`) 1255 loopTime++; 1256 avPlayer.stop() 1257 break; 1258 case AV_PLAYER_STATE.STOPPED: 1259 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); 1260 end = Date.now(); 1261 console.info(`stopTimeCallback end time is : ${end}`) 1262 execution = parseInt(end - start) 1263 console.info("stopTimeCallback execution time is :" + execution) 1264 totalTime = totalTime + execution; 1265 if(loopTime == 10){ 1266 avPlayer.release().then(() => { 1267 console.info('stopTimeCallback avPlayer is release') 1268 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1269 avPlayer = null; 1270 let avg = totalTime/10; 1271 console.info("stopTimeCallback avg time is :" + avg) 1272 done(); 1273 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1274 }else{ 1275 avPlayer.reset() 1276 } 1277 break; 1278 default: 1279 break; 1280 } 1281 }); 1282} 1283 1284export async function resetTimeWithoutCallback(src, avPlayer, done) { 1285 let totalTime = 0; 1286 let surfaceID = globalThis.value; 1287 for(var i = 0;i < 10;i++){ 1288 avPlayer = await idle(src, avPlayer) 1289 await setSource(avPlayer, src); 1290 console.info('resetTimeWithoutCallback setSource'); 1291 await sleep(20) 1292 avPlayer.surfaceId = surfaceID; 1293 await avPlayer.prepare().then(() => { 1294 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1295 console.info('resetTimeWithoutCallback avPlayer state is prepared') 1296 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1297 let end; 1298 await avPlayer.play().then(() => { 1299 console.info('resetTimeWithoutCallback play success'); 1300 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1301 }, (err) => { 1302 console.error('resetTimeWithoutCallback play filed,error message is :' + err.message) 1303 }) 1304 let start = Date.now(); 1305 console.info(`resetTimeWithoutCallback start time is : ${start}`) 1306 await avPlayer.reset().then(() => { 1307 end = Date.now(); 1308 console.info(`resetTimeWithoutCallback end time is : ${end}`) 1309 console.info('reset success'); 1310 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 1311 }, (err) => { 1312 console.error('reset filed,error message is :' + err.message) 1313 }) 1314 let execution = parseInt(end - start) 1315 console.info("resetTimeWithoutCallback execution time is :" + execution) 1316 totalTime = totalTime + execution; 1317 await avPlayer.release().then(() => { 1318 console.info('resetTimeWithoutCallback avPlayer is release') 1319 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1320 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1321 } 1322 let avg = totalTime/10; 1323 console.info("resetTimeWithoutCallback avg time is :" + avg) 1324 done(); 1325} 1326 1327export async function resetTimeWithCallback(src, avPlayer, done) { 1328 avPlayer = await idle(src, avPlayer) 1329 resetTimeCallback(src, avPlayer, done) 1330 await setSource(avPlayer, src); 1331} 1332 1333function resetTimeCallback(src, avPlayer, done) { 1334 let surfaceID = globalThis.value; 1335 let start; 1336 let end; 1337 let execution; 1338 let loopTime = 0; 1339 let totalTime = 0; 1340 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1341 avPlayer.on('stateChange', async (state, reason) => { 1342 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1343 console.info(`case state is ${state}`); 1344 switch (state) { 1345 case AV_PLAYER_STATE.IDLE: 1346 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 1347 end = Date.now(); 1348 console.info(`resetTimeCallback end time is : ${end}`) 1349 execution = parseInt(end - start) 1350 console.info("resetTimeCallback execution time is :" + execution) 1351 totalTime = totalTime + execution; 1352 loopTime++; 1353 if(loopTime == 10){ 1354 avPlayer.release().then(() => { 1355 console.info('resetTimeCallback avPlayer is release') 1356 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1357 avPlayer = null; 1358 let avg = totalTime/10; 1359 console.info("resetTimeCallback avg time is :" + avg) 1360 done(); 1361 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1362 }else{ 1363 setSource(avPlayer, src) 1364 } 1365 break; 1366 case AV_PLAYER_STATE.INITIALIZED: 1367 avPlayer.surfaceId = surfaceID; 1368 console.info('resetTimeCallback play state is INITIALIZED') 1369 start = Date.now(); 1370 console.info(`resetTimeCallback start time is : ${start}`) 1371 avPlayer.reset().then(() => { 1372 console.info('reset success'); 1373 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1374 break; 1375 default: 1376 break; 1377 } 1378 }); 1379} 1380 1381export async function releaseTimeWithoutCallback(src, avPlayer, done) { 1382 let totalTime = 0; 1383 let surfaceID = globalThis.value; 1384 for(var i = 0;i < 10;i++){ 1385 avPlayer = await idle(src, avPlayer) 1386 await setSource(avPlayer, src); 1387 console.info('releaseTimeWithoutCallback setSource'); 1388 await sleep(20) 1389 avPlayer.surfaceId = surfaceID; 1390 let start = Date.now(); 1391 console.info(`releaseTimeWithoutCallback start time is : ${start}`) 1392 let end; 1393 await avPlayer.release().then(() => { 1394 console.info('releaseTimeWithoutCallback avPlayer is release') 1395 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1396 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1397 end = Date.now(); 1398 console.info(`releaseTimeWithoutCallback end time is : ${end}`) 1399 let execution = parseInt(end - start) 1400 console.info("releaseTimeWithoutCallback execution time is :" + execution) 1401 totalTime = totalTime + execution; 1402 } 1403 let avg = totalTime/10; 1404 console.info("releaseTimeWithoutCallback avg time is :" + avg) 1405 done(); 1406} 1407 1408let releaseTotalTime = 0; 1409let releaseLoop = 0; 1410export async function releaseTimeWithCallback(src, avPlayer, done) { 1411 avPlayer = await idle(src, avPlayer) 1412 releaseTimeCallback(src, avPlayer, done) 1413 await setSource(avPlayer, src); 1414} 1415 1416function releaseTimeCallback(src, avPlayer, done) { 1417 let surfaceID = globalThis.value; 1418 let start; 1419 let end; 1420 let execution; 1421 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1422 avPlayer.on('stateChange', async (state, reason) => { 1423 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1424 console.info(`case state is ${state}`); 1425 switch (state) { 1426 case AV_PLAYER_STATE.INITIALIZED: 1427 avPlayer.surfaceId = surfaceID; 1428 console.info('releaseTimeCallback play state is INITIALIZED') 1429 start = Date.now(); 1430 console.info(`releaseTimeCallback start time is : ${start}`) 1431 avPlayer.release() 1432 break; 1433 case AV_PLAYER_STATE.RELEASED: 1434 console.info('releaseTimeCallback play state is release') 1435 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1436 end = Date.now(); 1437 console.info(`releaseTimeCallback end time is : ${end}`) 1438 execution = parseInt(end - start) 1439 console.info("releaseTimeCallback execution time is :" + execution) 1440 releaseTotalTime = releaseTotalTime + execution; 1441 releaseLoop++; 1442 if(releaseLoop == 10){ 1443 let avg = releaseTotalTime/10; 1444 console.info("createTimeCallback avg time is :" + avg) 1445 releaseTotalTime = 0; 1446 releaseLoop = 0; 1447 done(); 1448 }else{ 1449 avPlayer = null; 1450 releaseTimeWithCallback(src, avPlayer, done) 1451 } 1452 break; 1453 default: 1454 break; 1455 } 1456 }); 1457} 1458 1459export function getTotalTime(releaseTotalTime){ 1460 return releaseTotalTime; 1461} 1462 1463export async function seekTimeWithoutCallback(src, avPlayer, done) { 1464 let totalTime = 0; 1465 let surfaceID = globalThis.value; 1466 for(var i = 0;i < 10;i++){ 1467 avPlayer = await idle(src, avPlayer) 1468 await setSource(avPlayer, src); 1469 console.info('seekTimeWithoutCallback setSource'); 1470 await sleep(20) 1471 avPlayer.surfaceId = surfaceID; 1472 await avPlayer.prepare().then(() => { 1473 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1474 console.info('seekTimeWithoutCallback avPlayer state is prepared') 1475 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1476 let end; 1477 await avPlayer.play().then(() => { 1478 console.info('seekTimeWithoutCallback play success'); 1479 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1480 }, (err) => { 1481 console.error('seekTimeWithoutCallback play filed,error message is :' + err.message) 1482 }) 1483 let start = Date.now(); 1484 console.info(`seekTimeWithoutCallback start time is : ${start}`) 1485 await avPlayer.seek(100) 1486 end = Date.now(); 1487 console.info(`seekTimeWithoutCallback end time is : ${end}`) 1488 let execution = parseInt(end - start) 1489 console.info("seekTimeWithoutCallback execution time is :" + execution) 1490 totalTime = totalTime + execution; 1491 await avPlayer.release().then(() => { 1492 console.info('seekTimeWithoutCallback avPlayer is release') 1493 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1494 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1495 } 1496 let avg = totalTime/10; 1497 console.info("seekTimeWithoutCallback avg time is :" + avg) 1498 done(); 1499} 1500 1501export async function seekTimeWithCallback(src, avPlayer, done) { 1502 avPlayer = await idle(src, avPlayer) 1503 seekTimeCallback(avPlayer, done) 1504 await setSource(avPlayer, src); 1505} 1506 1507function seekTimeCallback(avPlayer, done) { 1508 let surfaceID = globalThis.value; 1509 let start; 1510 let end; 1511 let execution; 1512 let loopTime = 0; 1513 let totalTime = 0; 1514 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1515 avPlayer.on('stateChange', async (state, reason) => { 1516 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1517 console.info(`case state is ${state}`); 1518 switch (state) { 1519 case AV_PLAYER_STATE.INITIALIZED: 1520 avPlayer.surfaceId = surfaceID; 1521 console.info('seekTimeCallback play state is INITIALIZED') 1522 avPlayer.prepare((err) => { 1523 if (err != null) { 1524 console.error(`case prepare error, errMessage is ${err.message}`); 1525 expect().assertFail(); 1526 done(); 1527 } else { 1528 console.info('seekTimeCallback play state is prepared') 1529 } 1530 }); 1531 await sleep(2000); 1532 break; 1533 case AV_PLAYER_STATE.PREPARED: 1534 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1535 console.info('seekTimeCallback avPlayer state is prepared') 1536 avPlayer.play() 1537 break; 1538 case AV_PLAYER_STATE.PLAYING: 1539 console.info('seekTimeCallback play state is PLAYING') 1540 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1541 start = Date.now(); 1542 console.info(`seekTimeCallback start time is : ${start}`) 1543 loopTime+=20; 1544 if(loopTime == 220){ 1545 avPlayer.release().then(() => { 1546 console.info('seekTimeCallback avPlayer is release') 1547 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1548 avPlayer = null; 1549 let avg = totalTime/10; 1550 console.info("seekTimeCallback avg time is :" + avg) 1551 done(); 1552 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1553 }else{ 1554 avPlayer.seek(loopTime) 1555 } 1556 break; 1557 case AV_PLAYER_STATE.PAUSED: 1558 console.info('seekTimeCallback play state is PAUSED') 1559 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1560 avPlayer.play().then(() => { 1561 console.info('seekTimeCallback avPlayer from pause to play') 1562 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1563 break; 1564 default: 1565 break; 1566 } 1567 }); 1568 avPlayer.on('seekDone', async (seekDoneTime) => { 1569 end = Date.now(); 1570 console.info(`seekTimeCallback end time is : ${end}`) 1571 execution = parseInt(end - start) 1572 console.info("seekTimeCallback execution time is :" + execution) 1573 totalTime = totalTime + execution; 1574 console.info(`case seekDone called seekDoneTime is ${seekDoneTime}`); 1575 avPlayer.pause() 1576 }); 1577} 1578 1579export async function getTrackDescriptionTimeWithoutCallback(src, avPlayer, done) { 1580 let totalTime = 0; 1581 let surfaceID = globalThis.value; 1582 for(var i = 0;i < 10;i++){ 1583 avPlayer = await idle(src, avPlayer) 1584 await setSource(avPlayer, src); 1585 console.info('getTrackDescriptionTimeWithoutCallback setSource'); 1586 await sleep(20) 1587 avPlayer.surfaceId = surfaceID; 1588 await avPlayer.prepare().then(() => { 1589 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1590 console.info('getTrackDescriptionTimeWithoutCallback avPlayer state is prepared') 1591 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1592 await avPlayer.play().then(() => { 1593 console.info('getTrackDescriptionTimeWithoutCallback play success'); 1594 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1595 }, (err) => { 1596 console.error('getTrackDescriptionTimeWithoutCallback play filed,error message is :' + err.message) 1597 }) 1598 let arrayDescription; 1599 let start = Date.now(); 1600 console.info(`getTrackDescriptionTimeWithoutCallback start time is : ${start}`) 1601 let end; 1602 await avPlayer.getTrackDescription().then((arrList) => { 1603 if (arrList != null) { 1604 arrayDescription = arrList; 1605 } else { 1606 console.log('video getTrackDescription fail'); 1607 } 1608 }).catch((error) => { 1609 console.info(`video catchCallback, error:${error}`); 1610 }); 1611 end = Date.now(); 1612 console.info(`getTrackDescriptionTimeWithoutCallback end time is : ${end}`) 1613 let execution = parseInt(end - start) 1614 console.info("getTrackDescriptionTimeWithoutCallback execution time is :" + execution) 1615 totalTime = totalTime + execution; 1616 await avPlayer.release().then(() => { 1617 console.info('getTrackDescriptionTimeWithoutCallback avPlayer is release') 1618 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1619 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1620 } 1621 let avg = totalTime/10; 1622 console.info("getTrackDescriptionTimeWithoutCallback avg time is :" + avg) 1623 done(); 1624} 1625 1626export async function getTrackDescriptionTimeWithCallback(src, avPlayer, done) { 1627 avPlayer = await idle(src, avPlayer) 1628 getTrackDescriptionTimeCallback(avPlayer, done) 1629 await setSource(avPlayer, src); 1630} 1631 1632function getTrackDescriptionTimeCallback(avPlayer, done) { 1633 let surfaceID = globalThis.value; 1634 let start; 1635 let end; 1636 let execution; 1637 let loopTime = 0; 1638 let totalTime = 0; 1639 let arrayDescription; 1640 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1641 avPlayer.on('stateChange', async (state, reason) => { 1642 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1643 console.info(`case state is ${state}`); 1644 switch (state) { 1645 case AV_PLAYER_STATE.INITIALIZED: 1646 avPlayer.surfaceId = surfaceID; 1647 console.info('getTrackDescriptionTimeCallback play state is INITIALIZED') 1648 avPlayer.prepare((err) => { 1649 if (err != null) { 1650 console.error(`case prepare error, errMessage is ${err.message}`); 1651 expect().assertFail(); 1652 done(); 1653 } else { 1654 console.info('getTrackDescriptionTimeCallback play state is prepared') 1655 } 1656 }); 1657 await sleep(2000); 1658 break; 1659 case AV_PLAYER_STATE.PREPARED: 1660 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1661 console.info('getTrackDescriptionTimeCallback avPlayer state is prepared') 1662 avPlayer.play() 1663 break; 1664 case AV_PLAYER_STATE.PLAYING: 1665 console.info('getTrackDescriptionTimeCallback play state is PLAYING') 1666 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1667 start = Date.now(); 1668 console.info(`getTrackDescriptionTimeCallback start time is : ${start}`) 1669 if(loopTime == 10){ 1670 avPlayer.release().then(() => { 1671 console.info('getTrackDescriptionTimeCallback avPlayer is release') 1672 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1673 avPlayer = null; 1674 let avg = totalTime/10; 1675 console.info("getTrackDescriptionTimeCallback avg time is :" + avg) 1676 done(); 1677 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1678 }else{ 1679 loopTime++; 1680 avPlayer.getTrackDescription().then((arrList) => { 1681 if (arrList != null) { 1682 arrayDescription = arrList; 1683 end = Date.now(); 1684 console.info(`getTrackDescriptionTimeCallback end time is : ${end}`) 1685 execution = parseInt(end - start) 1686 console.info("getTrackDescriptionTimeCallback execution time is :" + execution) 1687 totalTime = totalTime + execution; 1688 1689 } else { 1690 console.log('video getTrackDescription fail'); 1691 } 1692 }).catch((error) => { 1693 console.info(`video catchCallback, error:${error}`); 1694 }); 1695 avPlayer.pause() 1696 } 1697 break; 1698 case AV_PLAYER_STATE.PAUSED: 1699 console.info('getTrackDescriptionTimeCallback play state is PAUSED') 1700 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1701 avPlayer.play().then(() => { 1702 console.info('getTrackDescriptionTimeCallback avPlayer from pause to play') 1703 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1704 break; 1705 default: 1706 break; 1707 } 1708 }); 1709} 1710 1711export async function setSpeedTimeWithoutCallback(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('setSpeedTimeWithoutCallback 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('setSpeedTimeWithoutCallback avPlayer state is prepared') 1723 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1724 let start = Date.now(); 1725 console.info(`setSpeedTimeWithoutCallback start time is : ${start}`) 1726 await avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X); 1727 let end = Date.now(); 1728 console.info(`setSpeedTimeWithoutCallback end time is : ${end}`) 1729 let execution = parseInt(end - start) 1730 console.info("setSpeedTimeWithoutCallback execution time is :" + execution) 1731 totalTime = totalTime + execution; 1732 await avPlayer.release().then(() => { 1733 console.info('setSpeedTimeWithoutCallback avPlayer is release') 1734 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1735 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1736 } 1737 let avg = totalTime/10; 1738 console.info("setSpeedTimeWithoutCallback avg time is :" + avg) 1739 done(); 1740} 1741 1742export async function setSpeedTimeWithCallback(src, avPlayer, done) { 1743 avPlayer = await idle(src, avPlayer) 1744 setSpeedTimeCallback(avPlayer, done) 1745 await setSource(avPlayer, src); 1746} 1747 1748function setSpeedTimeCallback(avPlayer, done) { 1749 let surfaceID = globalThis.value; 1750 let start; 1751 let end; 1752 let execution; 1753 let loopTime = 0; 1754 let totalTime = 0; 1755 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1756 avPlayer.on('stateChange', async (state, reason) => { 1757 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1758 console.info(`case state is ${state}`); 1759 switch (state) { 1760 case AV_PLAYER_STATE.INITIALIZED: 1761 avPlayer.surfaceId = surfaceID; 1762 console.info('setSpeedTimeCallback play state is INITIALIZED') 1763 // step 1: initialized -> prepared 1764 avPlayer.prepare((err) => { 1765 if (err != null) { 1766 console.error(`case prepare error, errMessage is ${err.message}`); 1767 expect().assertFail(); 1768 done(); 1769 } else { 1770 console.info('setSpeedTimeCallback play state is prepared') 1771 } 1772 }); 1773 await sleep(2000); 1774 break; 1775 case AV_PLAYER_STATE.PREPARED: 1776 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1777 console.info('setSpeedTimeCallback avPlayer state is prepared') 1778 avPlayer.play() 1779 break; 1780 case AV_PLAYER_STATE.PLAYING: 1781 console.info('setSpeedTimeCallback play state is PLAYING') 1782 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1783 if(loopTime == 10){ 1784 avPlayer.release().then(() => { 1785 console.info('setSpeedTimeCallback avPlayer is release') 1786 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1787 let avg = totalTime/10; 1788 console.info("setSpeedTimeCallback avg time is :" + avg) 1789 done(); 1790 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1791 }else{ 1792 start = Date.now(); 1793 console.info(`setSpeedTimeCallback start time is : ${start}`) 1794 loopTime++ 1795 avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_1_00_X); 1796 } 1797 break; 1798 case AV_PLAYER_STATE.PAUSED: 1799 console.info('setSpeedTimeCallback play state is PAUSED') 1800 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1801 avPlayer.play().then(() => { 1802 console.info('setSpeedTimeCallback avPlayer from pause to play') 1803 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1804 break; 1805 default: 1806 break; 1807 } 1808 }); 1809 avPlayer.on('speedDone', (speed) => { 1810 end = Date.now(); 1811 console.info(`setSpeedTimeCallback end time is : ${end}`) 1812 execution = parseInt(end - start) 1813 console.info("setSpeedTimeCallback execution time is :" + execution) 1814 totalTime = totalTime + execution; 1815 console.info('speedDone success,and speed value is:' + speed) 1816 avPlayer.pause() 1817 }); 1818} 1819 1820export async function setBitrateTimeWithoutCallback(src, avPlayer, done) { 1821 let totalTime = 0; 1822 let surfaceID = globalThis.value; 1823 for(var i = 0;i < 10;i++){ 1824 avPlayer = await idle(src, avPlayer) 1825 await setSource(avPlayer, src); 1826 console.info('setBitrateTimeWithoutCallback setSource'); 1827 await sleep(20) 1828 avPlayer.surfaceId = surfaceID; 1829 await avPlayer.prepare().then(() => { 1830 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1831 console.info('setBitrateTimeWithoutCallback avPlayer state is prepared') 1832 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1833 let start = Date.now(); 1834 console.info(`setBitrateTimeWithoutCallback start time is : ${start}`) 1835 let bitrate = 96000 1836 await avPlayer.setBitrate(bitrate) 1837 let end = Date.now(); 1838 console.info(`setBitrateTimeWithoutCallback end time is : ${end}`) 1839 let execution = parseInt(end - start) 1840 console.info("setBitrateTimeWithoutCallback execution time is :" + execution) 1841 totalTime = totalTime + execution; 1842 await avPlayer.release().then(() => { 1843 console.info('setBitrateTimeWithoutCallback avPlayer is release') 1844 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1845 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1846 } 1847 let avg = totalTime/10; 1848 console.info("setBitrateTimeWithoutCallback avg time is :" + avg) 1849 done(); 1850} 1851 1852export async function setBitrateTimeWithCallback(src, avPlayer, done) { 1853 avPlayer = await idle(src, avPlayer) 1854 playTimeCallback(avPlayer, done) 1855 await setSource(avPlayer, src); 1856} 1857 1858function setBitrateTimeCallback(avPlayer, done) { 1859 let surfaceID = globalThis.value; 1860 let start; 1861 let end; 1862 let execution; 1863 let loopTime = 0; 1864 let totalTime = 0; 1865 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1866 avPlayer.on('stateChange', async (state, reason) => { 1867 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1868 console.info(`case state is ${state}`); 1869 switch (state) { 1870 case AV_PLAYER_STATE.INITIALIZED: 1871 avPlayer.surfaceId = surfaceID; 1872 console.info('setBitrateTimeCallback play state is INITIALIZED') 1873 // step 1: initialized -> prepared 1874 avPlayer.prepare((err) => { 1875 if (err != null) { 1876 console.error(`case prepare error, errMessage is ${err.message}`); 1877 expect().assertFail(); 1878 done(); 1879 } else { 1880 console.info('setBitrateTimeCallback play state is prepared') 1881 } 1882 }); 1883 await sleep(2000); 1884 break; 1885 case AV_PLAYER_STATE.PREPARED: 1886 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1887 console.info('setBitrateTimeCallback avPlayer state is prepared') 1888 avPlayer.play() 1889 break; 1890 case AV_PLAYER_STATE.PLAYING: 1891 console.info('setBitrateTimeCallback play state is PLAYING') 1892 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 1893 if(loopTime == 10){ 1894 avPlayer.release().then(() => { 1895 console.info('setBitrateTimeCallback avPlayer is release') 1896 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1897 let avg = totalTime/10; 1898 console.info("setBitrateTimeCallback avg time is :" + avg) 1899 done(); 1900 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1901 }else{ 1902 start = Date.now(); 1903 console.info(`setBitrateTimeCallback start time is : ${start}`) 1904 loopTime++ 1905 let bitrate = 96000 1906 avPlayer.setBitrate(bitrate) 1907 } 1908 break; 1909 case AV_PLAYER_STATE.PAUSED: 1910 console.info('setBitrateTimeCallback play state is PAUSED') 1911 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 1912 avPlayer.play().then(() => { 1913 console.info('setBitrateTimeCallback avPlayer from pause to play') 1914 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1915 break; 1916 default: 1917 break; 1918 } 1919 }); 1920 avPlayer.on('bitrateDone', (bitrate) => { 1921 end = Date.now(); 1922 console.info(`setBitrateTimeCallback end time is : ${end}`) 1923 execution = parseInt(end - start) 1924 console.info("setBitrateTimeCallback execution time is :" + execution) 1925 totalTime = totalTime + execution; 1926 console.info('bitrate success,and speed value is:' + bitrate) 1927 avPlayer.pause() 1928 }); 1929} 1930 1931export async function setVolumeTimeWithoutCallback(src, avPlayer, done) { 1932 let totalTime = 0; 1933 let surfaceID = globalThis.value; 1934 for(var i = 0;i < 10;i++){ 1935 avPlayer = await idle(src, avPlayer) 1936 await setSource(avPlayer, src); 1937 console.info('setVolumeTimeWithoutCallback setSource'); 1938 await sleep(20) 1939 avPlayer.surfaceId = surfaceID; 1940 await avPlayer.prepare().then(() => { 1941 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1942 console.info('setVolumeTimeWithoutCallback avPlayer state is prepared') 1943 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1944 let start = Date.now(); 1945 console.info(`setVolumeTimeWithoutCallback start time is : ${start}`) 1946 let volume = 1.0 1947 avPlayer.setVolume(volume) 1948 let end = Date.now(); 1949 console.info(`setVolumeTimeWithoutCallback end time is : ${end}`) 1950 let execution = parseInt(end - start) 1951 console.info("setVolumeTimeWithoutCallback execution time is :" + execution) 1952 totalTime = totalTime + execution; 1953 await avPlayer.release().then(() => { 1954 console.info('setVolumeTimeWithoutCallback avPlayer is release') 1955 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 1956 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 1957 } 1958 let avg = totalTime/10; 1959 console.info("setVolumeTimeWithoutCallback avg time is :" + avg) 1960 done(); 1961} 1962 1963export async function setVolumeTimeWithCallback(src, avPlayer, done) { 1964 avPlayer = await idle(src, avPlayer) 1965 playTimeCallback(avPlayer, done) 1966 await setSource(avPlayer, src); 1967} 1968 1969function setVolumeTimeCallback(avPlayer, done) { 1970 let surfaceID = globalThis.value; 1971 let start; 1972 let end; 1973 let execution; 1974 let loopTime = 0; 1975 let totalTime = 0; 1976 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 1977 avPlayer.on('stateChange', async (state, reason) => { 1978 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 1979 console.info(`case state is ${state}`); 1980 switch (state) { 1981 case AV_PLAYER_STATE.INITIALIZED: 1982 avPlayer.surfaceId = surfaceID; 1983 console.info('setVolumeTimeCallback play state is INITIALIZED') 1984 // step 1: initialized -> prepared 1985 avPlayer.prepare((err) => { 1986 if (err != null) { 1987 console.error(`case prepare error, errMessage is ${err.message}`); 1988 expect().assertFail(); 1989 done(); 1990 } else { 1991 console.info('setVolumeTimeCallback play state is prepared') 1992 } 1993 }); 1994 await sleep(2000); 1995 break; 1996 case AV_PLAYER_STATE.PREPARED: 1997 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 1998 console.info('setVolumeTimeCallback avPlayer state is prepared') 1999 avPlayer.play() 2000 break; 2001 case AV_PLAYER_STATE.PLAYING: 2002 console.info('setVolumeTimeCallback play state is PLAYING') 2003 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 2004 if(loopTime == 10){ 2005 avPlayer.release().then(() => { 2006 console.info('setVolumeTimeCallback avPlayer is release') 2007 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 2008 let avg = totalTime/10; 2009 console.info("setVolumeTimeCallback avg time is :" + avg) 2010 done(); 2011 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2012 }else{ 2013 start = Date.now(); 2014 console.info(`setVolumeTimeCallback start time is : ${start}`) 2015 loopTime++ 2016 let volume = 1.0 2017 avPlayer.setVolume(volume) 2018 } 2019 break; 2020 case AV_PLAYER_STATE.PAUSED: 2021 console.info('setVolumeTimeCallback play state is PAUSED') 2022 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 2023 avPlayer.play().then(() => { 2024 console.info('setVolumeTimeCallback avPlayer from pause to play') 2025 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2026 break; 2027 default: 2028 break; 2029 } 2030 }); 2031 avPlayer.on('volumeChange', (vol) => { 2032 end = Date.now(); 2033 console.info(`setVolumeTimeCallback end time is : ${end}`) 2034 execution = parseInt(end - start) 2035 console.info("setVolumeTimeCallback execution time is :" + execution) 2036 totalTime = totalTime + execution; 2037 console.info('volumeChange success,and new volume is :' + vol) 2038 avPlayer.pause() 2039 }); 2040} 2041 2042export async function firstFrameTime(src, avPlayer, done) { 2043 let surfaceID = globalThis.value; 2044 let start; 2045 avPlayer = await idle(src, avPlayer) 2046 await setSource(avPlayer, src); 2047 console.info('firstFrameTime setSource'); 2048 await sleep(20) 2049 avPlayer.surfaceId = surfaceID; 2050 await avPlayer.prepare().then(() => { 2051 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 2052 console.info('firstFrameTime avPlayer state is prepared') 2053 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2054 await avPlayer.on('startRenderFrame', () => { 2055 console.info('startRenderFrame success') 2056 let end = Date.now(); 2057 console.info(`firstFrameTime end time is : ${end}`) 2058 let execution = parseInt(end - start) 2059 console.info("firstFrameTime execution time is :" + execution) 2060 sleep(100) 2061 avPlayer.release().then(() => { 2062 console.info('firstFrameTime avPlayer is release') 2063 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 2064 avPlayer = null; 2065 done(); 2066 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2067 }) 2068 start = Date.now(); 2069 console.info(`firstFrameTime start time is : ${start}`) 2070 await avPlayer.play().then(() => { 2071 console.info('firstFrameTime play success'); 2072 }, (err) => { 2073 console.error('firstFrameTime play filed,error message is :' + err.message) 2074 }) 2075} 2076 2077export async function avPlayerWithoutCallBack(src, avPlayer, done) { 2078 let surfaceID = globalThis.value; 2079 console.info(`case avPlayerWithoutCallBack Initialized in, surfaceID is ${surfaceID}`); 2080 avPlayer = await idle(src, avPlayer) 2081 setSource(avPlayer, src); 2082 console.info('avPlayerWithoutCallBack setSource'); 2083 await sleep(20); 2084 if(avPlayer.state == AV_PLAYER_STATE.INITIALIZED) { 2085 avPlayer.surfaceId = surfaceID; 2086 await preparePromise(avPlayer); 2087 await sleep(2000); 2088 } 2089 if(avPlayer.state == AV_PLAYER_STATE.PREPARED){ 2090 console.info('avPlayerWithoutCallBack avPlayer from PREPARED to play') 2091 // play to pause loop 1000 times 2092 for(var i = 0;i < 1000; i++){ 2093 await playToPauseLoop(avPlayer) 2094 console.info(`case avPlayerWithoutCallBack playToPauseLoop is ${i}`); 2095 } 2096 } 2097 await avPlayer.stop().then(() => { 2098 console.info('avPlayerWithoutCallBack avPlayer from play to stop') 2099 avPlayer.release().then(() => { 2100 console.info('avPlayerWithoutCallBack avPlayer from stop to release') 2101 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 2102 done(); 2103 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2104 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2105} 2106 2107function setAVPlayerPlay(src, avPlayer, done) { 2108 let surfaceID = globalThis.value; 2109 console.info(`case setAVPlayerPlay in, surfaceID is ${surfaceID}`); 2110 avPlayer.on('stateChange', async (state, reason) => { 2111 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 2112 console.info(`case state is ${state}`); 2113 switch (state) { 2114 case AV_PLAYER_STATE.INITIALIZED: 2115 avPlayer.surfaceId = surfaceID; 2116 console.info('setAVPlayerPlay play state is INITIALIZED') 2117 // step 1: initialized -> prepared -> play 2118 await preparePromise(avPlayer) 2119 await sleep(3000); 2120 avPlayer.play() 2121 break; 2122 case AV_PLAYER_STATE.PLAYING: 2123 console.info('setAVPlayerPlay play state is PLAYING') 2124 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 2125 if(avPlayer.duration > 3000){ 2126 mediaTestBase.msleepAsync(3000); 2127 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC) 2128 }else{ 2129 mediaTestBase.msleepAsync(500); 2130 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC) 2131 } 2132 break; 2133 case AV_PLAYER_STATE.COMPLETED: 2134 expect(avPlayer.currentTime).assertEqual(avPlayer.duration); 2135 expect(avPlayer.state).assertEqual('completed'); 2136 avPlayer.release().then(() => { 2137 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2138 break; 2139 case AV_PLAYER_STATE.RELEASED: 2140 expect(avPlayer.state).assertEqual('released'); 2141 avPlayer = null; 2142 done(); 2143 break; 2144 case AV_PLAYER_STATE.ERROR: 2145 console.info(`case error called, AV_PLAYER_STATE.ERROR, ignore`); 2146 avPlayer.release().then(() => { 2147 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2148 break; 2149 default: 2150 break; 2151 } 2152 }); 2153 avPlayer.on('error', async (err) => { 2154 console.error(`case error called, errMessage is ${err.message}`); 2155 if (error.code == media.AVErrorCode9.AVERR_UNSUPPORT_FORMAT){ 2156 console.info(`case error called, AVERR_UNSUPPORT_FORMAT, ignore`); 2157 } else { 2158 expect().assertFail(); 2159 } 2160 await avPlayer.release().then(() => { 2161 avPlayer = null; 2162 done(); 2163 }); 2164 }); 2165} 2166 2167export async function avPlayerPlay(src, avPlayer, done) { 2168 avPlayer = await idle(src, avPlayer) 2169 setAVPlayerPlay(src, avPlayer, done); 2170 await setSource(avPlayer, src); 2171} 2172 2173export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) { 2174 console.info(`case media source: ${src}`) 2175 await media.createAVPlayer().then((video) => { 2176 if (typeof(video) != 'undefined') { 2177 console.info('case createAVPlayer success'); 2178 avPlayer = video; 2179 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 2180 } else { 2181 console.error('case createAVPlayer failed'); 2182 expect().assertFail(); 2183 done(); 2184 } 2185 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2186 setAVPlayerFunCb(src, avPlayer, playTest, playTime, done); 2187 setSource(avPlayer, src); 2188} 2189 2190export function setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done) { 2191 let volumeCnt = [0]; 2192 let endOfStreamCnt = 0; 2193 let seekDoneCnt = 0; 2194 let speedDoneCnt = [0]; 2195 let playCnt = 0; 2196 let surfaceID = globalThis.value; 2197 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 2198 avPlayer.on('stateChange', async (state, reason) => { 2199 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 2200 if (reason == media.StateChangeReason.BACKGROUND) { 2201 avPlayer.release().then(() => { 2202 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2203 } 2204 switch (state) { 2205 case AV_PLAYER_STATE.INITIALIZED: 2206 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 2207 avPlayer.surfaceId = surfaceID; 2208 console.info('case initialized -> prepared'); 2209 // step 1,10: initialized -> prepared 2210 avPlayer.prepare((err) => { 2211 avPlayer.loop = true; 2212 if (err != null) { 2213 console.error(`case prepare error, errMessage is ${err.message}`); 2214 expect().assertFail(); 2215 done(); 2216 } else { 2217 checkPlayTest(avPlayer, playTest); 2218 } 2219 }); 2220 break; 2221 case AV_PLAYER_STATE.PREPARED: 2222 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 2223 checkPlayTest(avPlayer, playTest); 2224 expect(avPlayer.currentTime).assertEqual(0); 2225 offCallback(avPlayer, ['volumeChange']); 2226 // step 2,11: prepared -> seek 0 2227 avPlayer.seek(0, 2); // 2: CLOSEST SYNC 2228 break; 2229 case AV_PLAYER_STATE.PLAYING: 2230 playCnt++; 2231 if (playCnt == 1) { 2232 // step 4: seek + pause 2233 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 2234 avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_PREV_SYNC); 2235 avPlayer.pause((err) => { 2236 if (err != null) { 2237 mediaTestBase.assertErr('pause', err, done); 2238 } 2239 }); 2240 } else if (playCnt == 3) { 2241 // step 12: seek duration 2242 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); 2243 avPlayer.stop((err) => { 2244 if (err == null) { 2245 avPlayer.release((err) => { 2246 if (err != null) { 2247 mediaTestBase.assertErr('release', err, done); 2248 } 2249 }) 2250 } else { 2251 mediaTestBase.assertErr('stop', err, done); 2252 } 2253 }); 2254 } 2255 break; 2256 case AV_PLAYER_STATE.RELEASED: 2257 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 2258 // step 18: release -> done 2259 avPlayer = null; 2260 expect(volumeCnt[0]).assertEqual(0); 2261 expect(endOfStreamCnt).assertLarger(0); 2262 done(); 2263 break; 2264 case AV_PLAYER_STATE.ERROR: 2265 expect().assertFail(); 2266 avPlayer.release().then(() => { 2267 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 2268 break; 2269 default: 2270 break; 2271 } 2272 }); 2273 2274 avPlayer.on('endOfStream', () => { 2275 console.info(`case endOfStream called`); 2276 endOfStreamCnt++; 2277 // step 9: seek + reset 2278 avPlayer.seek(avPlayer.duration / 2, 3); // 3: CLOSEST 2279 avPlayer.reset((err) => { 2280 if (err == null) { 2281 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 2282 console.info('case reset success!!'); 2283 setSource(avPlayer, src); 2284 } else { 2285 mediaTestBase.assertErr('reset', err, done); 2286 } 2287 }); 2288 }); 2289 avPlayer.on('seekDone', async (seekDoneTime) => { 2290 seekDoneCnt++; 2291 console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`); 2292 switch (seekDoneCnt) { 2293 case 1: 2294 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 2295 // step 3: seek(prepared) -> play 2296 avPlayer.play((err) => { 2297 if (err != null) { 2298 mediaTestBase.assertErr('play', err, done); 2299 } 2300 }); 2301 break; 2302 case 2: 2303 // step 5: seek + play 2304 avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_NEXT_SYNC); 2305 avPlayer.play(); 2306 break; 2307 case 3: 2308 // step 6: seek + setVolume 2309 avPlayer.setVolume(0.5); 2310 avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_CLOSEST_SYNC); 2311 avPlayer.play(); 2312 break; 2313 case 4: 2314 // step 7: seek + seek 2315 avPlayer.seek(avPlayer.duration / 2); 2316 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); 2317 avPlayer.play(); 2318 break; 2319 case 5: 2320 // step 8: seek duration 2321 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); 2322 break; 2323 default: 2324 avPlayer.play(); 2325 break; 2326 } 2327 }); 2328 setCallback(avPlayer, 'volumeChange', volumeCnt); 2329 setCallback(avPlayer, 'speedDone', speedDoneCnt); 2330 setCallback(avPlayer, 'bitrateDone', null); 2331 setCallback(avPlayer, 'timeUpdate', null); 2332 setCallback(avPlayer, 'bufferingUpdate', null); 2333 setCallback(avPlayer, 'durationUpdate', null); 2334 setCallback(avPlayer, 'startRenderFrame', null); 2335 setCallback(avPlayer, 'videoSizeChange', null); 2336 setCallback(avPlayer, 'audioInterrupt', null); 2337 setCallback(avPlayer, 'availableBitrates', null); 2338 avPlayer.on('error', async (err) => { 2339 console.error(`case error called, errMessage is ${err.message}`); 2340 }); 2341} 2342 2343export async function testAVPlayerSeek(src, avPlayer, playTest, playTime, done) { 2344 console.info(`case media source: ${src}`) 2345 media.createAVPlayer((err, video) => { 2346 console.info(`case media err: ${err}`) 2347 if (typeof(video) != 'undefined') { 2348 console.info('case createAVPlayer success'); 2349 avPlayer = video; 2350 setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done); 2351 setSource(avPlayer, src); 2352 } 2353 if (err != null) { 2354 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 2355 expect().assertFail(); 2356 done(); 2357 } 2358 }); 2359} 2360