1/* 2 * Copyright (C) 2022-2023 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 fileio from '@ohos.fileio' 18import * as mediaTestBase from './MediaTestBase.js'; 19 20export const AV_PLAYER_STATE = { 21 IDLE : 'idle', 22 INITIALIZED : 'initialized', 23 PREPARED : 'prepared', 24 PLAYING : 'playing', 25 PAUSED : 'paused', 26 COMPLETED : 'completed', 27 STOPPED : 'stopped', 28 RELEASED : 'released', 29 ERROR : 'error', 30} 31 32let playTest = { 33 width: 0, 34 height: 0, 35 duration: -1 36} 37export {playTest}; 38 39export function setSource(avPlayer, src) { 40 if (typeof(avPlayer) == 'undefined') { 41 console.error('case avPlayer is undefined'); 42 return; 43 } 44 if (typeof(src) == 'string') { 45 console.info('case src test'); 46 avPlayer.url = src; 47 return 48 } 49 if (typeof(src) == 'object') { 50 let arr = Object.keys(src); 51 let len = arr.length; 52 if (len == 3) { 53 console.info('case fdsrc test'); 54 avPlayer.fdSrc = src; 55 } else if (len == 2) { 56 console.info('case dataSrc test'); 57 avPlayer.dataSrc = src; 58 } 59 } 60} 61 62export function checkPlayTest(avPlayer, playTest) { 63 if (avPlayer == null) { 64 return; 65 } 66 if (playTest.duration > 0) { 67 expect(Math.abs(avPlayer.duration - playTest.duration)).assertLess(500); 68 } 69 if (playTest.width > 0) { 70 expect(avPlayer.width).assertEqual(playTest.width); 71 expect(avPlayer.height).assertEqual(playTest.height); 72 } 73} 74 75export async function toPreparePromise(avPlayer, playTest) { 76 if (typeof(avPlayer) == 'undefined') { 77 return; 78 } 79 await avPlayer.prepare().then(() => { 80 console.info('case prepare called'); 81 console.info('case avPlayer.duration: ' + avPlayer.duration); 82 checkPlayTest(avPlayer, playTest); 83 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 84} 85 86function addCnt(countArr) { 87 if (countArr != null) { 88 countArr[0]++; 89 } 90} 91 92export function setCallback(avPlayer, type, countArr) { 93 if (avPlayer == null) { 94 return; 95 } 96 switch (type) { 97 case 'volumeChange': 98 avPlayer.on('volumeChange', (volume) => { 99 console.info(`case volumeChange called, volume is ${volume}`); 100 addCnt(countArr); 101 }); 102 break; 103 case 'endOfStream': 104 avPlayer.on('endOfStream', () => { 105 console.info(`case endOfStream called`); 106 addCnt(countArr); 107 }); 108 break; 109 case 'speedDone': 110 avPlayer.on('speedDone', (speedMode) => { 111 console.info(`case speedDone called, speedMode is ${speedMode}`); 112 addCnt(countArr); 113 }); 114 break; 115 case 'bitrateDone': 116 avPlayer.on('bitrateDone', (bitrate) => { 117 console.info(`case bitrateDone called, bitrate is ${bitrate}`); 118 }); 119 break; 120 case 'timeUpdate': 121 avPlayer.on('timeUpdate', (time) => { 122 console.info('case timeUpdate callback, time:' + time); 123 }); 124 break; 125 case 'bufferingUpdate': 126 avPlayer.on('bufferingUpdate', (infoType, value) => { 127 }); 128 break; 129 case 'durationUpdate': 130 avPlayer.on('durationUpdate', (duration) => { 131 console.info('case durationUpdate called,duration:' + duration); 132 addCnt(countArr); 133 }); 134 break; 135 case 'startRenderFrame': 136 avPlayer.on('startRenderFrame', () => { 137 console.info('case startRenderFrame called'); 138 addCnt(countArr); 139 }); 140 break; 141 case 'videoSizeChange': 142 avPlayer.on('videoSizeChange', (w, h) => { 143 console.info(`case videoSizeChange called, weight is ${w}, height is ${h}`); 144 addCnt(countArr); 145 }); 146 break; 147 case 'audioInterrupt': 148 avPlayer.on('audioInterrupt', (info) => { 149 console.info(`case audioInterrupt called, info is ${info}`); 150 }); 151 break; 152 case 'availableBitrates': 153 avPlayer.on('availableBitrates', (bitrates) => { 154 for (let i = 0; i < bitrates.length; i++) { 155 console.info('case availableBitrates : ' + bitrates[i]); 156 } 157 addCnt(countArr); 158 }); 159 break; 160 default: 161 break; 162 } 163} 164 165export function offCallback(avPlayer, typeArr) 166{ 167 if (avPlayer == null) { 168 return; 169 } 170 for (let i = 0; i < typeArr.length; i++) { 171 switch (typeArr[i]) { 172 case 'stateChange': 173 avPlayer.off('stateChange'); 174 break; 175 case 'volumeChange': 176 avPlayer.off('volumeChange'); 177 break; 178 case 'endOfStream': 179 avPlayer.off('endOfStream'); 180 break; 181 case 'seekDone': 182 avPlayer.off('seekDone'); 183 break; 184 case 'speedDone': 185 avPlayer.off('speedDone'); 186 break; 187 case 'speedDone': 188 avPlayer.off('speedDone'); 189 break; 190 case 'timeUpdate': 191 avPlayer.off('timeUpdate'); 192 break; 193 case 'durationUpdate': 194 avPlayer.off('durationUpdate'); 195 break; 196 case 'bufferingUpdate': 197 avPlayer.off('bufferingUpdate'); 198 break; 199 case 'startRenderFrame': 200 avPlayer.off('startRenderFrame'); 201 break; 202 case 'videoSizeChange': 203 avPlayer.off('videoSizeChange'); 204 break; 205 case 'audioInterrupt': 206 avPlayer.off('audioInterrupt'); 207 break; 208 case 'availableBitrates': 209 avPlayer.off('availableBitrates'); 210 break; 211 case 'error': 212 avPlayer.off('error'); 213 break; 214 default: 215 break; 216 } 217 } 218} 219 220export function setAVPlayerFunCb(src, avPlayer, playTest, playTime, done) { 221 let volumeCnt = [0]; 222 let endOfStreamCnt = [0]; 223 let speedDoneCnt = [0]; 224 let videoSizeCnt = [0]; 225 let startRenderFrameCnt = [0]; 226 let durationUpdateCnt = [0]; 227 let seekDoneCnt = [0]; 228 let prepareCnt = 0; 229 let playCnt = 0; 230 let completedCnt = 0; 231 let surfaceID = globalThis.value; 232 console.info(`case setAVPlayerFunCb in, surfaceID is ${surfaceID}`); 233 avPlayer.on('stateChange', async (state, reason) => { 234 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 235 if (reason == media.StateChangeReason.BACKGROUND) { 236 console.info(`case media.StateChangeReason.BACKGROUND`); 237 await avPlayer.release().then(() => { 238 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 239 } 240 console.info(`case state is ${state}`); 241 switch (state) { 242 case AV_PLAYER_STATE.INITIALIZED: 243 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 244 if (playTest.width != 0) { 245 avPlayer.surfaceId = surfaceID; 246 } 247 // step 1, 13: initialized -> prepared 248 toPreparePromise(avPlayer, playTest); 249 break; 250 case AV_PLAYER_STATE.PREPARED: 251 prepareCnt++; 252 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 253 checkPlayTest(avPlayer, playTest); 254 expect(avPlayer.currentTime).assertEqual(0); 255 if (prepareCnt == 1) { 256 // step 2: prepared -> playing 257 avPlayer.play().then(() => { 258 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 259 } else { 260 // step 14: prepared -> seek(5th) 261 avPlayer.seek(avPlayer.duration); 262 } 263 break; 264 case AV_PLAYER_STATE.PLAYING: 265 playCnt++; 266 if (playCnt == 1) { 267 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 268 // step 3: playing -> seek(1st) duration/3 269 await mediaTestBase.msleepAsync(playTime); 270 avPlayer.seek(avPlayer.duration / 3); 271 } else if (playCnt == 2) { 272 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 273 // step 7: playing -> seek(3th) duration when loop true 274 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); 275 } else if (playCnt == 3) { 276 // step 10: playing -> stop 277 avPlayer.stop().then(() => { 278 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 279 } 280 break; 281 case AV_PLAYER_STATE.PAUSED: 282 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 283 // step 5: pause -> seek(2nd) 0 284 avPlayer.loop = true; 285 avPlayer.seek(0, media.SeekMode.SEEK_NEXT_SYNC); 286 break; 287 case AV_PLAYER_STATE.COMPLETED: 288 completedCnt++; 289 expect(avPlayer.currentTime).assertEqual(avPlayer.duration); 290 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); 291 if (completedCnt == 1) { 292 // step 9: completed -> play 293 avPlayer.play(); 294 } else { 295 // step 16: completed -> reset 296 avPlayer.reset().then(() => { 297 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 298 // step 17: reset -> release 299 avPlayer.release().then(() => { 300 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 301 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 302 } 303 break; 304 case AV_PLAYER_STATE.STOPPED: 305 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); 306 // step 11: stop -> reset 307 avPlayer.reset().then(() => { 308 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 309 // step 12: reset -> initialized 310 setSource(avPlayer, src); 311 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 312 break; 313 case AV_PLAYER_STATE.RELEASED: 314 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 315 // step 18: release -> done 316 avPlayer = null; 317 done(); 318 break; 319 case AV_PLAYER_STATE.ERROR: 320 expect().assertFail(); 321 avPlayer.release().then(() => { 322 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 323 break; 324 default: 325 break; 326 } 327 }); 328 avPlayer.on('seekDone', async (seekDoneTime) => { 329 seekDoneCnt[0]++; 330 console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`); 331 switch (seekDoneCnt[0]) { 332 case 2: 333 // step 6: seek(paused) -> play 334 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 335 avPlayer.play(); 336 avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_2_00_X); 337 avPlayer.setVolume(0.5); 338 break; 339 case 1: 340 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 341 // step 4: seek(playing) -> pause 342 avPlayer.pause().then(() => { 343 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 344 break; 345 case 3: 346 case 4: 347 case 5: 348 let nowTime = avPlayer.currentTime; 349 if (avPlayer.state == AV_PLAYER_STATE.PREPARED) { 350 // step 15: prepared -> play 351 avPlayer.play(); 352 } 353 if (nowTime > avPlayer.duration / 2) { 354 await mediaTestBase.msleepAsync((avPlayer.duration - nowTime) / 2 + playTime); 355 } 356 if (avPlayer.loop == true) { 357 // step 8: playing -> seek(4th) duration when loop false 358 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 359 avPlayer.loop = false; 360 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); 361 } 362 break; 363 } 364 }); 365 setCallback(avPlayer, 'volumeChange', volumeCnt); 366 setCallback(avPlayer, 'endOfStream', endOfStreamCnt); 367 setCallback(avPlayer, 'speedDone', speedDoneCnt); 368 setCallback(avPlayer, 'bitrateDone', null); 369 setCallback(avPlayer, 'timeUpdate', null); 370 setCallback(avPlayer, 'bufferingUpdate', null); 371 setCallback(avPlayer, 'durationUpdate', durationUpdateCnt); 372 setCallback(avPlayer, 'startRenderFrame', startRenderFrameCnt); 373 setCallback(avPlayer, 'videoSizeChange', videoSizeCnt); 374 setCallback(avPlayer, 'audioInterrupt', null); 375 setCallback(avPlayer, 'availableBitrates', null); 376 avPlayer.on('error', async (err) => { 377 console.error(`case error called, errMessage is ${err.message}`); 378 expect().assertFail(); 379 await avPlayer.release().then(() => { 380 avPlayer = null; 381 done(); 382 }); 383 }); 384} 385 386export async function testAVPlayerFun(src, avPlayer, playTest, playTime, done) { 387 console.info(`case media source: ${src}`) 388 await media.createAVPlayer().then((video) => { 389 if (typeof(video) != 'undefined') { 390 console.info('case createAVPlayer success'); 391 avPlayer = video; 392 } else { 393 console.error('case createAVPlayer failed'); 394 expect().assertFail(); 395 done(); 396 } 397 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 398 setAVPlayerFunCb(src, avPlayer, playTest, playTime, done); 399 setSource(avPlayer, src); 400} 401 402export function setAVPlayerDataSrcNoSeekCb(fd, filePath, src, avPlayer, playTest, playTime, done) { 403 let volumeCnt = [0]; 404 let endOfStreamCnt = [0]; 405 let speedDoneCnt = [0]; 406 let videoSizeCnt = [0]; 407 let startRenderFrameCnt = [0]; 408 let durationUpdateCnt = [0]; 409 let seekDoneCnt = [0]; 410 let prepareCnt = 0; 411 let playCnt = 0; 412 let completedCnt = 0; 413 let errorCnt = 0; 414 let surfaceID = globalThis.value; 415 console.info(`case setAVPlayerDataSrcNoSeekCb in, surfaceID is ${surfaceID}`); 416 avPlayer.on('stateChange', async (state, reason) => { 417 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 418 if (reason == media.StateChangeReason.BACKGROUND) { 419 console.info(`case media.StateChangeReason.BACKGROUND`); 420 await avPlayer.release().then(() => { 421 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 422 } 423 console.info(`case state is ${state}`); 424 switch (state) { 425 case AV_PLAYER_STATE.INITIALIZED: 426 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 427 if (playTest.width != 0) { 428 avPlayer.surfaceId = surfaceID; 429 } 430 // step 1, 10: initialized -> prepared 431 toPreparePromise(avPlayer, playTest); 432 break; 433 case AV_PLAYER_STATE.PREPARED: 434 prepareCnt++; 435 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 436 checkPlayTest(avPlayer, playTest); 437 console.info(`case avPlayer.currentTime:` + avPlayer.currentTime); 438 expect(avPlayer.currentTime).assertEqual(0); 439 if (prepareCnt == 1) { 440 // step 2: prepared -> playing 441 avPlayer.play().then(() => { 442 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 443 } else { 444 // step 11: prepared -> seek 445 avPlayer.seek(avPlayer.duration); 446 } 447 break; 448 case AV_PLAYER_STATE.PLAYING: 449 playCnt++; 450 if (playCnt == 1) { 451 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 452 // step 3: playing -> seek duration/3 453 avPlayer.seek(avPlayer.duration / 3); 454 } else if (playCnt == 3) { 455 // step 13: playing -> loop 456 await mediaTestBase.msleepAsync(playTime); 457 avPlayer.loop = true; 458 } 459 break; 460 case AV_PLAYER_STATE.PAUSED: 461 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 462 // step 5: pause -> seek 0 463 avPlayer.seek(0, media.SeekMode.SEEK_NEXT_SYNC); 464 break; 465 case AV_PLAYER_STATE.COMPLETED: 466 break; 467 case AV_PLAYER_STATE.STOPPED: 468 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.STOPPED); 469 // step 8: stop -> reset 470 avPlayer.reset().then(() => { 471 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 472 fileio.closeSync(fd[0]); 473 fd[0] = fileio.openSync(filePath, 0o0); 474 // step 9: reset -> initialized 475 setSource(avPlayer, src); 476 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 477 break; 478 case AV_PLAYER_STATE.RELEASED: 479 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 480 // step 18: release -> done 481 avPlayer = null; 482 done(); 483 break; 484 case AV_PLAYER_STATE.ERROR: 485 expect().assertFail(); 486 avPlayer.release().then(() => { 487 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 488 break; 489 default: 490 break; 491 } 492 }); 493 avPlayer.on('seekDone', async (seekDoneTime) => { 494 seekDoneCnt[0]++; 495 }); 496 avPlayer.on('endOfStream', () => { 497 console.info(`case endOfStream called`); 498 endOfStreamCnt[0]++; 499 // step 7: playing -> stop 500 avPlayer.stop().then(() => { 501 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 502 }); 503 setCallback(avPlayer, 'volumeChange', volumeCnt); 504 setCallback(avPlayer, 'speedDone', speedDoneCnt); 505 setCallback(avPlayer, 'bitrateDone', null); 506 setCallback(avPlayer, 'timeUpdate', null); 507 setCallback(avPlayer, 'bufferingUpdate', null); 508 setCallback(avPlayer, 'durationUpdate', durationUpdateCnt); 509 setCallback(avPlayer, 'startRenderFrame', startRenderFrameCnt); 510 setCallback(avPlayer, 'videoSizeChange', videoSizeCnt); 511 setCallback(avPlayer, 'audioInterrupt', null); 512 setCallback(avPlayer, 'availableBitrates', null); 513 avPlayer.on('error', async (err) => { 514 console.error(`case error called, err is ${JSON.stringify(err)}`); 515 console.error(`case error called, errMessage is ${err.message}`); 516 errorCnt++; 517 switch (errorCnt) { 518 case 2: 519 // step 6: paused -> play 520 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PAUSED); 521 avPlayer.play(); 522 avPlayer.setSpeed(media.PlaybackSpeed.SPEED_FORWARD_2_00_X); 523 avPlayer.setVolume(0.5); 524 break; 525 case 1: 526 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 527 // step 4: playing -> pause 528 avPlayer.pause().then(() => { 529 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 530 break; 531 case 4: 532 // step 12: prepared -> play 533 avPlayer.play(); 534 break; 535 case 5: 536 // step 14: playing -> reset 537 avPlayer.reset().then(() => { 538 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 539 // step 15: reset -> release 540 avPlayer.release().then(() => { 541 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 542 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 543 break; 544 default: 545 break; 546 } 547 }); 548} 549 550export function testAVPlayerDataSrcNoSeek(filePath, src, avPlayer, playTest, playTime, done) { 551 console.info(`case media source: ${src}`) 552 let fd = [fileio.openSync(filePath, 0o0)]; 553 media.createAVPlayer((err, video) => { 554 if (typeof(video) != 'undefined') { 555 console.info('case createAVPlayer success'); 556 avPlayer = video; 557 setAVPlayerDataSrcNoSeekCb(fd, filePath, src, avPlayer, playTest, playTime, done); 558 setSource(avPlayer, src); 559 } 560 if (err != null) { 561 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 562 expect().assertFail(); 563 done(); 564 } 565 }); 566 return fd; 567} 568 569export function setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done) { 570 let volumeCnt = [0]; 571 let endOfStreamCnt = 0; 572 let seekDoneCnt = 0; 573 let speedDoneCnt = [0]; 574 let playCnt = 0; 575 let surfaceID = globalThis.value; 576 console.info(`case setCallback in, surfaceID is ${surfaceID}`); 577 avPlayer.on('stateChange', async (state, reason) => { 578 console.info(`case stateChange called, state is ${state}, reason is ${reason}`); 579 if (reason == media.StateChangeReason.BACKGROUND) { 580 avPlayer.release().then(() => { 581 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 582 } 583 switch (state) { 584 case AV_PLAYER_STATE.INITIALIZED: 585 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 586 if (playTest.width != 0) { 587 avPlayer.surfaceId = surfaceID; 588 } 589 console.info('case initialized -> prepared'); 590 // step 1,10: initialized -> prepared 591 avPlayer.prepare((err) => { 592 avPlayer.loop = true; 593 if (err != null) { 594 console.error(`case prepare error, errMessage is ${err.message}`); 595 expect().assertFail(); 596 done(); 597 } else { 598 checkPlayTest(avPlayer, playTest); 599 } 600 }); 601 break; 602 case AV_PLAYER_STATE.PREPARED: 603 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 604 checkPlayTest(avPlayer, playTest); 605 expect(avPlayer.currentTime).assertEqual(0); 606 offCallback(avPlayer, ['volumeChange']); 607 // step 2,11: prepared -> seek 0 608 avPlayer.seek(0, 2); // 2: CLOSEST SYNC 609 break; 610 case AV_PLAYER_STATE.PLAYING: 611 playCnt++; 612 if (playCnt == 1) { 613 // step 4: seek + pause 614 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PLAYING); 615 avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_PREV_SYNC); 616 avPlayer.pause((err) => { 617 if (err != null) { 618 mediaTestBase.assertErr('pause', err, done); 619 } 620 }); 621 } else if (playCnt == 3) { 622 // step 12: seek duration 623 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); 624 avPlayer.stop((err) => { 625 if (err == null) { 626 avPlayer.release((err) => { 627 if (err != null) { 628 mediaTestBase.assertErr('release', err, done); 629 } 630 }) 631 } else { 632 mediaTestBase.assertErr('stop', err, done); 633 } 634 }); 635 } 636 break; 637 case AV_PLAYER_STATE.RELEASED: 638 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.RELEASED); 639 // step 18: release -> done 640 avPlayer = null; 641 expect(volumeCnt[0]).assertEqual(0); 642 expect(endOfStreamCnt).assertLarger(0); 643 done(); 644 break; 645 case AV_PLAYER_STATE.ERROR: 646 expect().assertFail(); 647 avPlayer.release().then(() => { 648 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 649 break; 650 default: 651 break; 652 } 653 }); 654 655 avPlayer.on('endOfStream', () => { 656 console.info(`case endOfStream called`); 657 endOfStreamCnt++; 658 // step 9: seek + reset 659 avPlayer.seek(avPlayer.duration / 2, 3); // 3: CLOSEST 660 avPlayer.reset((err) => { 661 if (err == null) { 662 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.IDLE); 663 console.info('case reset success!!'); 664 setSource(avPlayer, src); 665 } else { 666 mediaTestBase.assertErr('reset', err, done); 667 } 668 }); 669 }); 670 avPlayer.on('seekDone', async (seekDoneTime) => { 671 seekDoneCnt++; 672 console.info(`case seekDone called, seekDoneCnt is ${seekDoneCnt}, seekDoneTime is ${seekDoneTime}`); 673 switch (seekDoneCnt) { 674 case 1: 675 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.PREPARED); 676 // step 3: seek(prepared) -> play 677 avPlayer.play((err) => { 678 if (err != null) { 679 mediaTestBase.assertErr('play', err, done); 680 } 681 }); 682 break; 683 case 2: 684 // step 5: seek + play 685 avPlayer.seek(avPlayer.duration / 2, media.SeekMode.SEEK_NEXT_SYNC); 686 avPlayer.play(); 687 break; 688 case 3: 689 // step 6: seek + setVolume 690 avPlayer.setVolume(0.5); 691 avPlayer.seek(avPlayer.duration / 2, 2); // 2: CLOSEST SYNC 692 avPlayer.play(); 693 break; 694 case 4: 695 // step 7: seek + seek 696 avPlayer.seek(avPlayer.duration / 2); 697 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_NEXT_SYNC); 698 avPlayer.play(); 699 break; 700 case 5: 701 // step 8: seek duration 702 avPlayer.seek(avPlayer.duration, media.SeekMode.SEEK_PREV_SYNC); 703 break; 704 default: 705 avPlayer.play(); 706 break; 707 } 708 }); 709 setCallback(avPlayer, 'volumeChange', volumeCnt); 710 setCallback(avPlayer, 'speedDone', speedDoneCnt); 711 setCallback(avPlayer, 'bitrateDone', null); 712 setCallback(avPlayer, 'timeUpdate', null); 713 setCallback(avPlayer, 'bufferingUpdate', null); 714 setCallback(avPlayer, 'durationUpdate', null); 715 setCallback(avPlayer, 'startRenderFrame', null); 716 setCallback(avPlayer, 'videoSizeChange', null); 717 setCallback(avPlayer, 'audioInterrupt', null); 718 setCallback(avPlayer, 'availableBitrates', null); 719 avPlayer.on('error', async (err) => { 720 console.error(`case error called, errMessage is ${err.message}`); 721 }); 722} 723 724export async function testAVPlayerSeek(src, avPlayer, playTest, playTime, done) { 725 console.info(`case media source: ${src}`) 726 media.createAVPlayer((err, video) => { 727 if (typeof(video) != 'undefined') { 728 console.info('case createAVPlayer success'); 729 avPlayer = video; 730 setAVPlayerSeekCb(src, avPlayer, playTest, playTime, done); 731 setSource(avPlayer, src); 732 } 733 if (err != null) { 734 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 735 expect().assertFail(); 736 done(); 737 } 738 }); 739} 740