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 */ 15import media from '@ohos.multimedia.media' 16import audio from '@ohos.multimedia.audio'; 17import * as mediaTestBase from '../../../../../../MediaTestBase.js'; 18import * as AVPlayerTestBase from '../../../../../../AVPlayerTestBase.js'; 19import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index'; 20 21export default function AVPlayerHlsLiveFuncTest() { 22 describe('AVPlayerHlsLiveFuncTest', function () { 23 const HLS_PATH = 'http://xxx.xxx.xxx.xxx:xx/xx/index.m3u8'; 24 const MULTI_HLS_PATH = 'http://xxx.xxx.xxx.xxx:xx/multi/index.m3u8' 25 const PLAY_TIME = 2000; 26 let avPlayer = null; 27 let surfaceID = globalThis.value; 28 29 const AV_MULTI_HLS_LIVE_BITRATE = [ 30 224726, 31 389070, 32 592145, 33 883770, 34 1239184, 35 1801257 36 ] 37 38 let trackDescription = { 39 'codec_mime': 'video/mpegts', 40 'track_index': '0', 41 'track_type': '1' 42 } 43 44 const audioRendererInfo = { 45 content: audio.ContentType.CONTENT_TYPE_MOVIE, 46 usage: audio.StreamUsage.STREAM_USAGE_MEDIA, 47 rendererFlags: 0, 48 } 49 const videoScaleType1 = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT; 50 const audioInterruptMode1 = audio.InterruptMode.INDEPENDENT_MODE; 51 const videoScaleType2 = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT_CROP; 52 const audioInterruptMode2 = audio.InterruptMode.SHARE_MODE; 53 54 beforeAll(async function() { 55 console.info('beforeAll case'); 56 }) 57 58 beforeEach(async function() { 59 console.info('beforeEach case'); 60 }) 61 62 afterEach(async function() { 63 console.info('afterEach case'); 64 }) 65 66 afterAll(async function() { 67 console.info('afterAll case'); 68 if (avPlayer != null) { 69 avPlayer.release().then(() => { 70 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 71 } 72 }) 73 74 function checkArray(realArray, expectArray) { 75 expect(realArray.length).assertEqual(expectArray.length); 76 for (let i = 0; i < expectArray.length; i++) { 77 console.info('case expect ' + expectArray[i] + ', real value is ' + realArray[i]); 78 expect(realArray[i]).assertEqual(expectArray[i]); 79 } 80 } 81 82 function setAttribute(avPlayer, videoScaleTypeValue, audioInterruptModeValue) { 83 avPlayer.videoScaleType = videoScaleTypeValue; 84 avPlayer.audioInterruptMode = audioInterruptModeValue; 85 } 86 87 function expectAttributeEqual(avPlayer, expectRender, expectScaleType, expectInterruptMode) { 88 expect(avPlayer.audioRendererInfo.content).assertEqual(expectRender.content); 89 expect(avPlayer.audioRendererInfo.usage).assertEqual(expectRender.usage); 90 expect(avPlayer.audioRendererInfo.rendererFlags).assertEqual(expectRender.rendererFlags); 91 expect(avPlayer.videoScaleType).assertEqual(expectScaleType); 92 expect(avPlayer.audioInterruptMode).assertEqual(expectInterruptMode); 93 } 94 95 function NextSteps(avPlayer, src, steps) { 96 switch(steps[0]) { 97 case 'src': 98 steps.shift(); 99 avPlayer.url = src; 100 break; 101 case 'prepare': 102 steps.shift(); 103 avPlayer.prepare(); 104 break; 105 case 'play': 106 steps.shift(); 107 avPlayer.play(); 108 break; 109 case 'seek': 110 steps.shift(); 111 const seekNum = steps[0]; 112 steps.shift(); 113 avPlayer.seek(seekNum); 114 break; 115 case 'loop': 116 steps.shift(); 117 const loopFlag = steps[0]; 118 steps.shift(); 119 avPlayer.loop = loopFlag; 120 break; 121 case 'setSpeed': 122 steps.shift(); 123 const speedNum = steps[0]; 124 steps.shift(); 125 avPlayer.setSpeed(speedNum); 126 break; 127 case 'duration': 128 steps.shift(); 129 expect(avPlayer.duration).assertEqual(steps[0]); 130 steps.shift(); 131 NextSteps(avPlayer, src, steps); 132 break; 133 case 'currentTime': 134 steps.shift(); 135 expect(avPlayer.currentTime).assertEqual(steps[0]); 136 steps.shift(); 137 NextSteps(avPlayer, src, steps); 138 break; 139 case 'setBitrate': 140 steps.shift(); 141 avPlayer.setBitrate(steps[0]); 142 steps.shift(); 143 NextSteps(avPlayer, src, steps); 144 break; 145 case 'pause': 146 steps.shift(); 147 avPlayer.pause(); 148 break; 149 case 'stop': 150 steps.shift(); 151 avPlayer.stop(); 152 break; 153 case 'reset': 154 steps.shift(); 155 avPlayer.reset(); 156 break; 157 case 'release': 158 steps.shift(); 159 avPlayer.release(); 160 break; 161 default: 162 break; 163 } 164 } 165 166 function testFun(avPlayer, src, surfaceID, Steps, done) { 167 avPlayer.on('stateChange', async (state, reason) => { 168 switch (state) { 169 case AVPlayerTestBase.AV_PLAYER_STATE.IDLE: 170 NextSteps(avPlayer, src, Steps); 171 break; 172 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 173 avPlayer.surfaceId = surfaceID; 174 NextSteps(avPlayer, src, Steps); 175 break; 176 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 177 NextSteps(avPlayer, src, Steps); 178 break; 179 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 180 await mediaTestBase.msleepAsync(PLAY_TIME); 181 NextSteps(avPlayer, src, Steps); 182 break; 183 case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: 184 await mediaTestBase.msleepAsync(PLAY_TIME); 185 NextSteps(avPlayer, src, Steps); 186 break; 187 case AVPlayerTestBase.AV_PLAYER_STATE.STOPPED: 188 NextSteps(avPlayer, src, Steps); 189 break; 190 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 191 avPlayer = null; 192 done(); 193 break; 194 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 195 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 196 expect().assertFail(); 197 avPlayer.release(); 198 break; 199 default: 200 break; 201 } 202 }); 203 avPlayer.on('error', (err) => { 204 console.info(`case error called,errName is ${err.name},errCode is ${err.code},errMessage is ${err.message}`); 205 avPlayer.release(); 206 expect().assertFail(); 207 }); 208 console.info(`case src is ${src}`); 209 Steps.shift(); 210 avPlayer.url = src; 211 } 212 213 function testReliability(avPlayer, src, surfaceID, Steps, done) { 214 avPlayer.on('stateChange', async (state, reason) => { 215 switch (state) { 216 case AVPlayerTestBase.AV_PLAYER_STATE.IDLE: 217 NextSteps(avPlayer, src, Steps); 218 break; 219 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 220 avPlayer.surfaceId = surfaceID; 221 NextSteps(avPlayer, src, Steps); 222 break; 223 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 224 NextSteps(avPlayer, src, Steps); 225 break; 226 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 227 await mediaTestBase.msleepAsync(PLAY_TIME); 228 NextSteps(avPlayer, src, Steps); 229 break; 230 case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: 231 await mediaTestBase.msleepAsync(PLAY_TIME); 232 NextSteps(avPlayer, src, Steps); 233 break; 234 case AVPlayerTestBase.AV_PLAYER_STATE.STOPPED: 235 NextSteps(avPlayer, src, Steps); 236 break; 237 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 238 avPlayer = null; 239 done(); 240 break; 241 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 242 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 243 expect().assertFail(); 244 avPlayer.release(); 245 break; 246 default: 247 break; 248 } 249 }); 250 avPlayer.on('error', (err) => { 251 console.info(`case error called,errName is ${err.name},errCode is ${err.code},errMessage is ${err.message}`); 252 expect(Steps[0]).assertEqual('error'); 253 Steps.shift(); 254 NextSteps(avPlayer, src, Steps); 255 }); 256 avPlayer.on('bufferingUpdate', (infoType, value) => { 257 console.info('case bufferingUpdate success, infoType is ' + infoType + ', value is ' + value); 258 }); 259 console.info(`case src is ${src}`); 260 Steps.shift(); 261 avPlayer.url = src; 262 } 263 264 function testBufferingUpdate(avPlayer, src, surfaceID, Steps, done) { 265 let isUpdate = false; 266 avPlayer.on('stateChange', async (state, reason) => { 267 switch (state) { 268 case AVPlayerTestBase.AV_PLAYER_STATE.IDLE: 269 NextSteps(avPlayer, src, Steps); 270 break; 271 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 272 avPlayer.surfaceId = surfaceID; 273 NextSteps(avPlayer, src, Steps); 274 break; 275 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 276 NextSteps(avPlayer, src, Steps); 277 break; 278 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 279 await mediaTestBase.msleepAsync(8000); // wait play 8000 ms 280 NextSteps(avPlayer, src, Steps); 281 break; 282 case AVPlayerTestBase.AV_PLAYER_STATE.STOPPED: 283 NextSteps(avPlayer, src, Steps); 284 break; 285 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 286 avPlayer = null; 287 expect(isUpdate).assertEqual(true); 288 done(); 289 break; 290 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 291 expect().assertFail(); 292 avPlayer.release(); 293 break; 294 default: 295 break; 296 } 297 }); 298 avPlayer.on('error', (err) => { 299 console.info(`case error called,errName is ${err.name},errCode is ${err.code},errMessage is ${err.message}`); 300 expect(Steps[0]).assertEqual('error'); 301 Steps.shift(); 302 NextSteps(avPlayer, src, Steps); 303 }); 304 avPlayer.on('bufferingUpdate', (infoType, value) => { 305 console.info('case bufferingUpdate success, infoType is ' + infoType + ', value is ' + value); 306 isUpdate = true; 307 }); 308 console.info(`case src is ${src}`); 309 Steps.shift(); 310 avPlayer.url = src; 311 } 312 313 function testSetMultiBitrate(avPlayer, src, surfaceID, done) { 314 let bitrateFlag = 'False'; 315 let nowBitRate = -1; 316 avPlayer.on('stateChange', async (state, reason) => { 317 switch (state) { 318 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 319 avPlayer.surfaceId = surfaceID; 320 avPlayer.prepare(); 321 break; 322 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 323 nowBitRate = AV_MULTI_HLS_LIVE_BITRATE[0]; 324 avPlayer.setBitrate(nowBitRate); 325 avPlayer.play(); 326 break; 327 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 328 await mediaTestBase.msleepAsync(3000); // wait 3000ms 329 nowBitRate = AV_MULTI_HLS_LIVE_BITRATE[1]; 330 avPlayer.setBitrate(nowBitRate); 331 await mediaTestBase.msleepAsync(3000); // wait 3000ms 332 avPlayer.pause(); 333 break; 334 case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: 335 nowBitRate = AV_MULTI_HLS_LIVE_BITRATE[2]; 336 avPlayer.setBitrate(nowBitRate); 337 await mediaTestBase.msleepAsync(3000); // wait 3000ms 338 avPlayer.stop(); 339 break; 340 case AVPlayerTestBase.AV_PLAYER_STATE.STOPPED: 341 avPlayer.release(); 342 break; 343 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 344 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED`); 345 avPlayer = null; 346 done(); 347 break; 348 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 349 expect().assertFail(); 350 avPlayer.release(); 351 break; 352 default: 353 break; 354 } 355 }); 356 avPlayer.on('error', (err) => { 357 console.info(`case error called,errName is ${err.name},errCode is ${err.code},errMessage is ${err.message}`); 358 avPlayer.release(); 359 expect().assertFail(); 360 }); 361 avPlayer.on('bitrateDone', (bitrate) => { 362 if (bitrateFlag == 'False') { 363 bitrateFlag = 'True'; 364 }else { 365 expect(bitrate).assertEqual(nowBitRate); 366 } 367 }); 368 console.info(`case src is ${src}`); 369 avPlayer.url = src; 370 } 371 372 /* * 373 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0100 374 * @tc.name : 001.test hls live - stop 375 * @tc.desc : Hls live playback control test 376 * @tc.size : MediumTest 377 * @tc.type : Function test 378 * @tc.level : Level1 379 */ 380 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0100', 0, async function (done) { 381 await media.createAVPlayer().then((video) => { 382 if (typeof (video) != 'undefined') { 383 console.info('case createAVPlayer success'); 384 avPlayer = video; 385 } else { 386 console.error('case createAVPlayer failed'); 387 expect().assertFail(); 388 done(); 389 } 390 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 391 let Steps = new Array('src', 'prepare', 'play', 'pause', 'stop', 'prepare', 'stop', 392 'prepare', 'play', 'stop', 'release'); 393 let surfaceID = globalThis.value; 394 testFun(avPlayer, HLS_PATH, surfaceID, Steps, done); 395 }) 396 397 /* * 398 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0200 399 * @tc.name : 002.test hls live - reset 400 * @tc.desc : Hls live playback control test 401 * @tc.size : MediumTest 402 * @tc.type : Function test 403 * @tc.level : Level1 404 */ 405 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0200', 0, async function (done) { 406 await media.createAVPlayer().then((video) => { 407 if (typeof (video) != 'undefined') { 408 console.info('case createAVPlayer success'); 409 avPlayer = video; 410 } else { 411 console.error('case createAVPlayer failed'); 412 expect().assertFail(); 413 done(); 414 } 415 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 416 let Steps = new Array('src', 'reset', 'src', 'prepare', 'reset', 'src', 'prepare', 'play', 417 'reset', 'src', 'prepare', 'play', 'pause', 'reset','src', 'prepare', 'play', 418 'stop', 'reset', 'release'); 419 let surfaceID = globalThis.value; 420 testFun(avPlayer, HLS_PATH, surfaceID, Steps, done); 421 }) 422 423 /* * 424 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0300 425 * @tc.name : 003.test hls live - set 426 * @tc.desc : Hls live playback control test 427 * @tc.size : MediumTest 428 * @tc.type : Function test 429 * @tc.level : Level2 430 */ 431 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0300', 0, async function (done) { 432 avPlayer = await media.createAVPlayer(); 433 avPlayer.on('stateChange', async (state, reason) => { 434 switch (state) { 435 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 436 avPlayer.surfaceId = surfaceID; 437 avPlayer.audioRendererInfo = audioRendererInfo; 438 avPlayer.prepare(); 439 break; 440 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 441 setAttribute(avPlayer, videoScaleType2, audioInterruptMode2); 442 expectAttributeEqual(avPlayer, audioRendererInfo, videoScaleType2, audioInterruptMode2); 443 avPlayer.play(); 444 break; 445 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 446 setAttribute(avPlayer, videoScaleType1, audioInterruptMode1); 447 expectAttributeEqual(avPlayer, audioRendererInfo, videoScaleType1, audioInterruptMode1); 448 avPlayer.setVolume(0.1); // set volume value is 0.1 449 avPlayer.pause(); 450 break; 451 case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: 452 setAttribute(avPlayer, videoScaleType2, audioInterruptMode2); 453 expectAttributeEqual(avPlayer, audioRendererInfo, videoScaleType2, audioInterruptMode2); 454 avPlayer.release(); 455 break; 456 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 457 avPlayer = null; 458 done(); 459 break; 460 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 461 avPlayer.release(); 462 expect().assertFail(); 463 break; 464 default: 465 break; 466 } 467 }); 468 avPlayer.on('volumeChange', (vol) => { 469 expect(true).assertEqual(Math.abs(0.1 - vol) < 0.05); // set volume value is 0.1, deviation is 0.05 470 }) 471 avPlayer.on('error', (err) => { 472 console.info(`case error called,errName ${err.name},errCode ${err.code},errMessage ${err.message}`); 473 avPlayer.release(); 474 expect().assertFail(); 475 }); 476 avPlayer.url = HLS_PATH; 477 }) 478 479 /* * 480 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0400 481 * @tc.name : 004.test hls live - getTrackDescription 482 * @tc.desc : Hls live playback control test 483 * @tc.size : MediumTest 484 * @tc.type : Function test 485 * @tc.level : Level2 486 */ 487 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0400', 0, async function (done) { 488 await media.createAVPlayer().then((video) => { 489 if (typeof (video) != 'undefined') { 490 avPlayer = video; 491 } else { 492 expect().assertFail(); 493 done(); 494 } 495 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 496 avPlayer.on('stateChange', async (state, reason) => { 497 switch (state) { 498 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 499 avPlayer.surfaceId = surfaceID; 500 avPlayer.prepare(); 501 break; 502 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 503 await avPlayer.getTrackDescription((error, arrList) => { 504 if ((arrList) != null) { 505 for (let i = 0; i < arrList.length; i++) { 506 for (let item in arrList[i]) { 507 console.info(item + ': ' + arrList[i][item])�� 508 } 509 } 510 } else { 511 console.log(`video getTrackDescription fail, error:${error}`); 512 } 513 }); 514 avPlayer.release(); 515 break; 516 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 517 avPlayer = null; 518 done(); 519 break; 520 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 521 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 522 avPlayer.release(); 523 expect().assertFail(); 524 break; 525 default: 526 break; 527 } 528 }); 529 avPlayer.on('error', (err) => { 530 console.info(`case error called,errName is ${err.name}, case error called,errCode is ${err.code}, 531 case error called,errMessage is ${err.message}`); 532 avPlayer.release(); 533 expect().assertFail(); 534 }); 535 console.info(`case src is ${HLS_PATH}`); 536 avPlayer.url = HLS_PATH; 537 }) 538 539 /* * 540 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0500 541 * @tc.name : 005.test hls live - bufferingUpdate 542 * @tc.desc : Hls live playback control test 543 * @tc.size : MediumTest 544 * @tc.type : Function test 545 * @tc.level : Level1 546 */ 547 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0500', 0, async function (done) { 548 await media.createAVPlayer().then((video) => { 549 if (typeof (video) != 'undefined') { 550 console.info('case createAVPlayer success'); 551 avPlayer = video; 552 } else { 553 console.error('case createAVPlayer failed'); 554 expect().assertFail(); 555 done(); 556 } 557 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 558 let Steps = new Array('src', 'prepare', 'play', 'stop', 'reset', 'release'); 559 let surfaceID = globalThis.value; 560 testBufferingUpdate(avPlayer, HLS_PATH, surfaceID, Steps, done); 561 }) 562 563 /* * 564 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0600 565 * @tc.name : 006.test hls live - multiBitrate 566 * @tc.desc : Hls live playback control test 567 * @tc.size : MediumTest 568 * @tc.type : Function test 569 * @tc.level : Level1 570 */ 571 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0600', 0, async function (done) { 572 await media.createAVPlayer().then((video) => { 573 if (typeof (video) != 'undefined') { 574 avPlayer = video; 575 } else { 576 expect().assertFail(); 577 done(); 578 } 579 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 580 avPlayer.on('stateChange', async (state, reason) => { 581 switch (state) { 582 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 583 avPlayer.surfaceId = surfaceID; 584 avPlayer.prepare(); 585 break; 586 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 587 avPlayer.play(); 588 break; 589 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 590 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING`); 591 await mediaTestBase.msleepAsync(8000); // play time 8000ms 592 avPlayer.release(); 593 break; 594 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 595 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED`); 596 avPlayer = null; 597 done(); 598 break; 599 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 600 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 601 expect().assertFail(); 602 avPlayer.release().then(() => { 603 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 604 break; 605 default: 606 break; 607 } 608 }); 609 avPlayer.on('error', (err) => { 610 console.info(`case error called,errName is ${err.name}, case error called,errCode is ${err.code}, 611 case error called,errMessage is ${err.message}`); 612 }); 613 614 avPlayer.on('availableBitrates', (bitrates) => { 615 for (let i = 0; i < bitrates.length; i++) { 616 console.info('case availableBitrates : ' + bitrates[i]); 617 } 618 checkArray(bitrates, AV_MULTI_HLS_LIVE_BITRATE); 619 }); 620 console.info(`case src is ${MULTI_HLS_PATH}`); 621 avPlayer.url = MULTI_HLS_PATH; 622 }) 623 624 /* * 625 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0700 626 * @tc.name : 007.test hls live - multi setBitrate 627 * @tc.desc : Hls live playback control test 628 * @tc.size : MediumTest 629 * @tc.type : Function test 630 * @tc.level : Level1 631 */ 632 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_FUNCTION_0700', 0, async function (done) { 633 await media.createAVPlayer().then((video) => { 634 if (typeof (video) != 'undefined') { 635 console.info('case createAVPlayer success'); 636 avPlayer = video; 637 } else { 638 console.error('case createAVPlayer failed'); 639 expect().assertFail(); 640 done(); 641 } 642 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 643 let surfaceID = globalThis.value; 644 testSetMultiBitrate(avPlayer, MULTI_HLS_PATH, surfaceID, done); 645 }) 646 647 /* * 648 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0100 649 * @tc.name : 008.test hls live - seek 650 * @tc.desc : Hls live playback control test 651 * @tc.size : MediumTest 652 * @tc.type : RELIABILITY test 653 * @tc.level : Level2 654 */ 655 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0100', 0, async function (done) { 656 await media.createAVPlayer().then((video) => { 657 if (typeof (video) != 'undefined') { 658 console.info('case createAVPlayer success'); 659 avPlayer = video; 660 } else { 661 console.error('case createAVPlayer failed'); 662 expect().assertFail(); 663 done(); 664 } 665 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 666 let Steps = new Array('src', 'prepare', 'seek', 6, 'error', 'play', 'seek', 0, 'error', 667 'pause', 'seek', 5, 'error', 'stop', 'seek', 1, 'error', 'release'); // 6, 0, 5, 1 is seek target 668 testReliability(avPlayer, HLS_PATH, surfaceID, Steps, done); 669 }) 670 671 /* * 672 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0200 673 * @tc.name : 009.test hls live - currentTime 674 * @tc.desc : HLS setBitrate test 675 * @tc.size : MediumTest 676 * @tc.type : RELIABILITY test 677 * @tc.level : Level2 678 */ 679 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0200', 0, async function (done) { 680 await media.createAVPlayer().then((video) => { 681 if (typeof (video) != 'undefined') { 682 console.info('case createAVPlayer success'); 683 avPlayer = video; 684 } else { 685 console.error('case createAVPlayer failed'); 686 expect().assertFail(); 687 done(); 688 } 689 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 690 let Steps = new Array('src', 'prepare', 'currentTime', -1, 'play', 'currentTime', -1, 'pause', 691 'currentTime', -1, 'stop', 'currentTime', -1, 'release'); 692 testReliability(avPlayer, HLS_PATH, surfaceID, Steps, done); 693 }) 694 695 /* * 696 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0300 697 * @tc.name : 010.test hls live - loop 698 * @tc.desc : Hls live playback control test 699 * @tc.size : MediumTest 700 * @tc.type : RELIABILITY test 701 * @tc.level : Level2 702 */ 703 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0300', 0, async function (done) { 704 await media.createAVPlayer().then((video) => { 705 if (typeof (video) != 'undefined') { 706 console.info('case createAVPlayer success'); 707 avPlayer = video; 708 } else { 709 console.error('case createAVPlayer failed'); 710 expect().assertFail(); 711 done(); 712 } 713 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 714 let Steps = new Array('src', 'prepare', 'loop', true, 'error', 'play', 'loop', false, 715 'error', 'pause', 'loop', true, 'error', 'stop', 'loop', false, 'error', 'release'); 716 testReliability(avPlayer, HLS_PATH, surfaceID, Steps, done); 717 }) 718 719 /* * 720 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0400 721 * @tc.name : 011.test hls live - duration 722 * @tc.desc : Hls live playback control test 723 * @tc.size : MediumTest 724 * @tc.type : RELIABILITY test 725 * @tc.level : Level2 726 */ 727 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0400', 0, async function (done) { 728 await media.createAVPlayer().then((video) => { 729 if (typeof (video) != 'undefined') { 730 console.info('case createAVPlayer success'); 731 avPlayer = video; 732 } else { 733 console.error('case createAVPlayer failed'); 734 expect().assertFail(); 735 done(); 736 } 737 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 738 let Steps = new Array('src', 'prepare', 'duration', -1, 'play', 'duration', -1, 'pause', 739 'duration', -1, 'stop', 'duration', -1, 'release'); 740 testReliability(avPlayer, HLS_PATH, surfaceID, Steps, done); 741 }) 742 743 /* * 744 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0500 745 * @tc.name : 012.test hls live - setSpeed 746 * @tc.desc : Hls live reliability control test 747 * @tc.size : MediumTest 748 * @tc.type : Reliability test 749 * @tc.level : Level2 750 */ 751 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0500', 0, async function (done) { 752 await media.createAVPlayer().then((video) => { 753 if (typeof (video) != 'undefined') { 754 console.info('case createAVPlayer success'); 755 avPlayer = video; 756 } else { 757 console.error('case createAVPlayer failed'); 758 expect().assertFail(); 759 done(); 760 } 761 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 762 let Steps = new Array('src', 'prepare', 'setSpeed', media.PlaybackSpeed.SPEED_FORWARD_2_00_X, 'error', 'play', 'setSpeed', 763 media.PlaybackSpeed.SPEED_FORWARD_0_75_X, 'error', 764 'pause', 'setSpeed', media.PlaybackSpeed.SPEED_FORWARD_1_75_X, 'error', 'stop', 'setSpeed', 765 media.PlaybackSpeed.SPEED_FORWARD_1_00_X, 'error', 'release'); 766 testReliability(avPlayer, HLS_PATH, surfaceID, Steps, done); 767 }) 768 769 /* * 770 // * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0600 771 // * @tc.name : 013.test hls live - bitrate adaptation 772 // * @tc.desc : Hls live stability test 773 // * @tc.size : MediumTest 774 // * @tc.type : Reliability test 775 // * @tc.level : Level1 776 // */ 777 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_RELIABILITY_0600', 0, async function (done) { 778 let isAdaption = false; 779 await media.createAVPlayer().then((video) => { 780 if (typeof (video) != 'undefined') { 781 avPlayer = video; 782 } else { 783 expect().assertFail(); 784 done(); 785 } 786 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 787 788 avPlayer.on('stateChange', async (state, reason) => { 789 switch (state) { 790 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 791 avPlayer.surfaceId = surfaceID; 792 avPlayer.prepare(); 793 break; 794 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 795 avPlayer.play(); 796 break; 797 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 798 await mediaTestBase.msleepAsync(2000); // play time 2000ms, ensure network had changed 799 avPlayer.release(); 800 break; 801 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 802 avPlayer = null; 803 expect(isAdaption).assertEqual(true); 804 done(); 805 break; 806 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 807 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 808 expect().assertFail(); 809 avPlayer.release(); 810 break; 811 default: 812 break; 813 } 814 }); 815 avPlayer.on('videoSizeChange', (width, height) => { 816 console.info('videoSizeChange success,and width is:' + width + ', height is :' + height) 817 isAdaption = true; 818 }) 819 avPlayer.on('error', (err) => { 820 console.info(`case error called,errName is ${err.name}, case error called,errCode is ${err.code}, 821 case error called,errMessage is ${err.message}`); 822 avPlayer.release(); 823 expect().assertFail(); 824 }); 825 console.info(`case src is ${HLS_PATH}`); 826 avPlayer.url = MULTI_HLS_PATH; 827 }) 828 829 /* * 830 * @tc.number : SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_STABILITY_0100 831 * @tc.name : 013.test hls live - 1000 times to pause 832 * @tc.desc : Hls live stability test 833 * @tc.size : MediumTest 834 * @tc.type : Stability test 835 * @tc.level : Level1 836 */ 837 it('SUB_MULTIMEDIA_MEDIA_AVPLAYER_HLS_Live_STABILITY_0100', 0, async function (done) { 838 let pauseTimes = 0; 839 await media.createAVPlayer().then((video) => { 840 if (typeof (video) != 'undefined') { 841 avPlayer = video; 842 } else { 843 expect().assertFail(); 844 done(); 845 } 846 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 847 848 avPlayer.on('stateChange', async (state, reason) => { 849 switch (state) { 850 case AVPlayerTestBase.AV_PLAYER_STATE.INITIALIZED: 851 avPlayer.surfaceId = surfaceID; 852 avPlayer.prepare(); 853 break; 854 case AVPlayerTestBase.AV_PLAYER_STATE.PREPARED: 855 avPlayer.play(); 856 break; 857 case AVPlayerTestBase.AV_PLAYER_STATE.PLAYING: 858 if ((pauseTimes++) < 1000) { 859 avPlayer.pause(); 860 } else { 861 avPlayer.release(); 862 } 863 break; 864 case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED: 865 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.PAUSED`); 866 avPlayer.play(); 867 break; 868 case AVPlayerTestBase.AV_PLAYER_STATE.RELEASED: 869 avPlayer = null; 870 done(); 871 break; 872 case AVPlayerTestBase.AV_PLAYER_STATE.ERROR: 873 console.info(`case AVPlayerTestBase.AV_PLAYER_STATE.ERROR`); 874 expect().assertFail(); 875 avPlayer.release(); 876 break; 877 default: 878 break; 879 } 880 }); 881 avPlayer.on('error', (err) => { 882 console.info(`case error called,errName is ${err.name}, case error called,errCode is ${err.code}, 883 case error called,errMessage is ${err.message}`); 884 avPlayer.release(); 885 expect().assertFail(); 886 }); 887 console.info(`case src is ${HLS_PATH}`); 888 avPlayer.url = HLS_PATH; 889 }) 890 }) 891} 892