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