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 * as mediaTestBase from '../../../../../../MediaTestBase'; 17import media from '@ohos.multimedia.media' 18import audio from '@ohos.multimedia.audio'; 19import { testAVPlayerFun, AV_PLAYER_STATE, setSource } from '../../../../../../AVPlayerTestBase.js'; 20import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; 21 22export default function AVPlayerLocalTest() { 23 describe('AVPlayerLocalTest', function () { 24 const VIDEO_SOURCE = 'H264_AAC.mp4'; 25 const AUDIO_SOURCE = '01.mp3'; 26 const VIDEO_NOAUDIO = 'H264_NONE.mp4' 27 const PLAY_TIME = 3000; 28 const TAG = 'AVPlayerLocalTest:'; 29 let fileDescriptor = null; 30 let fileDescriptor2 = null; 31 let fileDescriptor3 = null; 32 let avPlayer = null; 33 let avPlayTest = { 34 width: 0, 35 height: 0, 36 duration: -1, 37 } 38 let fdPath = ''; 39 let fdNumber = 0; 40 41 beforeAll(async function() { 42 console.info('beforeAll case'); 43 await mediaTestBase.getStageFileDescriptor(VIDEO_SOURCE).then((res) => { 44 fileDescriptor = res; 45 }); 46 await mediaTestBase.getStageFileDescriptor(AUDIO_SOURCE).then((res) => { 47 fileDescriptor2 = res; 48 }); 49 await mediaTestBase.getStageFileDescriptor(VIDEO_NOAUDIO).then((res) => { 50 fileDescriptor3 = res; 51 }); 52 }) 53 54 beforeEach(async function() { 55 console.info('beforeEach case'); 56 }) 57 58 afterEach(async function() { 59 if (avPlayer != null) { 60 avPlayer.release().then(() => { 61 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 62 } 63 console.info('afterEach case'); 64 }) 65 66 afterAll(async function() { 67 console.info('afterAll case'); 68 await mediaTestBase.closeFileDescriptor(VIDEO_SOURCE); 69 await mediaTestBase.closeFileDescriptor(AUDIO_SOURCE); 70 await mediaTestBase.closeFileDescriptor(VIDEO_NOAUDIO); 71 }) 72 73 function setAVPlayerTrackCb(avPlayer, descriptionKey, descriptionValue, done) { 74 let arrayDescription; 75 let surfaceID = globalThis.value; 76 avPlayer.on('stateChange', async (state, reason) => { 77 switch (state) { 78 case AV_PLAYER_STATE.INITIALIZED: 79 console.info(`case AV_PLAYER_STATE.INITIALIZED`); 80 avPlayer.surfaceId = surfaceID; 81 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 82 avPlayer.prepare((err) => { 83 console.info('case prepare called' + err); 84 if (err != null) { 85 console.error(`case prepare error, errMessage is ${err.message}`); 86 expect().assertFail(); 87 done(); 88 } else { 89 console.info('case avPlayer.duration: ' + avPlayer.duration); 90 } 91 }); 92 break; 93 case AV_PLAYER_STATE.PREPARED: 94 await avPlayer.getTrackDescription().then((arrayList) => { 95 console.info('case getTrackDescription called!!'); 96 if (typeof (arrayList) != 'undefined') { 97 arrayDescription = arrayList; 98 } else { 99 console.info('case getTrackDescription is failed'); 100 expect().assertFail(); 101 } 102 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 103 expect(descriptionKey.length).assertEqual(arrayDescription.length); 104 for (let i = 0; i < arrayDescription.length; i++) { 105 mediaTestBase.checkDescription(arrayDescription[i], descriptionKey[i], descriptionValue[i]); 106 } 107 avPlayer.getTrackDescription((error, arrayList) => { 108 if (error == null) { 109 for (let i = 0; i < arrayList.length; i++) { 110 mediaTestBase.checkDescription(arrayList[i], descriptionKey[i], descriptionValue[i]); 111 } 112 } else { 113 console.info('getTrackDescription failed, message is:' + error.message); 114 } 115 avPlayer.release(); 116 }) 117 break; 118 case AV_PLAYER_STATE.RELEASED: 119 avPlayer = null; 120 done(); 121 break; 122 case AV_PLAYER_STATE.ERROR: 123 expect().assertFail(); 124 avPlayer.release().then(() => { 125 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 126 avPlayer = null; 127 break; 128 default: 129 break; 130 } 131 }) 132 } 133 134 async function testCheckTrackDescription(src, avPlayer, descriptionKey, descriptionValue, done) { 135 console.info(`case media source: ${src}`) 136 media.createAVPlayer((err, video) => { 137 console.info(`case media err: ${err}`) 138 if (typeof (video) != 'undefined') { 139 console.info('case createAVPlayer success'); 140 avPlayer = video; 141 setAVPlayerTrackCb(avPlayer, descriptionKey, descriptionValue, done) 142 setSource(avPlayer, src); 143 } 144 if (err != null) { 145 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 146 expect().assertFail(); 147 done(); 148 } 149 }); 150 } 151 152 async function setAVPlayerScaleCb(avPlayer, done) { 153 let surfaceID = globalThis.value; 154 let count = 0; 155 avPlayer.on('stateChange', async (state, reason) => { 156 switch (state) { 157 case AV_PLAYER_STATE.INITIALIZED: 158 console.info(`case AV_PLAYER_STATE.INITIALIZED`); 159 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 160 avPlayer.surfaceId = surfaceID; 161 avPlayer.prepare((err) => { 162 console.info('case prepare called' + err); 163 avPlayer.loop = true; 164 if (err != null) { 165 console.error(`case prepare error, errMessage is ${err.message}`); 166 expect().assertFail(); 167 done(); 168 } else { 169 console.info('case avPlayer.duration: ' + avPlayer.duration); 170 } 171 }); 172 break; 173 case AV_PLAYER_STATE.PREPARED: 174 console.info('case prepare called'); 175 avPlayer.play((err) => { 176 console.info('case play called' + err); 177 if (err != null) { 178 console.error(`case play error, errMessage is ${err.message}`); 179 expect().assertFail(); 180 done(); 181 } else { 182 console.info('case avPlayer.duration: ' + avPlayer.duration); 183 } 184 }); 185 break; 186 case AV_PLAYER_STATE.PLAYING: 187 console.info('case playing called'); 188 for (let i = 0; i < 20; i++) { 189 if (count == 0) { 190 console.info('case set videoScaleType : 1'); 191 avPlayer.videoScaleType = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT_CROP; 192 count = 1; 193 } else { 194 console.info('case set videoScaleType : 0'); 195 avPlayer.videoScaleType = media.VideoScaleType.VIDEO_SCALE_TYPE_FIT; 196 count = 0; 197 } 198 await mediaTestBase.msleepAsync(500); 199 } 200 avPlayer.loop = false; 201 break; 202 case AV_PLAYER_STATE.COMPLETED: 203 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); 204 expect(avPlayer.currentTime).assertEqual(avPlayer.duration); 205 avPlayer.release(); 206 break; 207 case AV_PLAYER_STATE.RELEASED: 208 avPlayer = null; 209 done(); 210 break; 211 case AV_PLAYER_STATE.ERROR: 212 expect().assertFail(); 213 avPlayer.release().then(() => { 214 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 215 avPlayer = null; 216 break; 217 default: 218 break; 219 } 220 }) 221 } 222 223 async function testVideoScaleType(src, avPlayer, done) { 224 console.info(`case media source: ${src}`) 225 media.createAVPlayer((err, video) => { 226 console.info(`case media err: ${err}`) 227 if (typeof (video) != 'undefined') { 228 console.info('case createAVPlayer success'); 229 avPlayer = video; 230 setAVPlayerScaleCb(avPlayer, done) 231 setSource(avPlayer, src); 232 } 233 if (err != null) { 234 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 235 expect().assertFail(); 236 done(); 237 } 238 }); 239 } 240 241 async function testAudioInterruptMode(audioSource, videoSource, done) { 242 let testAVPlayer01 = await media.createAVPlayer(); 243 let testAVPlayer02 = await media.createAVPlayer(); 244 let surfaceID = globalThis.value; 245 testAVPlayer01.on('stateChange', async (state, reason) => { 246 switch (state) { 247 case AV_PLAYER_STATE.INITIALIZED: 248 console.info(`case AV_PLAYER_STATE.INITIALIZED`); 249 expect(testAVPlayer01.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 250 testAVPlayer01.prepare((err) => { 251 console.info('case prepare called' + err); 252 if (err != null) { 253 console.error(`case prepare error, errMessage is ${err.message}`); 254 expect().assertFail(); 255 done(); 256 } else { 257 console.info('case avPlayer.duration: ' + testAVPlayer01.duration); 258 } 259 }); 260 break; 261 case AV_PLAYER_STATE.PREPARED: 262 testAVPlayer01.audioInterruptMode = audio.InterruptMode.INDEPENDENT_MODE; 263 testAVPlayer01.play(); 264 break; 265 case AV_PLAYER_STATE.PLAYING: 266 testAVPlayer02.fdSrc = videoSource; 267 break; 268 case AV_PLAYER_STATE.RELEASED: 269 break; 270 case AV_PLAYER_STATE.ERROR: 271 expect().assertFail(); 272 testAVPlayer01.release().then(() => { 273 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 274 break; 275 default: 276 break; 277 } 278 }) 279 280 testAVPlayer01.on('audioInterrupt', async (info) => { 281 console.info('case audioInterrupt1 is called, info is :' + JSON.stringify(info)); 282 await testAVPlayer02.release(); 283 await testAVPlayer01.release().then(() => { 284 console.info('case release called!!'); 285 done(); 286 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 287 }); 288 289 testAVPlayer02.on('stateChange', async (state, reason) => { 290 switch (state) { 291 case AV_PLAYER_STATE.INITIALIZED: 292 console.info(`case AV_PLAYER_STATE.INITIALIZED`); 293 expect(testAVPlayer02.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 294 testAVPlayer02.surfaceId = surfaceID; 295 testAVPlayer02.prepare((err) => { 296 console.info('case prepare called' + err); 297 if (err != null) { 298 console.error(`case prepare error, errMessage is ${err.message}`); 299 expect().assertFail(); 300 done(); 301 } else { 302 console.info('case avPlayer.duration: ' + testAVPlayer02.duration); 303 } 304 }); 305 break; 306 case AV_PLAYER_STATE.PREPARED: 307 testAVPlayer02.play(); 308 break; 309 case AV_PLAYER_STATE.PLAYING: 310 break; 311 case AV_PLAYER_STATE.RELEASED: 312 break; 313 case AV_PLAYER_STATE.ERROR: 314 expect().assertFail(); 315 testAVPlayer02.release().then(() => { 316 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 317 break; 318 default: 319 break; 320 } 321 }) 322 testAVPlayer01.fdSrc = audioSource; 323 } 324 325 async function setOnCallback(avPlayer, done) { 326 let surfaceID = globalThis.value; 327 let count = 0; 328 let playCount = 0; 329 avPlayer.on('endOfStream', () => { 330 count++; 331 console.info(TAG + 'endOfStream success') 332 avPlayer.off('endOfStream') 333 }) 334 avPlayer.on('stateChange', async (state, reason) => { 335 switch (state) { 336 case AV_PLAYER_STATE.INITIALIZED: 337 console.info(`case AV_PLAYER_STATE.INITIALIZED`); 338 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.INITIALIZED); 339 avPlayer.surfaceId = surfaceID; 340 avPlayer.prepare((err) => { 341 console.info('case prepare called' + err); 342 if (err != null) { 343 console.error(`case prepare error, errMessage is ${err.message}`); 344 expect().assertFail(); 345 done(); 346 } else { 347 console.info('case avPlayer.duration: ' + avPlayer.duration); 348 } 349 }); 350 break; 351 case AV_PLAYER_STATE.PREPARED: 352 console.info('case prepare called'); 353 avPlayer.play().then(() => { 354 console.info('play called success') 355 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 356 break; 357 case AV_PLAYER_STATE.PLAYING: 358 if (playCount == 0) { 359 playCount++; 360 avPlayer.pause().then(() => { 361 console.info('play called success') 362 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 363 } 364 console.info('case playing called'); 365 break; 366 case AV_PLAYER_STATE.PAUSED: 367 avPlayer.play((err) => { 368 console.info('case play called'); 369 if (err != null) { 370 console.error(`case play error, errMessage is ${err.message}`); 371 expect().assertFail(); 372 done(); 373 } else { 374 console.info('case avPlayer.duration: ' + avPlayer.duration); 375 } 376 }); 377 console.info('case pause called'); 378 break; 379 case AV_PLAYER_STATE.STOPPED: 380 expect(count).assertEqual(1); 381 console.info('case stop called'); 382 avPlayer.release().then(() => { 383 console.info('play stop success') 384 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 385 break; 386 case AV_PLAYER_STATE.COMPLETED: 387 expect(avPlayer.state).assertEqual(AV_PLAYER_STATE.COMPLETED); 388 expect(avPlayer.currentTime).assertEqual(avPlayer.duration); 389 if (playCount == 1) { 390 playCount++ 391 avPlayer.play().then(() => { 392 console.info('play called success') 393 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 394 } else { 395 avPlayer.stop().then(() => { 396 console.info('play stop success') 397 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 398 } 399 break; 400 case AV_PLAYER_STATE.RELEASED: 401 avPlayer = null; 402 done(); 403 break; 404 case AV_PLAYER_STATE.ERROR: 405 expect().assertFail(); 406 avPlayer.release().then(() => { 407 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 408 avPlayer = null; 409 break; 410 default: 411 break; 412 } 413 }) 414 } 415 async function testOffCallback(src, avPlayer, done) { 416 console.info(`case media source: ${src}`) 417 media.createAVPlayer((err, video) => { 418 console.info(`case media err: ${err}`) 419 if (typeof (video) != 'undefined') { 420 console.info('case createAVPlayer success'); 421 avPlayer = video; 422 setOnCallback(avPlayer, done) 423 setSource(avPlayer, src); 424 } 425 if (err != null) { 426 console.error(`case createAVPlayer error, errMessage is ${err.message}`); 427 expect().assertFail(); 428 done(); 429 } 430 }); 431 } 432 433 /* * 434 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_FDSRC_0100 435 * @tc.name : 001.test fdsrc 436 * @tc.desc : Local Video playback control test 437 * @tc.size : MediumTest 438 * @tc.type : Function test 439 * @tc.level : Level0 440 */ 441 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_FDSRC_0100', 0, async function (done) { 442 avPlayTest = { width: 720, height: 480, duration: 10100 }; 443 testAVPlayerFun(fileDescriptor, avPlayer, avPlayTest, PLAY_TIME, done); 444 }) 445 446 /* * 447 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0100 448 * @tc.name : 001.test getTrackDescription 449 * @tc.desc : Local Video playback control test 450 * @tc.size : MediumTest 451 * @tc.type : Function test 452 * @tc.level : Level1 453 */ 454 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0100', 0, async function (done) { 455 let videoTrackKey = new Array('bitrate', 'codec_mime', 'frame_rate', 'height', 456 'track_index', 'track_type', 'width'); 457 let audioTrackKey = new Array('bitrate', 'channel_count', 'codec_mime', 'sample_rate', 458 'track_index', 'track_type'); 459 let videoTrackValue = new Array(1366541, 0, 6000, 480, 0, 1, 720); 460 let audioTrackValue = new Array(129207, 2, 1, 44100, 1, 0); 461 let descriptionKey = new Array(videoTrackKey, audioTrackKey); 462 let descriptionValue = new Array(videoTrackValue, audioTrackValue); 463 testCheckTrackDescription(fileDescriptor, avPlayer, descriptionKey, descriptionValue, done) 464 }) 465 466 /* * 467 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0200 468 * @tc.name : 002.test getTrackDescription 469 * @tc.desc : Local Video playback control test 470 * @tc.size : MediumTest 471 * @tc.type : Function test 472 * @tc.level : Level1 473 */ 474 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0200', 0, async function (done) { 475 let audioTrackKey = new Array('channel_count', 'codec_mime', 'sample_rate', 'track_index', 476 'track_type'); 477 let audioTrackValue = new Array(1, 2, 48000, 0, 0); 478 let descriptionKey = new Array(audioTrackKey); 479 let descriptionValue = new Array(audioTrackValue); 480 testCheckTrackDescription(fileDescriptor2, avPlayer, descriptionKey, descriptionValue, done) 481 }) 482 483 /* * 484 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0300 485 * @tc.name : 003.test getTrackDescription 486 * @tc.desc : Local Video playback control test 487 * @tc.size : MediumTest 488 * @tc.type : Function test 489 * @tc.level : Level1 490 */ 491 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_GETTRECKDESCRIPTION_0300', 0, async function (done) { 492 let videoTrackKey = new Array('bitrate', 'codec_mime', 'frame_rate', 'height', 493 'track_index', 'track_type', 'width'); 494 let videoTrackValue = new Array(1506121, 0, 6000, 480, 0, 1, 720); 495 let descriptionKey = new Array(videoTrackKey); 496 let descriptionValue = new Array(videoTrackValue); 497 testCheckTrackDescription(fileDescriptor3, avPlayer, descriptionKey, descriptionValue, done) 498 }) 499 500 /* * 501 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_VIDEOSCALETYPE_0100 502 * @tc.name : 001.test video player videoScaleTpe 503 * @tc.desc : Local Video playback control test 504 * @tc.size : MediumTest 505 * @tc.type : Function test 506 * @tc.level : Level1 507 */ 508 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_VIDEOSCALETYPE_0100', 0, async function (done) { 509 testVideoScaleType(fileDescriptor, avPlayer, done); 510 }) 511 512 /* * 513 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0100 514 * @tc.name : 001.test audioInterruptMode Function 515 * @tc.desc : Local Video playback control test 516 * @tc.size : MediumTest 517 * @tc.type : Function test 518 * @tc.level : Level1 519 */ 520 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0100', 0, async function (done) { 521 testAudioInterruptMode(fileDescriptor2, fileDescriptor, done); 522 }) 523 524 /* * 525 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0200 526 * @tc.name : 002.test audioInterruptMode Function 527 * @tc.desc : Local Video playback control test 528 * @tc.size : MediumTest 529 * @tc.type : Function test 530 * @tc.level : Level1 531 */ 532 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_AUDIOINTERRUPTMODE_0200', 0, async function (done) { 533 testAudioInterruptMode(fileDescriptor, fileDescriptor2, done); 534 }) 535 536 /* * 537 * @tc.number : SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_OFF_CALLBACK_0100 538 * @tc.name : 001.test off callback Function 539 * @tc.desc : Local Video playback control test 540 * @tc.size : MediumTest 541 * @tc.type : Function test 542 * @tc.level : Level1 543 */ 544 it('SUB_MULTIMEDIA_MEDIA_VIDEO_PLAYER_OFF_CALLBACK_0100', 0, async function (done) { 545 testOffCallback(fileDescriptor, avPlayer, done); 546 }) 547 }) 548}