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