1/** 2 * Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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 deviceInfo from '@ohos.deviceInfo' 17import media from '@ohos.multimedia.media' 18import camera from '@ohos.multimedia.camera' 19import photoAccessHelper from '@ohos.file.photoAccessHelper'; 20import * as mediaTestBase from '../../../../../MediaTestBase.js'; 21import * as avRecorderTestBase from '../../../../../AVRecorderTestBase.js'; 22import * as avVideoRecorderTestBase from '../../../../../AvVideoRecorderTestBase.js'; 23import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from '@ohos/hypium'; 24 25export default function avVideoRecorderTestOne() { 26 describe('avVideoRecorderTestOne', function () { 27 let avRecorder = null; 28 let isInitCamera = false; 29 const recorderTime = 3000; 30 const RECORDER_LONG_TIME = 3600000; 31 const LOOP_TIMES = 1000; 32 const FORMAT_M4A = media.ContainerFormatType.CFT_MPEG_4A; 33 const ENCORDER_AAC = media.CodecMimeType.AUDIO_AAC; 34 const ONLYAUDIO_TYPE = 'only_audio'; 35 let trackArray; 36 let fdObject; 37 let fdPath; 38 let maxAmplitudeStartTimes = 0; 39 let maxAmplitudePauseTimes = 0; 40 let TAG = "[avVideoRecorderTestOne] "; 41 let avProfile = { 42 audioBitrate : 48000, 43 audioChannels : 2, 44 audioCodec : media.CodecMimeType.AUDIO_AAC, 45 audioSampleRate : 48000, 46 fileFormat : media.ContainerFormatType.CFT_MPEG_4, 47 videoBitrate : 280000, // 视频比特率 48 videoCodec : media.CodecMimeType.VIDEO_AVC, 49 videoFrameWidth : 640, // 视频分辨率的宽 50 videoFrameHeight : 480, // 视频分辨率的高 51 videoFrameRate : 30 // 视频帧率 52 } 53 54 let metaData = { 55 genre : "{marketing-name:\"HHH XXX\"}", 56 videoOrientation : "180", 57 location : { latitude : 35, longitude : 135 }, 58 customInfo : { 59 "com.hh.version" : "5", 60 } 61 } 62 63 let AutoCreateConfig = { 64 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 65 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 66 profile: avProfile, 67 url : '', 68 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 69 location : { latitude : 30, longitude : 130 }, 70 fileGenerationMode : media.FileGenerationMode.APP_CREATE, 71 } 72 73 let avmetaConfig = { 74 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 75 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 76 profile: avProfile, 77 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 78 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 79 location : { latitude : 30, longitude : 130 }, 80 metadata : metaData, 81 } 82 83 let avConfig = { 84 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 85 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 86 profile: avProfile, 87 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 88 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 89 location : { latitude : 30, longitude : 130 }, 90 } 91 92 let avProfileMpeg = { 93 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 94 videoBitrate: 280000, 95 videoCodec: media.CodecMimeType.VIDEO_AVC, 96 videoFrameWidth: 640, 97 videoFrameHeight: 480, 98 videoFrameRate: 30 99 } 100 let avConfigMpeg = { 101 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 102 profile: avProfileMpeg, 103 url: 'fd://35', 104 rotation: 0, 105 location: { 106 latitude: 30, longitude: 130 107 } 108 } 109 let avProfileMpegAac = { 110 audioBitrate: 48000, 111 audioChannels: 2, 112 audioCodec: media.CodecMimeType.AUDIO_AAC, 113 audioSampleRate: 48000, 114 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 115 videoBitrate: 280000, 116 videoCodec: media.CodecMimeType.VIDEO_AVC, 117 videoFrameWidth: 640, 118 videoFrameHeight: 480, 119 videoFrameRate: 30 120 } 121 let avConfigMpegAac = { 122 audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 123 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 124 profile: avProfileMpegAac, 125 url: 'fd://35', 126 rotation: 0, 127 location: { 128 latitude: 30, longitude: 130 129 } 130 } 131 let avProfileH264 = { 132 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 133 videoBitrate: 280000, 134 videoCodec: media.CodecMimeType.VIDEO_AVC, 135 videoFrameWidth: 640, 136 videoFrameHeight: 480, 137 videoFrameRate: 30 138 } 139 let avConfigH264 = { 140 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 141 profile: avProfileH264, 142 url: 'fd://35', 143 rotation: 0, 144 location: { 145 latitude: 30, longitude: 130 146 } 147 } 148 149 let avProfileH265 = { 150 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 151 videoBitrate: 280000, 152 videoCodec: media.CodecMimeType.VIDEO_HEVC, 153 videoFrameWidth: 640, 154 videoFrameHeight: 480, 155 videoFrameRate: 30 156 } 157 let avConfigH265 = { 158 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 159 profile: avProfileH265, 160 url: 'fd://35', 161 rotation: 0, 162 location: { 163 latitude: 30, longitude: 130 164 } 165 } 166 167 let avProfileH264Aac = { 168 audioBitrate: 48000, 169 audioChannels: 2, 170 audioCodec: media.CodecMimeType.AUDIO_AAC, 171 audioSampleRate: 48000, 172 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 173 videoBitrate: 280000, 174 videoCodec: media.CodecMimeType.VIDEO_AVC, 175 videoFrameWidth: 640, 176 videoFrameHeight: 480, 177 videoFrameRate: 30 178 } 179 let avConfigH264Aac = { 180 audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 181 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 182 profile: avProfileH264Aac, 183 url: 'fd://35', 184 rotation: 0, 185 location: { 186 latitude: 30, longitude: 130 187 } 188 } 189 190 let avProfileH265Aac = { 191 audioBitrate: 48000, 192 audioChannels: 2, 193 audioCodec: media.CodecMimeType.AUDIO_AAC, 194 audioSampleRate: 48000, 195 fileFormat: media.ContainerFormatType.CFT_MPEG_4, 196 videoBitrate: 280000, 197 videoCodec: media.CodecMimeType.VIDEO_HEVC, 198 videoFrameWidth: 640, 199 videoFrameHeight: 480, 200 videoFrameRate: 30, 201 isHdr: false, 202 enableTemporalScale: false 203 } 204 let avConfigH265Aac = { 205 audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 206 videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 207 profile: avProfileH265Aac, 208 url: 'fd://35', 209 rotation: 0, 210 location: { 211 latitude: 30, longitude: 130 212 } 213 } 214 215 let avConfigOnlyAac = { 216 audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 217 profile: avProfileH264Aac, 218 url: 'fd://35', 219 rotation: 0, 220 location: { 221 latitude: 30, longitude: 130 222 } 223 } 224 225 let events = require('events'); 226 let eventEmitter = new events.EventEmitter(); 227 228 const CREATE_CALLBACK_EVENT = 'createCallback'; 229 const SETONCALLBACK_EVENT = 'setAvRecorderCallback'; 230 const SETPHOTOASSETCALLBACK_EVENT = 'setPhotoAssetCallback'; 231 const PREPARE_CALLBACK_EVENT = 'prepareCallback'; 232 const GETINPUTSURFACE_CALLBACK_EVENT = 'getInputSurfaceCallback'; 233 const INITCAMERA_EVENT = 'initCamera'; 234 const STARTCAMERA_EVENT = 'startCameraOutput'; 235 const STOPCAMERA_EVENT = 'stopCameraOutput'; 236 const STARTRECORDER_CALLBACK_EVENT = 'startCallback'; 237 const PAUSERECORDER_CALLBACK_EVENT = 'pauseCallback'; 238 const RESUMERECORDER_CALLBACK_EVENT = 'resumeCallback'; 239 const STOPRECORDER_CALLBACK_EVENT = 'stopCallback'; 240 const RESETRECORDER_CALLBACK_EVENT = 'resetCallback'; 241 const RELEASECORDER_CALLBACK_EVENT = 'releaseCallback'; 242 const RELEASECAMERA_EVENT = 'releaseCamera'; 243 const CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT = 'audioCapturerInfoCallback'; 244 const ENCODER_INFO_CALLBACK_EVENT = 'availableEncoderCallback'; 245 const MAX_AMPLITUDE_CALLBACK_EVENT = 'maxAmplitudeCallback'; 246 const END_EVENT = 'end'; 247 248 const CREATE_PROMISE_EVENT = 'createPromise'; 249 const PREPARE_PROMISE_EVENT = 'preparePromise'; 250 const GETINPUTSURFACE_PROMISE_EVENT = 'getInputSurfacePromise'; 251 const GETAVRECORDERCONFIG_PROMISE_EVENT = 'getAVRecorderConfigPromise'; 252 const STARTRECORDER_PROMISE_EVENT = 'startPromise'; 253 const PAUSERECORDER_PROMISE_EVENT = 'pausePromise'; 254 const RESUMERECORDER_PROMISE_EVENT = 'resumePromise'; 255 const STOPRECORDER_PROMISE_EVENT = 'stopPromise'; 256 const RESETRECORDER_PROMISE_EVENT = 'resetPromise'; 257 const RELEASECORDER_PROMISE_EVENT = 'releasePromise'; 258 const CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT = 'audioCapturerInfoPromise'; 259 const ENCODER_INFO_PROMISE_EVENT = 'availableEncoderPromise'; 260 const MAX_AMPLITUDE_PROMISE_EVENT = 'maxAmplitudePromise'; 261 262 const UPDATE_ROTATION_EVENT = 'updateRotationEvent'; 263 264 let cameraManager; 265 let videoOutput; 266 let captureSession; 267 let cameraInput; 268 let previewOutput; 269 let cameraOutputCap; 270 let videoSurfaceId = null; 271 let myVideoProfile = null; 272 let myPreviewProfile = null; 273 let isSupportCameraVideoProfiles = true; 274 275 beforeAll(async function () { 276 console.info('beforeAll in1'); 277 let permissionName1 = 'ohos.permission.MICROPHONE'; 278 let permissionName2 = 'ohos.permission.MEDIA_LOCATION'; 279 let permissionName3 = 'ohos.permission.READ_MEDIA'; 280 let permissionName4 = 'ohos.permission.WRITE_MEDIA'; 281 let permissionName5 = 'ohos.permission.CAMERA'; 282 let permissionNames = [permissionName1, permissionName2, permissionName3, permissionName4, permissionName5]; 283 await mediaTestBase.getPermission(permissionNames); 284 await mediaTestBase.msleepAsync(5000); 285 await mediaTestBase.driveFn(4) 286 287 let context = globalThis.contextVideo; 288 console.info('initCamera 002'); 289 cameraManager = camera.getCameraManager(context) 290 console.info('initCamera 003'); 291 if (!cameraManager) { 292 console.error("camera.getCameraManager error") 293 return; 294 } 295 let cameras = cameraManager.getSupportedCameras(); 296 let cameraDevice = cameras[0]; 297 console.info('initCamera 006'); 298 let cameraOutputCapability = cameraManager.getSupportedOutputCapability(cameraDevice); 299 if (cameraOutputCapability?.videoProfiles) { 300 console.info('initCamera 007'); 301 setProfileSize(cameraOutputCapability.videoProfiles,cameraOutputCapability.previewProfiles); 302 let configs = [avConfig, avConfigMpeg, avConfigMpegAac, avConfigH264, avConfigH264Aac, avConfigH265, avConfigH265Aac] 303 for (let i = 0; i < configs.length; i++) { 304 checkDevice(configs[i]) 305 } 306 avConfigH264.profile.videoBitrate = 280000; 307 avConfigH264Aac.profile.videoBitrate = 280000; 308 309 console.info('beforeAll out'); 310 311 } else { 312 isSupportCameraVideoProfiles = false; 313 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 314 console.info('beforeAll out'); 315 } 316 317 console.info('beforeAll out'); 318 }) 319 320 beforeEach(async function () { 321 console.info('beforeEach case'); 322 if (isSupportCameraVideoProfiles) { 323 await avRecorderTestBase.sleep(1000); 324 fdObject = null; 325 } 326 }) 327 328 afterEach(async function () { 329 console.info('afterEach case'); 330 if (isSupportCameraVideoProfiles) { 331 isInitCamera = false 332 if (avRecorder != null) { 333 avRecorder.release().then(() => { 334 console.info(TAG + 'this testCase execution completed') 335 }, mediaTestBase.failureCallback).catch(mediaTestBase.catchCallback); 336 } 337 await mediaTestBase.closeFd(fdObject?.fdNumber); 338 await avRecorderTestBase.sleep(1000); 339 } 340 }) 341 342 afterAll(function () { 343 console.info('afterAll case'); 344 }) 345 346 function setProfileSize(videoProfiles, previewProfiles) { 347 console.log('choosen videoProfiles: ' + JSON.stringify(videoProfiles)); 348 console.log('choosen previewProfiles: ' + JSON.stringify(previewProfiles)); 349 350 let myVideoProfile0 = []; 351 let myPreviewProfile0 = []; 352 outerLoop: for (let i = 0; i < videoProfiles.length; i++) { 353 for (let j = 0; j < previewProfiles.length; j++) { 354 if(checkIfQuotientsAreEqual(videoProfiles[i], previewProfiles[j])){ 355 myVideoProfile0[0] = videoProfiles[i]; 356 myPreviewProfile0[0] = previewProfiles[j]; 357 console.log('choosen myVideoProfile0: ' + JSON.stringify(myVideoProfile0)); 358 console.log('choosen myPreviewProfile0: ' + JSON.stringify(myPreviewProfile0)); 359 break outerLoop; 360 } 361 } 362 } 363 myVideoProfile = myVideoProfile0[0]; 364 myPreviewProfile = myPreviewProfile0[0]; 365 console.log('choosen myVideoProfile: ' + JSON.stringify(myVideoProfile)); 366 console.log('choosen myPreviewProfile: ' + JSON.stringify(myPreviewProfile)); 367 } 368 369 function checkIfQuotientsAreEqual(videoProfileSize, previewProfileSize) { 370 return (videoProfileSize.size.width / videoProfileSize.size.height) === (previewProfileSize.size.width / previewProfileSize.size.height); 371 } 372 373 function checkDevice(avConfig) { 374 if (deviceInfo.deviceType === 'default') { 375 avConfig.videoSourceType = media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES 376 } else { 377 avConfig.videoSourceType = media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_YUV 378 } 379 avConfig.profile.videoFrameWidth = myVideoProfile.size.width; 380 avConfig.profile.videoFrameHeight = myVideoProfile.size.height; 381 } 382 383 async function initCamera(avRecorder, avConfig, recorderTime, steps, done) { 384 // 获取相机列表 385 let cameras = cameraManager.getSupportedCameras(); 386 let cameraDevice = cameras[0]; 387 // 创建相机输入流 388 try { 389 cameraInput = cameraManager.createCameraInput(cameraDevice); 390 console.info('createCameraInput success'); 391 } catch (error) { 392 console.error('Failed to createCameraInput errorCode = ' + error.code); 393 } 394 // 监听cameraInput错误信息 395 cameraInput.on('error', cameraDevice, (error) => { 396 console.log(`Camera input error code: ${error.code}`); 397 }) 398 399 // 创建VideoOutput对象 400 // let profile = cameraOutputCapability.videoProfiles[0]; 401 let profile = myVideoProfile; 402 console.log('choosen[0] profile: ' + JSON.stringify(profile)); 403 try { 404 videoOutput = cameraManager.createVideoOutput(profile, videoSurfaceId) 405 console.info('createVideoOutput success'); 406 } catch (error) { 407 console.error('Failed to create the videoOutput instance. errorCode = ' + error.code); 408 } 409 // 监听视频输出错误信息 410 videoOutput.on('error', (error) => { 411 console.log(`Preview output error code: ${error.code}`); 412 }) 413 414 // 创建previewOutput输出对象 415 let surfaceId = globalThis.value; 416 let previewProfile = myPreviewProfile; 417 console.log('choosen[0] previewProfile: ' + JSON.stringify(previewProfile)); 418 try { 419 previewOutput = cameraManager.createPreviewOutput(previewProfile, surfaceId) 420 console.info('createPreviewOutput success'); 421 } catch (error) { 422 console.error('Failed to create the PreviewOutput instance errorCode = ' + error.code); 423 } 424 425 // 打开相机 426 await cameraInput.open(); 427 428 //创建会话 429 try { 430 captureSession = cameraManager.createCaptureSession() 431 console.info('createCaptureSession success'); 432 } catch (error) { 433 console.error('Failed to create the CaptureSession instance. errorCode = ' + error.code); 434 } 435 436 // 监听session错误信息 437 captureSession.on('error', (error) => { 438 console.log(`Capture session error code: ${error.code}`); 439 }) 440 441 // 开始配置会话 442 try { 443 captureSession.beginConfig() 444 console.info('beginConfig success'); 445 } catch (error) { 446 console.error('Failed to beginConfig. errorCode = ' + error.code); 447 } 448 449 // 向会话中添加相机输入流 450 try { 451 captureSession.addInput(cameraInput) 452 console.info('captureSession.addInput cameraInput success'); 453 } catch (error) { 454 console.error('Failed to addInput. errorCode = ' + error.code); 455 } 456 457 // 向会话中添加预览输入流 458 try { 459 captureSession.addOutput(previewOutput) 460 console.info('captureSession.addOutput previewOutput success'); 461 } catch (error) { 462 console.error('Failed to addOutput(previewOutput). errorCode = ' + error.code); 463 } 464 465 // 向会话中添加录像输出流 466 try { 467 captureSession.addOutput(videoOutput) 468 console.info('captureSession.addOutput videoOutput success'); 469 } catch (error) { 470 console.error('Failed to addOutput(videoOutput). errorCode = ' + error.code); 471 } 472 473 // 提交会话配置 474 await captureSession.commitConfig() 475 476 // 启动会话 477 await captureSession.start().then(() => { 478 isInitCamera = true 479 console.log('captureSession start success.'); 480 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 481 }) 482 } 483 484 function toNextStep(avRecorder, avConfig, recorderTime, steps, done) { 485 if (steps[0] == END_EVENT) { 486 console.info('case success!!'); 487 done(); 488 } else { 489 eventEmitter.emit(steps[0], avRecorder, avConfig, recorderTime, steps, done); 490 } 491 } 492 493 function setAvRecorderCallback(avRecorder, done) { 494 // 状态机变化回调函数 495 avRecorder.on('stateChange', (state, reason) => { 496 console.info(TAG + 'current state is: ' + state); 497 }) 498 // 错误上报回调函数 499 avRecorder.on('error', async (err) => { 500 try { 501 console.error(TAG + 'error ocConstantSourceNode, error message is ' + err); 502 await releaseRecorderPromise(avRecorder, done); 503 } catch (error) { 504 // 处理错误 505 console.error(TAG + 'when error on execute releaseRecorderPromise error message is ' + error); 506 } 507 }); 508 } 509 510 function setPhotoAssetAvailableCallback(avRecorder, done) { 511 avRecorder.on('photoAssetAvailable', (asset) => { 512 console.info(TAG + 'photoAssetAvailable called'); 513 if (asset != undefined) { 514 mediaTestBase.saveVideo(asset); 515 } else { 516 console.error(TAG + 'asset is undefined'); 517 } 518 console.info(TAG + 'photoAssetAvailable end'); 519 }) 520 } 521 522 async function releaseRecorderPromise(avRecorder, done) { 523 await avRecorderTestBase.releasePromise(avRecorder) 524 if(isInitCamera == true){ 525 releaseCameraError(avRecorder, done) 526 }else{ 527 done(); 528 } 529 } 530 531 eventEmitter.on(CREATE_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 532 steps.shift(); 533 media.createAVRecorder((error, recorder) => { 534 if (recorder != null) { 535 avRecorder = recorder; 536 expect(avRecorder.state).assertEqual('idle'); 537 console.info('createAVRecorder idleCallback success'); 538 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 539 } else { 540 console.info(`createAVRecorder idleCallback fail, error:${error}`); 541 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 542 } 543 }); 544 }); 545 546 eventEmitter.on(CREATE_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 547 steps.shift(); 548 media.createAVRecorder().then((recorder) => { 549 if (recorder != null) { 550 avRecorder = recorder; 551 console.info('createAVRecorder success'); 552 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 553 } else { 554 console.info('createAVRecorder fail'); 555 } 556 }).catch((error) => { 557 console.info(`createAVRecorder catchCallback, error:${error}`); 558 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 559 }); 560 }); 561 562 eventEmitter.on(SETONCALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 563 steps.shift(); 564 try{ 565 setAvRecorderCallback(avRecorder, done) 566 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 567 }catch(error){ 568 console.info('setAvRecorderCallback failed and catch error is ' + error.message); 569 } 570 }); 571 572 eventEmitter.on(SETPHOTOASSETCALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 573 steps.shift(); 574 try{ 575 setPhotoAssetAvailableCallback(avRecorder, done) 576 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 577 }catch(error){ 578 console.info('setAvRecorderCallback failed and catch error is ' + error.message); 579 } 580 }); 581 582 eventEmitter.on(PREPARE_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 583 steps.shift(); 584 avRecorder.prepare(avConfig, (err) => { 585 console.info('case prepare called'); 586 if (err == null) { 587 console.error(`case prepare success, state is ${avRecorder.state}`); 588 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED); 589 console.info('prepare success'); 590 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 591 } else { 592 console.error(`case prepare error, errMessage is ${err.message}`); 593 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 594 } 595 }) 596 }); 597 598 eventEmitter.on(UPDATE_ROTATION_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 599 steps.shift(); 600 let rotation = 90 601 avRecorder.updateRotation(rotation).then(() => { 602 console.info('updateRotation success'); 603 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 604 }).catch((error) => { 605 console.error('updateRotation failed and catch error is ' + error.message); 606 expect(false).assertEqual(true) 607 }); 608 }); 609 610 eventEmitter.on(PREPARE_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 611 steps.shift(); 612 avRecorder.prepare(avConfig).then(() => { 613 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED); 614 console.info('prepare success'); 615 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 616 }).catch((err) => { 617 console.info('prepare failed and catch error is ' + err.message); 618 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 619 }); 620 }); 621 622 eventEmitter.on(GETINPUTSURFACE_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 623 steps.shift(); 624 avRecorder.getInputSurface((err, surfaceId) => { 625 if (err == null) { 626 console.info('getInputSurface success'); 627 videoSurfaceId = surfaceId; 628 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 629 } else { 630 console.info('getInputSurface failed and error is ' + err.message); 631 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 632 } 633 }); 634 }); 635 636 eventEmitter.on(GETINPUTSURFACE_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 637 steps.shift(); 638 avRecorder.getInputSurface().then((surfaceId) => { 639 console.info('getInputSurface success'); 640 videoSurfaceId = surfaceId; 641 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 642 }).catch((err) => { 643 console.info('getInputSurface failed and catch error is ' + err.message); 644 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 645 }); 646 }); 647 648 eventEmitter.on(GETAVRECORDERCONFIG_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 649 steps.shift(); 650 avRecorder.getAVRecorderConfig().then((config) => { 651 console.info('getAVRecorderConfig success'); 652 expect(config.audioSourceType).assertEqual(avConfig.audioSourceType); 653 expect(config.audioBitrate).assertEqual(avConfig.audioBitrate); 654 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 655 }).catch((err) => { 656 console.info('getAVRecorderConfig failed and catch error is ' + err.message); 657 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 658 }); 659 }); 660 661 eventEmitter.on(INITCAMERA_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 662 steps.shift(); 663 try{ 664 initCamera(avRecorder, avConfig, recorderTime, steps, done) 665 }catch(error){ 666 console.info('initCamera failed and catch error is ' + error.message); 667 } 668 }); 669 670 eventEmitter.on(STARTCAMERA_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 671 steps.shift(); 672 try{ 673 startCameraOutput(avRecorder, avConfig, recorderTime, steps, done) 674 }catch(error){ 675 console.info('startCameraOutput failed and catch error is ' + error.message); 676 } 677 }); 678 679 eventEmitter.on(STOPCAMERA_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 680 steps.shift(); 681 try{ 682 stopCameraOutput(avRecorder, avConfig, recorderTime, steps, done) 683 }catch(error){ 684 console.info('stopCameraOutput failed and catch error is ' + error.message); 685 } 686 }); 687 688 eventEmitter.on(STARTRECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 689 steps.shift(); 690 avRecorder.start((err) => { 691 console.info('case start called'); 692 if (err == null) { 693 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED); 694 console.info('start AVRecorder success'); 695 setTimeout(() => { 696 console.info('STARTRECORDER_CALLBACK_EVENT setTimeout success'); 697 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 698 }, recorderTime); 699 } else { 700 console.info('start AVRecorder failed and error is ' + err.message); 701 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 702 } 703 }) 704 }); 705 706 eventEmitter.on(STARTRECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 707 steps.shift(); 708 avRecorder.start().then(() => { 709 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED); 710 console.info('start success'); 711 setTimeout(() => { 712 console.info('STARTRECORDER_PROMISE_EVENT setTimeout success'); 713 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 714 }, recorderTime); 715 }).catch((err) => { 716 console.info('start failed and catch error is ' + err.message); 717 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 718 }); 719 }); 720 721 eventEmitter.on(PAUSERECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 722 steps.shift(); 723 avRecorder.pause((err) => { 724 console.info('case pause called'); 725 if (err == null) { 726 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED); 727 console.info('pause AVRecorder success'); 728 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 729 } else { 730 console.info('pause AVRecorder failed and error is ' + err.message); 731 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 732 } 733 }) 734 }); 735 736 eventEmitter.on(PAUSERECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 737 steps.shift(); 738 avRecorder.pause().then(() => { 739 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED); 740 console.info('pause AVRecorder success'); 741 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 742 }).catch((err) => { 743 console.info('pause failed and catch error is ' + err.message); 744 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 745 }); 746 }); 747 748 eventEmitter.on(RESUMERECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 749 steps.shift(); 750 let resumeValue = true; 751 avRecorder.resume((err) => { 752 console.info('case resume called'); 753 if (err == null) { 754 console.info('resume AVRecorder success'); 755 expect(resumeValue).assertEqual(true); 756 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 757 } else { 758 resumeValue = false 759 console.info('resume AVRecorder failed and error is ' + err.message); 760 console.info('resumeValue is ' + resumeValue); 761 expect(resumeValue).assertEqual(false); 762 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 763 } 764 }) 765 }); 766 767 eventEmitter.on(RESUMERECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 768 steps.shift(); 769 let resumeValue = true; 770 avRecorder.resume().then(() => { 771 console.info('resume success'); 772 expect(resumeValue).assertEqual(true); 773 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 774 }).catch((err) => { 775 resumeValue = false 776 console.info('resume AVRecorder failed and error is ' + err.message); 777 console.info('resumeValue is ' + resumeValue); 778 expect(resumeValue).assertEqual(false); 779 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 780 }); 781 }); 782 783 eventEmitter.on(STOPRECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 784 steps.shift(); 785 let stopValue = true; 786 avRecorder.stop((err) => { 787 console.info('case stop called'); 788 if (err == null) { 789 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED); 790 console.info('stop AVRecorder success'); 791 expect(stopValue).assertEqual(true); 792 setTimeout(() => { 793 console.info('STOPRECORDER_CALLBACK_EVENT setTimeout success'); 794 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 795 }, 500); 796 } else { 797 stopValue = false 798 console.info('stop AVRecorder failed and error is ' + err.message); 799 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 800 } 801 }) 802 }); 803 804 eventEmitter.on(STOPRECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 805 steps.shift(); 806 let stopValue = true; 807 avRecorder.stop((err) => { 808 console.info('case stop called'); 809 if (err == null) { 810 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED); 811 console.info('stop AVRecorder success'); 812 expect(stopValue).assertEqual(true); 813 setTimeout(() => { 814 console.info('STOPRECORDER_PROMISE_EVENT setTimeout success'); 815 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 816 }, 500); 817 } else { 818 stopValue = false 819 console.info('stop AVRecorder failed and error is ' + err.message); 820 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 821 } 822 }) 823 }); 824 825 eventEmitter.on(RESETRECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 826 steps.shift(); 827 avRecorder.reset((err) => { 828 console.info('case reset called'); 829 if (err == null) { 830 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE); 831 console.info('reset AVRecorder success'); 832 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 833 } else { 834 console.info('reset AVRecorder failed and error is ' + err.message); 835 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 836 } 837 }) 838 }); 839 840 eventEmitter.on(RESETRECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 841 steps.shift(); 842 avRecorder.reset().then(() => { 843 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE); 844 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 845 }).catch((err) => { 846 console.info('reset AVRecorder failed and catch error is ' + err.message); 847 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 848 }); 849 }); 850 851 eventEmitter.on(RELEASECORDER_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 852 steps.shift(); 853 avRecorder.release((err) => { 854 console.info('case release called'); 855 if (err == null) { 856 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED); 857 console.info('release AVRecorder success'); 858 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 859 } else { 860 console.info('release AVRecorder failed and error is ' + err.message); 861 } 862 }) 863 }); 864 865 eventEmitter.on(RELEASECORDER_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 866 steps.shift(); 867 avRecorder.release().then(() => { 868 expect(avRecorder.state).assertEqual(avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED); 869 console.info('release AVRecorder success'); 870 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 871 }).catch((err) => { 872 console.info('release AVRecorder failed and catch error is ' + err.message); 873 }); 874 }); 875 876 eventEmitter.on(CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 877 steps.shift(); 878 let state = avRecorder.state; 879 avRecorder.getCurrentAudioCapturerInfo().then((captureInfo) => { 880 switch(state) { 881 case avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE: 882 console.info('getCurrentAudioCapturerInfo in idle state'); 883 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 884 break; 885 case avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED: 886 console.info('getCurrentAudioCapturerInfo in prepared state'); 887 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.PREPARED); 888 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 889 break; 890 case avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED: 891 console.info('getCurrentAudioCapturerInfo in started state'); 892 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.STARTED); 893 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 894 break; 895 case avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED: 896 console.info('getCurrentAudioCapturerInfo in paused state'); 897 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.PAUSED); 898 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 899 break; 900 case avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED: 901 console.info('getCurrentAudioCapturerInfo in stopped state'); 902 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 903 break; 904 case avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED: 905 console.info('getCurrentAudioCapturerInfo in released state'); 906 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 907 break; 908 default: 909 break; 910 } 911 }).catch((error) => { 912 console.info('getCurrentAudioCapturerInfo failed and catch error is ' + error.message); 913 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 914 }) 915 }); 916 917 eventEmitter.on(ENCODER_INFO_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 918 steps.shift(); 919 let state = avRecorder.state; 920 avRecorder.getAvailableEncoder().then((encoderInfo) => { 921 if (state == avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED) { 922 console.info('getAvailableEncoder in released state'); 923 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 924 } else { 925 console.info('getAvailableEncoder encoderInfo length: ' + encoderInfo.length); 926 expect(encoderInfo.length).assertLarger(0); 927 for (let i = 0; i < encoderInfo.length; i++) { 928 if (encoderInfo[i].type == 'video') { 929 console.info('getAvailableEncoder video encoder frameRate min ' + encoderInfo[i].frameRate.min); 930 console.info('getAvailableEncoder video encoder frameRate max ' + encoderInfo[i].frameRate.max); 931 if (encoderInfo[i].frameRate.min == 0 && encoderInfo[i].frameRate.max == 0) { 932 continue; 933 } 934 expect(encoderInfo[i].frameRate.max).assertLarger(0); 935 } else { 936 console.info('getAvailableEncoder audio encoder bitrate min ' + encoderInfo[i].bitRate.min); 937 console.info('getAvailableEncoder audio encoder bitrate max ' + encoderInfo[i].bitRate.max); 938 if (encoderInfo[i].bitRate.min == 0 && encoderInfo[i].bitRate.max == 0) { 939 continue; 940 } 941 expect(encoderInfo[i].bitRate.max).assertLarger(0); 942 } 943 } 944 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 945 } 946 }).catch((error) => { 947 console.info('avRecorder getAvailableEncoder failed and catch error is: ' + error.message); 948 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 949 }) 950 }); 951 952 eventEmitter.on(MAX_AMPLITUDE_PROMISE_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 953 steps.shift(); 954 let state = avRecorder.state; 955 avRecorder.getAudioCapturerMaxAmplitude().then((maxAmplitude) => { 956 switch (state) { 957 case avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE: 958 maxAmplitudeStartTimes = 0; 959 maxAmplitudePauseTimes = 0; 960 console.info('getAudioCapturerMaxAmplitude in idle state'); 961 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 962 break; 963 case avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED: 964 maxAmplitudeStartTimes = 0; 965 maxAmplitudePauseTimes = 0; 966 console.info('getAudioCapturerMaxAmplitude in prepared state'); 967 expect(maxAmplitude).assertEqual(0); 968 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 969 break; 970 case avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED: 971 maxAmplitudePauseTimes = 0; 972 console.info('getAudioCapturerMaxAmplitude in started state'); 973 if (maxAmplitudeStartTimes != 0) { 974 expect(maxAmplitude).assertLarger(0); 975 } 976 maxAmplitudeStartTimes++; 977 mediaTestBase.msleep(300); 978 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 979 break; 980 case avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED: 981 maxAmplitudeStartTimes = 0; 982 console.info('getAudioCapturerMaxAmplitude in paused state'); 983 if (maxAmplitudePauseTimes != 0) { 984 expect(maxAmplitude).assertEqual(0); 985 } 986 maxAmplitudePauseTimes++; 987 mediaTestBase.msleep(100); 988 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 989 break; 990 case avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED: 991 maxAmplitudeStartTimes = 0; 992 maxAmplitudePauseTimes = 0; 993 console.info('getAudioCapturerMaxAmplitude in stopped state'); 994 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 995 break; 996 case avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED: 997 maxAmplitudeStartTimes = 0; 998 maxAmplitudePauseTimes = 0; 999 console.info('getAudioCapturerMaxAmplitude in released state'); 1000 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1001 break; 1002 default: 1003 break; 1004 } 1005 }).catch((error) => { 1006 console.info('avRecorder getAudioCapturerMaxAmplitude failed and catch error is ' + error.message); 1007 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1008 }) 1009 }); 1010 1011 async function startCameraOutput(avRecorder, avConfig, recorderTime, steps, done) { 1012 console.info('startCameraOutput start') 1013 await videoOutput.start(async (err) => { 1014 if (err) { 1015 console.error(`Failed to start the video output ${err.message}`); 1016 return; 1017 } 1018 console.log('Callback invoked to indicate the video output start success.'); 1019 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1020 }); 1021 } 1022 1023 async function stopCameraOutput(avRecorder, avConfig, recorderTime, steps, done) { 1024 await videoOutput.stop((err) => { 1025 if (err) { 1026 console.error(`Failed to stop the video output ${err.message}`); 1027 return; 1028 } 1029 console.log('Callback invoked to indicate the video output stop success.'); 1030 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1031 }); 1032 1033 } 1034 1035 eventEmitter.on(RELEASECAMERA_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 1036 steps.shift(); 1037 try{ 1038 releaseCamera(avRecorder, avConfig, recorderTime, steps, done) 1039 1040 }catch(error){ 1041 console.info('releaseCamera failed and catch error is ' + error.message); 1042 } 1043 }); 1044 1045 eventEmitter.on(CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 1046 steps.shift(); 1047 try { 1048 let state = avRecorder.state; 1049 avRecorder.getCurrentAudioCapturerInfo((err, captureInfo) => { 1050 switch(state) { 1051 case avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE: 1052 console.info('getCurrentAudioCapturerInfo in idle state'); 1053 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1054 break; 1055 case avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED: 1056 console.info('getCurrentAudioCapturerInfo in prepared state'); 1057 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.PREPARED); 1058 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1059 break; 1060 case avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED: 1061 console.info('getCurrentAudioCapturerInfo in started state'); 1062 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.STARTED); 1063 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1064 break; 1065 case avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED: 1066 console.info('getCurrentAudioCapturerInfo in paused state'); 1067 expect(captureInfo.capturerState).assertEqual(avVideoRecorderTestBase.AV_RECORDER_AUDIO_STATE.PAUSED); 1068 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1069 break; 1070 case avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED: 1071 console.info('getCurrentAudioCapturerInfo in stopped state'); 1072 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1073 break; 1074 case avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED: 1075 console.info('getCurrentAudioCapturerInfo in released state'); 1076 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1077 break; 1078 default: 1079 break; 1080 } 1081 }) 1082 } catch (error) { 1083 console.info('avRecorder getCurrentAudioCapturerInfo failed and catch error is ' + error.message); 1084 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1085 } 1086 }); 1087 1088 eventEmitter.on(ENCODER_INFO_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 1089 steps.shift(); 1090 try { 1091 let state = avRecorder.state; 1092 avRecorder.getAvailableEncoder((err, encoderInfo) => { 1093 if (state == avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED) { 1094 console.info('getAvailableEncoder in released state'); 1095 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1096 } else { 1097 console.info('getAvailableEncoder encoderInfo length: ' + encoderInfo.length); 1098 expect(encoderInfo.length).assertLarger(0); 1099 for (let i = 0; i < encoderInfo.length; i++) { 1100 if (encoderInfo[i].type == 'video') { 1101 console.info('getAvailableEncoder video encoder frameRate min ' + encoderInfo[i].frameRate.min); 1102 console.info('getAvailableEncoder video encoder frameRate max ' + encoderInfo[i].frameRate.max); 1103 if (encoderInfo[i].frameRate.min == 0 && encoderInfo[i].frameRate.max == 0) { 1104 continue; 1105 } 1106 expect(encoderInfo[i].frameRate.max).assertLarger(0); 1107 } else { 1108 console.info('getAvailableEncoder audio encoder bitrate min ' + encoderInfo[i].bitRate.min); 1109 console.info('getAvailableEncoder audio encoder bitrate max ' + encoderInfo[i].bitRate.min); 1110 if (encoderInfo[i].bitRate.min == 0 && encoderInfo[i].bitRate.max == 0) { 1111 continue; 1112 } 1113 expect(encoderInfo[i].bitRate.max).assertLarger(0); 1114 } 1115 } 1116 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1117 } 1118 }); 1119 } catch (error) { 1120 console.info('avRecorder getAvailableEncoder failed and catch error is ' + error.message); 1121 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1122 } 1123 }); 1124 1125 eventEmitter.on(MAX_AMPLITUDE_CALLBACK_EVENT, (avRecorder, avConfig, recorderTime, steps, done) => { 1126 steps.shift(); 1127 try { 1128 let state = avRecorder.state; 1129 avRecorder.getAudioCapturerMaxAmplitude((err, maxAmplitude) => { 1130 switch (state) { 1131 case avVideoRecorderTestBase.AV_RECORDER_STATE.IDLE: 1132 maxAmplitudeStartTimes = 0; 1133 maxAmplitudePauseTimes = 0; 1134 console.info('getAudioCapturerMaxAmplitude in idle state'); 1135 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1136 break; 1137 case avVideoRecorderTestBase.AV_RECORDER_STATE.PREPARED: 1138 maxAmplitudeStartTimes = 0; 1139 maxAmplitudePauseTimes = 0; 1140 console.info('getAudioCapturerMaxAmplitude in prepared state'); 1141 expect(maxAmplitude).assertEqual(0); 1142 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1143 break; 1144 case avVideoRecorderTestBase.AV_RECORDER_STATE.STARTED: 1145 maxAmplitudePauseTimes = 0; 1146 console.info('getAudioCapturerMaxAmplitude in started state'); 1147 if (maxAmplitudeStartTimes != 0) { 1148 expect(maxAmplitude).assertLarger(0); 1149 } 1150 maxAmplitudeStartTimes++; 1151 mediaTestBase.msleep(300); 1152 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1153 break; 1154 case avVideoRecorderTestBase.AV_RECORDER_STATE.PAUSED: 1155 maxAmplitudeStartTimes = 0; 1156 console.info('getAudioCapturerMaxAmplitude in paused state'); 1157 if (maxAmplitudePauseTimes != 0) { 1158 expect(maxAmplitude).assertEqual(0); 1159 } 1160 maxAmplitudePauseTimes++; 1161 mediaTestBase.msleep(100); 1162 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1163 break; 1164 case avVideoRecorderTestBase.AV_RECORDER_STATE.STOPPED: 1165 maxAmplitudeStartTimes = 0; 1166 maxAmplitudePauseTimes = 0; 1167 console.info('getAudioCapturerMaxAmplitude in stopped state'); 1168 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1169 break; 1170 case avVideoRecorderTestBase.AV_RECORDER_STATE.RELEASED: 1171 maxAmplitudeStartTimes = 0; 1172 maxAmplitudePauseTimes = 0; 1173 console.info('getAudioCapturerMaxAmplitude in released state'); 1174 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1175 break; 1176 default: 1177 break; 1178 } 1179 }) 1180 } catch (error) { 1181 console.info('avRecorder getAudioCapturerMaxAmplitude failed and catch error is ' + error.message); 1182 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1183 } 1184 }); 1185 1186 async function releaseCameraError(avRecorder, done) { 1187 try{ 1188 await captureSession.stop() 1189 console.info('releaseCameraError 001'); 1190 console.info('captureSession.stop success'); 1191 await cameraInput.close() 1192 console.info('releaseCameraError 002'); 1193 console.info('cameraInput.close success'); 1194 await previewOutput.release() 1195 console.info('releaseCameraError 003'); 1196 console.info('previewOutput.release success'); 1197 await videoOutput.release() 1198 console.info('releaseCameraError 004'); 1199 console.info('videoOutput.release success'); 1200 await captureSession.release() 1201 console.info('releaseCameraError 005'); 1202 console.info('captureSession.release success'); 1203 captureSession = null 1204 console.info('releaseCameraError success'); 1205 done(); 1206 } catch(err){ 1207 console.info('releaseCameraError failed and catch error is ' + err.message); 1208 done(); 1209 } 1210 } 1211 1212 async function releaseCamera(avRecorder, avConfig, recorderTime, steps, done) { 1213 try{ 1214 await captureSession.stop() 1215 console.info('releaseCamera 001'); 1216 console.info('captureSession.stop success'); 1217 await cameraInput.close() 1218 console.info('releaseCamera 002'); 1219 console.info('cameraInput.close success'); 1220 await previewOutput.release() 1221 console.info('releaseCamera 003'); 1222 console.info('previewOutput.release success'); 1223 await videoOutput.release() 1224 console.info('releaseCamera 004'); 1225 console.info('videoOutput.release success'); 1226 await captureSession.release() 1227 console.info('releaseCamera 005'); 1228 console.info('captureSession.release success'); 1229 captureSession = null 1230 console.info('releaseCamera success'); 1231 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1232 } catch(err){ 1233 console.info('releaseCamera failed and catch error is ' + err.message); 1234 toNextStep(avRecorder, avConfig, recorderTime, steps, done); 1235 } 1236 } 1237 1238 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0100', 0, async function (done) { 1239 if (!isSupportCameraVideoProfiles) { 1240 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1241 expect(true).assertTrue(); 1242 done(); 1243 } 1244 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0100 start') 1245 let fileName = avVideoRecorderTestBase.resourceName() 1246 fdObject = await mediaTestBase.getFd(fileName); 1247 fdPath = "fd://" + fdObject.fdNumber; 1248 avConfig.url = fdPath; 1249 let mySteps = new Array( 1250 // init avRecorder 1251 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1252 // init camera 1253 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1254 // start recorder 1255 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 1256 // pause recorder 1257 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1258 // resume recorder 1259 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 1260 // stop recorder 1261 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1262 // release avRecorder and camera 1263 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1264 // end 1265 END_EVENT 1266 ); 1267 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1268 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0100 end') 1269 }) 1270 1271 /* * 1272 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0400 1273 * @tc.name : 001.test start-pause-resume 1274 * @tc.desc : Recorder video start-pause-resume 1275 * @tc.size : MediumTest 1276 * @tc.type : Function test 1277 * @tc.level : Level2 1278 */ 1279 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0400', 0, async function (done) { 1280 if (!isSupportCameraVideoProfiles) { 1281 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1282 expect(true).assertTrue(); 1283 done(); 1284 } 1285 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0400 start') 1286 let fileName = avVideoRecorderTestBase.resourceName() 1287 fdObject = await mediaTestBase.getFd(fileName); 1288 fdPath = "fd://" + fdObject.fdNumber; 1289 avConfig.url = fdPath; 1290 let mySteps = new Array( 1291 // init avRecorder 1292 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1293 // init camera 1294 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1295 // start recorder 1296 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1297 // pause recorder 1298 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1299 // resume recorder 1300 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 1301 // stop camera 1302 STOPCAMERA_EVENT, 1303 // release avRecorder and camera 1304 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1305 // end 1306 END_EVENT 1307 ); 1308 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1309 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0400 end') 1310 }) 1311 1312 /* * 1313 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0500 1314 * @tc.name : 001.test start-stop-resume 1315 * @tc.desc : Recorder video start-stop-resume 1316 * @tc.size : MediumTest 1317 * @tc.type : Function test 1318 * @tc.level : Level2 1319 */ 1320 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0500', 0, async function (done) { 1321 if (!isSupportCameraVideoProfiles) { 1322 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1323 expect(true).assertTrue(); 1324 done(); 1325 } 1326 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0500 start') 1327 let fileName = avVideoRecorderTestBase.resourceName() 1328 fdObject = await mediaTestBase.getFd(fileName); 1329 fdPath = "fd://" + fdObject.fdNumber; 1330 avConfig.url = fdPath; 1331 let mySteps = new Array( 1332 // init avRecorder 1333 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1334 // init camera 1335 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1336 // start recorder 1337 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1338 // stop recorder 1339 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1340 // resume recorder 1341 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 1342 // stop camera 1343 STOPCAMERA_EVENT, 1344 // release avRecorder and camera 1345 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1346 // end 1347 END_EVENT 1348 ); 1349 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1350 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0500 end') 1351 }) 1352 1353 /* * 1354 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0600 1355 * @tc.name : 001.test start-reset-resume 1356 * @tc.desc : Recorder video start-reset-resume 1357 * @tc.size : MediumTest 1358 * @tc.type : Function test 1359 * @tc.level : Level2 1360 */ 1361 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0600', 0, async function (done) { 1362 if (!isSupportCameraVideoProfiles) { 1363 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1364 expect(true).assertTrue(); 1365 done(); 1366 } 1367 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0600 start') 1368 let fileName = avVideoRecorderTestBase.resourceName() 1369 fdObject = await mediaTestBase.getFd(fileName); 1370 fdPath = "fd://" + fdObject.fdNumber; 1371 avConfig.url = fdPath; 1372 let mySteps = new Array( 1373 // init avRecorder 1374 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1375 // init camera 1376 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1377 // start recorder 1378 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1379 // reset recorder 1380 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1381 // resume recorder 1382 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 1383 // stop camera 1384 STOPCAMERA_EVENT, 1385 // release avRecorder and camera 1386 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1387 // end 1388 END_EVENT 1389 ); 1390 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1391 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0600 end') 1392 }) 1393 1394 /* * 1395 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0800 1396 * @tc.name : 001.test create-prepare-getInputSurface-start-pause-resume-resume-resume 1397 * @tc.desc : Recorder create-prepare-getInputSurface-start-pause-resume-resume-resume 1398 * @tc.size : MediumTest 1399 * @tc.type : Function test 1400 * @tc.level : Level2 1401 */ 1402 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0800', 0, async function (done) { 1403 if (!isSupportCameraVideoProfiles) { 1404 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1405 expect(true).assertTrue(); 1406 done(); 1407 } 1408 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0800 start') 1409 let fileName = avVideoRecorderTestBase.resourceName() 1410 fdObject = await mediaTestBase.getFd(fileName); 1411 fdPath = "fd://" + fdObject.fdNumber; 1412 avConfig.url = fdPath; 1413 let mySteps = new Array( 1414 // init avRecorder 1415 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1416 // init camera 1417 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1418 // start recorder 1419 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1420 // pause recorder 1421 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1422 // resume recorder 1423 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 1424 // resume recorder 1425 RESUMERECORDER_CALLBACK_EVENT, 1426 // resume recorder 1427 RESUMERECORDER_CALLBACK_EVENT, 1428 // stop camera 1429 STOPCAMERA_EVENT, 1430 // release avRecorder and camera 1431 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1432 // end 1433 END_EVENT 1434 ); 1435 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1436 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0800 end') 1437 }) 1438 1439 /* * 1440 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0400 1441 * @tc.name : 001.test start-resume 1442 * @tc.desc : Recorder video start-resume 1443 * @tc.size : MediumTest 1444 * @tc.type : Function test 1445 * @tc.level : Level2 1446 */ 1447 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0400', 0, async function (done) { 1448 if (!isSupportCameraVideoProfiles) { 1449 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1450 expect(true).assertTrue(); 1451 done(); 1452 } 1453 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0400 start') 1454 let fileName = avVideoRecorderTestBase.resourceName() 1455 fdObject = await mediaTestBase.getFd(fileName); 1456 fdPath = "fd://" + fdObject.fdNumber; 1457 avConfig.url = fdPath; 1458 let mySteps = new Array( 1459 // init avRecorder 1460 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1461 // init camera 1462 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1463 // start recorder 1464 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 1465 // pause 1466 PAUSERECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 1467 // resume recorder 1468 STARTCAMERA_EVENT,RESUMERECORDER_PROMISE_EVENT, 1469 // stop camera 1470 STOPCAMERA_EVENT, 1471 // release avRecorder and camera 1472 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1473 // end 1474 END_EVENT 1475 ); 1476 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1477 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0400 end') 1478 }) 1479 1480 /* * 1481 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0500 1482 * @tc.name : 001.test start-resume 1483 * @tc.desc : Recorder video start-resume 1484 * @tc.size : MediumTest 1485 * @tc.type : Function test 1486 * @tc.level : Level2 1487 */ 1488 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0500', 0, async function (done) { 1489 if (!isSupportCameraVideoProfiles) { 1490 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1491 expect(true).assertTrue(); 1492 done(); 1493 } 1494 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0500 start') 1495 let fileName = avVideoRecorderTestBase.resourceName() 1496 fdObject = await mediaTestBase.getFd(fileName); 1497 fdPath = "fd://" + fdObject.fdNumber; 1498 avConfig.url = fdPath; 1499 let mySteps = new Array( 1500 // init avRecorder 1501 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1502 // init camera 1503 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1504 // start recorder 1505 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 1506 // stop 1507 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 1508 // resume recorder 1509 STARTCAMERA_EVENT,RESUMERECORDER_PROMISE_EVENT, 1510 // stop camera 1511 STOPCAMERA_EVENT, 1512 // release avRecorder and camera 1513 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1514 // end 1515 END_EVENT 1516 ); 1517 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1518 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0500 end') 1519 }) 1520 1521 /* * 1522 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0600 1523 * @tc.name : 001.test start-resume 1524 * @tc.desc : Recorder video start-resume 1525 * @tc.size : MediumTest 1526 * @tc.type : Function test 1527 * @tc.level : Level2 1528 */ 1529 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0600', 0, async function (done) { 1530 if (!isSupportCameraVideoProfiles) { 1531 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1532 expect(true).assertTrue(); 1533 done(); 1534 } 1535 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0600 start') 1536 let fileName = avVideoRecorderTestBase.resourceName() 1537 fdObject = await mediaTestBase.getFd(fileName); 1538 fdPath = "fd://" + fdObject.fdNumber; 1539 avConfig.url = fdPath; 1540 let mySteps = new Array( 1541 // init avRecorder 1542 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1543 // init camera 1544 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1545 // start recorder 1546 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 1547 // RESET 1548 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1549 // resume recorder 1550 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 1551 // stop camera 1552 STOPCAMERA_EVENT, 1553 // release avRecorder and camera 1554 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1555 // end 1556 END_EVENT 1557 ); 1558 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1559 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0600 end') 1560 }) 1561 1562 /* * 1563 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0800 1564 * @tc.name : 001.test start-resume 1565 * @tc.desc : Recorder video start-resume 1566 * @tc.size : MediumTest 1567 * @tc.type : Function test 1568 * @tc.level : Level2 1569 */ 1570 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0800', 0, async function (done) { 1571 if (!isSupportCameraVideoProfiles) { 1572 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1573 expect(true).assertTrue(); 1574 done(); 1575 } 1576 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0800 start') 1577 let fileName = avVideoRecorderTestBase.resourceName() 1578 fdObject = await mediaTestBase.getFd(fileName); 1579 fdPath = "fd://" + fdObject.fdNumber; 1580 avConfig.url = fdPath; 1581 let mySteps = new Array( 1582 // init avRecorder 1583 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1584 // init camera 1585 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1586 // start recorder 1587 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 1588 // pause 1589 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1590 // resume recorder 1591 STARTCAMERA_EVENT,RESUMERECORDER_PROMISE_EVENT, 1592 // resume recorder 1593 RESUMERECORDER_PROMISE_EVENT, 1594 // resume recorder 1595 RESUMERECORDER_PROMISE_EVENT, 1596 // stop camera 1597 STOPCAMERA_EVENT, 1598 // release avRecorder and camera 1599 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1600 // end 1601 END_EVENT 1602 ); 1603 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1604 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0800 end') 1605 }) 1606 1607 /* * 1608 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0500 1609 * @tc.name : 001.test start-pause-resume-stop 1610 * @tc.desc : Recorder start-pause-resume-stop 1611 * @tc.size : MediumTest 1612 * @tc.type : Function test 1613 * @tc.level : Level2 1614 */ 1615 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0500', 0, async function (done) { 1616 if (!isSupportCameraVideoProfiles) { 1617 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1618 expect(true).assertTrue(); 1619 done(); 1620 } 1621 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0500 start') 1622 let fileName = avVideoRecorderTestBase.resourceName() 1623 fdObject = await mediaTestBase.getFd(fileName); 1624 fdPath = "fd://" + fdObject.fdNumber; 1625 avConfig.url = fdPath; 1626 let mySteps = new Array( 1627 // init avRecorder 1628 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1629 // init camera 1630 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1631 // start recorder 1632 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1633 // pause recorder 1634 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1635 // resume recorder 1636 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 1637 // stop recorder 1638 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1639 // release avRecorder and camera 1640 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1641 // end 1642 END_EVENT 1643 ); 1644 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1645 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0500 end') 1646 }) 1647 1648 /* * 1649 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0500 1650 * @tc.name : 001.test resume-stop 1651 * @tc.desc : Recorder video resume-stop 1652 * @tc.size : MediumTest 1653 * @tc.type : Function test 1654 * @tc.level : Level2 1655 */ 1656 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0500', 0, async function (done) { 1657 if (!isSupportCameraVideoProfiles) { 1658 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1659 expect(true).assertTrue(); 1660 done(); 1661 } 1662 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0500 start') 1663 let fileName = avVideoRecorderTestBase.resourceName() 1664 fdObject = await mediaTestBase.getFd(fileName); 1665 fdPath = "fd://" + fdObject.fdNumber; 1666 avConfig.url = fdPath; 1667 let mySteps = new Array( 1668 // init avRecorder 1669 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_CALLBACK_EVENT, 1670 // init camera 1671 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1672 // start recorder 1673 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 1674 //pause recorder 1675 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1676 //resume recorder 1677 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 1678 // stop recorder 1679 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1680 // release avRecorder and camera 1681 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1682 // end 1683 END_EVENT 1684 ); 1685 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1686 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0500 end') 1687 }) 1688 1689 /* * 1690 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0500 1691 * @tc.name : 001.test start-resume-reset 1692 * @tc.desc : Recorder video start-resume-reset 1693 * @tc.size : MediumTest 1694 * @tc.type : Function test 1695 * @tc.level : Level2 1696 */ 1697 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0500', 0, async function (done) { 1698 if (!isSupportCameraVideoProfiles) { 1699 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1700 expect(true).assertTrue(); 1701 done(); 1702 } 1703 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0500 start') 1704 let fileName = avVideoRecorderTestBase.resourceName() 1705 fdObject = await mediaTestBase.getFd(fileName); 1706 fdPath = "fd://" + fdObject.fdNumber; 1707 avConfig.url = fdPath; 1708 let mySteps = new Array( 1709 // init avRecorder 1710 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1711 // init camera 1712 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1713 // start recorder 1714 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 1715 // pause recorder 1716 PAUSERECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 1717 // resume recorder 1718 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 1719 // reset recorder 1720 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 1721 // release avRecorder and camera 1722 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1723 // end 1724 END_EVENT 1725 ); 1726 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1727 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0500 end') 1728 }) 1729 1730 /* * 1731 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0100 1732 * @tc.name : 001.test create-resume 1733 * @tc.desc : Recorder video create-resume 1734 * @tc.size : MediumTest 1735 * @tc.type : Function test 1736 * @tc.level : Level2 1737 */ 1738 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0100', 0, async function (done) { 1739 if (!isSupportCameraVideoProfiles) { 1740 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1741 expect(true).assertTrue(); 1742 done(); 1743 } 1744 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0100 start') 1745 let fileName = avVideoRecorderTestBase.resourceName() 1746 fdObject = await mediaTestBase.getFd(fileName); 1747 fdPath = "fd://" + fdObject.fdNumber; 1748 avConfig.url = fdPath; 1749 console.info('avRecorderResumeCallBack1 test start'); 1750 let mySteps = new Array( 1751 // init avRecorder 1752 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 1753 // resume recorder 1754 RESUMERECORDER_CALLBACK_EVENT, 1755 // release avRecorder 1756 RELEASECORDER_CALLBACK_EVENT, 1757 // end 1758 END_EVENT 1759 ); 1760 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1761 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0100 end') 1762 }) 1763 1764 /* * 1765 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0200 1766 * @tc.name : 001.test prepare-resume 1767 * @tc.desc : Recorder video prepare-resume 1768 * @tc.size : MediumTest 1769 * @tc.type : Function test 1770 * @tc.level : Level2 1771 */ 1772 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0200', 0, async function (done) { 1773 if (!isSupportCameraVideoProfiles) { 1774 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1775 expect(true).assertTrue(); 1776 done(); 1777 } 1778 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0200 start') 1779 let fileName = avVideoRecorderTestBase.resourceName() 1780 fdObject = await mediaTestBase.getFd(fileName); 1781 fdPath = "fd://" + fdObject.fdNumber; 1782 avConfig.url = fdPath; 1783 let mySteps = new Array( 1784 // init avRecorder 1785 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1786 // resume recorder 1787 RESUMERECORDER_CALLBACK_EVENT, 1788 // release avRecorder 1789 RELEASECORDER_CALLBACK_EVENT, 1790 // end 1791 END_EVENT 1792 ); 1793 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1794 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0200 end') 1795 }) 1796 1797 /* * 1798 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0300 1799 * @tc.name : 001.test start-resume 1800 * @tc.desc : Recorder video start-resume 1801 * @tc.size : MediumTest 1802 * @tc.type : Function test 1803 * @tc.level : Level2 1804 */ 1805 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0300', 0, async function (done) { 1806 if (!isSupportCameraVideoProfiles) { 1807 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1808 expect(true).assertTrue(); 1809 done(); 1810 } 1811 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0300 start') 1812 let fileName = avVideoRecorderTestBase.resourceName() 1813 fdObject = await mediaTestBase.getFd(fileName); 1814 fdPath = "fd://" + fdObject.fdNumber; 1815 avConfig.url = fdPath; 1816 let mySteps = new Array( 1817 // init avRecorder 1818 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1819 // init camera 1820 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 1821 // start recorder 1822 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1823 // resume recorder 1824 RESUMERECORDER_CALLBACK_EVENT, 1825 // stop camera 1826 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 1827 // release avRecorder and camera 1828 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 1829 // end 1830 END_EVENT 1831 ); 1832 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1833 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0300 end') 1834 }) 1835 1836 /* * 1837 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0700 1838 * @tc.name : 001.test create-prepare-getInputSurface-resume 1839 * @tc.desc : Recorder create-prepare-getInputSurface-resume 1840 * @tc.size : MediumTest 1841 * @tc.type : Function test 1842 * @tc.level : Level2 1843 */ 1844 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0700', 0, async function (done) { 1845 if (!isSupportCameraVideoProfiles) { 1846 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1847 expect(true).assertTrue(); 1848 done(); 1849 } 1850 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0700 start') 1851 let fileName = avVideoRecorderTestBase.resourceName() 1852 fdObject = await mediaTestBase.getFd(fileName); 1853 fdPath = "fd://" + fdObject.fdNumber; 1854 avConfig.url = fdPath; 1855 let mySteps = new Array( 1856 // init avRecorder 1857 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 1858 // getInputSurface 1859 GETINPUTSURFACE_CALLBACK_EVENT, 1860 // resume recorder 1861 RESUMERECORDER_CALLBACK_EVENT, 1862 // release avRecorder and camera 1863 RELEASECORDER_CALLBACK_EVENT, 1864 // end 1865 END_EVENT 1866 ); 1867 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1868 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_CALLBACK_0700 end') 1869 }) 1870 1871 1872 1873 /* * 1874 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0100 1875 * @tc.name : 001.test start-resume 1876 * @tc.desc : Recorder video start-resume 1877 * @tc.size : MediumTest 1878 * @tc.type : Function test 1879 * @tc.level : Level2 1880 */ 1881 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0100', 0, async function (done) { 1882 if (!isSupportCameraVideoProfiles) { 1883 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1884 expect(true).assertTrue(); 1885 done(); 1886 } 1887 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0100 start') 1888 let fileName = avVideoRecorderTestBase.resourceName() 1889 fdObject = await mediaTestBase.getFd(fileName); 1890 fdPath = "fd://" + fdObject.fdNumber; 1891 avConfig.url = fdPath; 1892 let mySteps = new Array( 1893 // init avRecorder 1894 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1895 // init camera 1896 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1897 // start recorder 1898 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1899 // resume recorder 1900 RESUMERECORDER_PROMISE_EVENT, 1901 // stop camera 1902 STOPCAMERA_EVENT, 1903 // release avRecorder and camera 1904 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1905 // end 1906 END_EVENT 1907 ); 1908 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1909 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0100 end') 1910 }) 1911 1912 /* * 1913 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0200 1914 * @tc.name : 001.test start-resume 1915 * @tc.desc : Recorder video start-resume 1916 * @tc.size : MediumTest 1917 * @tc.type : Function test 1918 * @tc.level : Level2 1919 */ 1920 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0200', 0, async function (done) { 1921 if (!isSupportCameraVideoProfiles) { 1922 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1923 expect(true).assertTrue(); 1924 done(); 1925 } 1926 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0200 start') 1927 let fileName = avVideoRecorderTestBase.resourceName() 1928 fdObject = await mediaTestBase.getFd(fileName); 1929 fdPath = "fd://" + fdObject.fdNumber; 1930 avConfig.url = fdPath; 1931 let mySteps = new Array( 1932 // init avRecorder 1933 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1934 // init camera 1935 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1936 // start recorder 1937 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 1938 // resume recorder 1939 RESUMERECORDER_PROMISE_EVENT, 1940 // stop camera 1941 STOPCAMERA_EVENT, 1942 // release avRecorder and camera 1943 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1944 // end 1945 END_EVENT 1946 ); 1947 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1948 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0200 end') 1949 }) 1950 1951 /* * 1952 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0300 1953 * @tc.name : 001.test start-resume 1954 * @tc.desc : Recorder video start-resume 1955 * @tc.size : MediumTest 1956 * @tc.type : Function test 1957 * @tc.level : Level2 1958 */ 1959 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0300', 0, async function (done) { 1960 if (!isSupportCameraVideoProfiles) { 1961 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 1962 expect(true).assertTrue(); 1963 done(); 1964 } 1965 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0300 start') 1966 let fileName = avVideoRecorderTestBase.resourceName() 1967 fdObject = await mediaTestBase.getFd(fileName); 1968 fdPath = "fd://" + fdObject.fdNumber; 1969 avConfig.url = fdPath; 1970 let mySteps = new Array( 1971 // init avRecorder 1972 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 1973 // init camera 1974 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 1975 // start recorder 1976 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 1977 // resume recorder 1978 RESUMERECORDER_PROMISE_EVENT, 1979 // stop camera 1980 STOPCAMERA_EVENT, 1981 // release avRecorder and camera 1982 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 1983 // end 1984 END_EVENT 1985 ); 1986 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 1987 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0300 end') 1988 }) 1989 1990 /* * 1991 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0700 1992 * @tc.name : 001.test start-resume 1993 * @tc.desc : Recorder video start-resume 1994 * @tc.size : MediumTest 1995 * @tc.type : Function test 1996 * @tc.level : Level2 1997 */ 1998 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0700', 0, async function (done) { 1999 if (!isSupportCameraVideoProfiles) { 2000 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2001 expect(true).assertTrue(); 2002 done(); 2003 } 2004 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0700 start') 2005 let fileName = avVideoRecorderTestBase.resourceName() 2006 fdObject = await mediaTestBase.getFd(fileName); 2007 fdPath = "fd://" + fdObject.fdNumber; 2008 avConfig.url = fdPath; 2009 let mySteps = new Array( 2010 // init avRecorder 2011 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2012 // init camera 2013 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2014 // resume recorder 2015 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 2016 // stop camera 2017 STOPCAMERA_EVENT, 2018 // release avRecorder and camera 2019 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2020 // end 2021 END_EVENT 2022 ); 2023 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2024 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESUME_PROMISE_0700 end') 2025 }) 2026 2027 2028 2029 2030 /* * 2031 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0300 2032 * @tc.name : 001.test start-stop 2033 * @tc.desc : Recorder video start-stop 2034 * @tc.size : MediumTest 2035 * @tc.type : Function test 2036 * @tc.level : Level2 2037 */ 2038 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0300', 0, async function (done) { 2039 if (!isSupportCameraVideoProfiles) { 2040 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2041 expect(true).assertTrue(); 2042 done(); 2043 } 2044 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0300 start') 2045 let fileName = avVideoRecorderTestBase.resourceName() 2046 fdObject = await mediaTestBase.getFd(fileName); 2047 fdPath = "fd://" + fdObject.fdNumber; 2048 avConfig.url = fdPath; 2049 let mySteps = new Array( 2050 // init avRecorder 2051 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2052 // init camera 2053 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2054 // start recorder 2055 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2056 // stop recorder 2057 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2058 // release avRecorder and camera 2059 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2060 // end 2061 END_EVENT 2062 ); 2063 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2064 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0300 end') 2065 }) 2066 2067 /* * 2068 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0400 2069 * @tc.name : 001.test start-pause-stop 2070 * @tc.desc : Recorder video start-pause-stop 2071 * @tc.size : MediumTest 2072 * @tc.type : Function test 2073 * @tc.level : Level2 2074 */ 2075 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0400', 0, async function (done) { 2076 if (!isSupportCameraVideoProfiles) { 2077 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2078 expect(true).assertTrue(); 2079 done(); 2080 } 2081 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0400 start') 2082 let fileName = avVideoRecorderTestBase.resourceName() 2083 fdObject = await mediaTestBase.getFd(fileName); 2084 fdPath = "fd://" + fdObject.fdNumber; 2085 avConfig.url = fdPath; 2086 let mySteps = new Array( 2087 // init avRecorder 2088 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2089 // init camera 2090 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2091 // start recorder 2092 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2093 // pause recorder 2094 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2095 // stop recorder 2096 STOPRECORDER_CALLBACK_EVENT, 2097 // release avRecorder and camera 2098 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2099 // end 2100 END_EVENT 2101 ); 2102 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2103 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0400 end') 2104 }) 2105 2106 2107 2108 /* * 2109 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0600 2110 * @tc.name : 001.test start-reset-stop 2111 * @tc.desc : Recorder start-reset-stop 2112 * @tc.size : MediumTest 2113 * @tc.type : Function test 2114 * @tc.level : Level2 2115 */ 2116 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0600', 0, async function (done) { 2117 if (!isSupportCameraVideoProfiles) { 2118 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2119 expect(true).assertTrue(); 2120 done(); 2121 } 2122 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0600 start') 2123 let fileName = avVideoRecorderTestBase.resourceName() 2124 fdObject = await mediaTestBase.getFd(fileName); 2125 fdPath = "fd://" + fdObject.fdNumber; 2126 avConfig.url = fdPath; 2127 let mySteps = new Array( 2128 // init avRecorder 2129 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2130 // init camera 2131 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2132 // start recorder 2133 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2134 // reset recorder 2135 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2136 // stop recorder 2137 STOPRECORDER_CALLBACK_EVENT, 2138 // release avRecorder and camera 2139 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2140 // end 2141 END_EVENT 2142 ); 2143 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2144 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0600 end') 2145 }) 2146 2147 /* * 2148 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0800 2149 * @tc.name : 001.test start-stop-stop-stop 2150 * @tc.desc : Recorder start-stop-stop-stop 2151 * @tc.size : MediumTest 2152 * @tc.type : Function test 2153 * @tc.level : Level2 2154 */ 2155 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0800', 0, async function (done) { 2156 if (!isSupportCameraVideoProfiles) { 2157 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2158 expect(true).assertTrue(); 2159 done(); 2160 } 2161 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0800 start') 2162 let fileName = avVideoRecorderTestBase.resourceName() 2163 fdObject = await mediaTestBase.getFd(fileName); 2164 fdPath = "fd://" + fdObject.fdNumber; 2165 avConfig.url = fdPath; 2166 let mySteps = new Array( 2167 // init avRecorder 2168 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2169 // init camera 2170 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2171 // start recorder 2172 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2173 // stop recorder 2174 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2175 // stop recorder 2176 STOPRECORDER_CALLBACK_EVENT, 2177 // stop recorder 2178 STOPRECORDER_CALLBACK_EVENT, 2179 // release avRecorder and camera 2180 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2181 // end 2182 END_EVENT 2183 ); 2184 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2185 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_CALLBACK_0800 end') 2186 }) 2187 2188 /* * 2189 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0100 2190 * @tc.name : 001.test create-stop 2191 * @tc.desc : Recorder video create-stop 2192 * @tc.size : MediumTest 2193 * @tc.type : Function test 2194 * @tc.level : Level2 2195 */ 2196 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0100', 0, async function (done) { 2197 if (!isSupportCameraVideoProfiles) { 2198 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2199 expect(true).assertTrue(); 2200 done(); 2201 } 2202 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0100 start') 2203 let fileName = avVideoRecorderTestBase.resourceName() 2204 fdObject = await mediaTestBase.getFd(fileName); 2205 fdPath = "fd://" + fdObject.fdNumber; 2206 avConfig.url = fdPath; 2207 let mySteps = new Array( 2208 // init avRecorder 2209 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 2210 // stop recorder 2211 STOPRECORDER_PROMISE_EVENT, 2212 // release avRecorder and camera 2213 RELEASECORDER_PROMISE_EVENT, 2214 // end 2215 END_EVENT 2216 ); 2217 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2218 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0100 end') 2219 }) 2220 2221 /* * 2222 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0200 2223 * @tc.name : 001.test prepare-stop 2224 * @tc.desc : Recorder video prepare-stop 2225 * @tc.size : MediumTest 2226 * @tc.type : Function test 2227 * @tc.level : Level2 2228 */ 2229 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0200', 0, async function (done) { 2230 if (!isSupportCameraVideoProfiles) { 2231 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2232 expect(true).assertTrue(); 2233 done(); 2234 } 2235 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0200 start') 2236 let fileName = avVideoRecorderTestBase.resourceName() 2237 fdObject = await mediaTestBase.getFd(fileName); 2238 fdPath = "fd://" + fdObject.fdNumber; 2239 avConfig.url = fdPath; 2240 let mySteps = new Array( 2241 // init avRecorder 2242 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2243 // stop recorder 2244 STOPRECORDER_PROMISE_EVENT, 2245 // release avRecorder and camera 2246 RELEASECORDER_PROMISE_EVENT, 2247 // end 2248 END_EVENT 2249 ); 2250 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2251 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0200 end') 2252 }) 2253 2254 /* * 2255 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0300 2256 * @tc.name : 001.test start-stop 2257 * @tc.desc : Recorder video start-stop 2258 * @tc.size : MediumTest 2259 * @tc.type : Function test 2260 * @tc.level : Level2 2261 */ 2262 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0300', 0, async function (done) { 2263 if (!isSupportCameraVideoProfiles) { 2264 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2265 expect(true).assertTrue(); 2266 done(); 2267 } 2268 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0300 start') 2269 let fileName = avVideoRecorderTestBase.resourceName() 2270 fdObject = await mediaTestBase.getFd(fileName); 2271 fdPath = "fd://" + fdObject.fdNumber; 2272 avConfig.url = fdPath; 2273 let mySteps = new Array( 2274 // init avRecorder 2275 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_CALLBACK_EVENT, 2276 // init camera 2277 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2278 // start recorder 2279 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 2280 // stop recorder 2281 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 2282 // release avRecorder and camera 2283 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2284 // end 2285 END_EVENT 2286 ); 2287 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2288 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0300 end') 2289 }) 2290 2291 2292 /* * 2293 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0400 2294 * @tc.name : 001.test pause-stop 2295 * @tc.desc : Recorder video pause-stop 2296 * @tc.size : MediumTest 2297 * @tc.type : Function test 2298 * @tc.level : Level2 2299 */ 2300 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0400', 0, async function (done) { 2301 if (!isSupportCameraVideoProfiles) { 2302 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2303 expect(true).assertTrue(); 2304 done(); 2305 } 2306 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0400 start') 2307 let fileName = avVideoRecorderTestBase.resourceName() 2308 fdObject = await mediaTestBase.getFd(fileName); 2309 fdPath = "fd://" + fdObject.fdNumber; 2310 avConfig.url = fdPath; 2311 let mySteps = new Array( 2312 // init avRecorder 2313 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_CALLBACK_EVENT, 2314 // init camera 2315 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2316 // start recorder 2317 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 2318 //pause recorder 2319 PAUSERECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 2320 // stop recorder 2321 STOPRECORDER_PROMISE_EVENT, 2322 // release avRecorder and camera 2323 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2324 // end 2325 END_EVENT 2326 ); 2327 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2328 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0400 end') 2329 }) 2330 2331 2332 /* * 2333 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0600 2334 * @tc.name : 001.test reset-stop 2335 * @tc.desc : Recorder video reset-stop 2336 * @tc.size : MediumTest 2337 * @tc.type : Function test 2338 * @tc.level : Level2 2339 */ 2340 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0600', 0, async function (done) { 2341 if (!isSupportCameraVideoProfiles) { 2342 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2343 expect(true).assertTrue(); 2344 done(); 2345 } 2346 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0600 start') 2347 let fileName = avVideoRecorderTestBase.resourceName() 2348 fdObject = await mediaTestBase.getFd(fileName); 2349 fdPath = "fd://" + fdObject.fdNumber; 2350 avConfig.url = fdPath; 2351 let mySteps = new Array( 2352 // init avRecorder 2353 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_CALLBACK_EVENT, 2354 // init camera 2355 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2356 // start recorder 2357 STARTCAMERA_EVENT,STARTRECORDER_PROMISE_EVENT, 2358 // reset recorder 2359 RESETRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 2360 // stop recorder 2361 STOPRECORDER_PROMISE_EVENT, 2362 // release avRecorder and camera 2363 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2364 // end 2365 END_EVENT 2366 ); 2367 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2368 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0600 end') 2369 }) 2370 2371 /* * 2372 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0700 2373 * @tc.name : 001.test getInputSurface-stop 2374 * @tc.desc : Recorder video getInputSurface-stop 2375 * @tc.size : MediumTest 2376 * @tc.type : Function test 2377 * @tc.level : Level2 2378 */ 2379 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0700', 0, async function (done) { 2380 if (!isSupportCameraVideoProfiles) { 2381 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2382 expect(true).assertTrue(); 2383 done(); 2384 } 2385 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0700 start') 2386 let fileName = avVideoRecorderTestBase.resourceName() 2387 fdObject = await mediaTestBase.getFd(fileName); 2388 fdPath = "fd://" + fdObject.fdNumber; 2389 avConfig.url = fdPath; 2390 let mySteps = new Array( 2391 // init avRecorder 2392 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2393 // init camera 2394 GETINPUTSURFACE_PROMISE_EVENT, 2395 // start recorder 2396 STARTRECORDER_PROMISE_EVENT, 2397 // stop recorder 2398 STOPRECORDER_PROMISE_EVENT, 2399 // release avRecorder 2400 RELEASECORDER_PROMISE_EVENT, 2401 // end 2402 END_EVENT 2403 ); 2404 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2405 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0700 end') 2406 }) 2407 2408 /* * 2409 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0800 2410 * @tc.name : 001.test start-stop-stop-stop 2411 * @tc.desc : Recorder video start-stop-stop-stop 2412 * @tc.size : MediumTest 2413 * @tc.type : Function test 2414 * @tc.level : Level2 2415 */ 2416 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0800', 0, async function (done) { 2417 if (!isSupportCameraVideoProfiles) { 2418 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2419 expect(true).assertTrue(); 2420 done(); 2421 } 2422 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0800 start') 2423 let fileName = avVideoRecorderTestBase.resourceName() 2424 fdObject = await mediaTestBase.getFd(fileName); 2425 fdPath = "fd://" + fdObject.fdNumber; 2426 avConfig.url = fdPath; 2427 let mySteps = new Array( 2428 // init avRecorder 2429 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_CALLBACK_EVENT, 2430 // init camera 2431 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2432 // start recorder 2433 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 2434 // stop recorder 2435 STOPRECORDER_PROMISE_EVENT, 2436 // stop recorder 2437 STOPRECORDER_PROMISE_EVENT, 2438 // stop recorder 2439 STOPRECORDER_PROMISE_EVENT, 2440 // stop camera 2441 STOPCAMERA_EVENT, 2442 // release avRecorder and camera 2443 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2444 // end 2445 END_EVENT 2446 ); 2447 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2448 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_STOP_PROMISE_0800 end') 2449 }) 2450 2451 /* * 2452 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0100 2453 * @tc.name : 001.test create-reset 2454 * @tc.desc : Recorder video create-reset 2455 * @tc.size : MediumTest 2456 * @tc.type : Function test 2457 * @tc.level : Level2 2458 */ 2459 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0100', 0, async function (done) { 2460 if (!isSupportCameraVideoProfiles) { 2461 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2462 expect(true).assertTrue(); 2463 done(); 2464 } 2465 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0100 start') 2466 let fileName = avVideoRecorderTestBase.resourceName() 2467 fdObject = await mediaTestBase.getFd(fileName); 2468 fdPath = "fd://" + fdObject.fdNumber; 2469 avConfig.url = fdPath; 2470 console.info('avRecorderResumeCallBack1 test start'); 2471 let mySteps = new Array( 2472 // init avRecorder 2473 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 2474 // reset recorder 2475 RESETRECORDER_CALLBACK_EVENT, 2476 // release avRecorder 2477 RELEASECORDER_CALLBACK_EVENT, 2478 // end 2479 END_EVENT 2480 ); 2481 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2482 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0100 end') 2483 }) 2484 2485 /* * 2486 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0200 2487 * @tc.name : 001.test prepare-reset 2488 * @tc.desc : Recorder video prepare-reset 2489 * @tc.size : MediumTest 2490 * @tc.type : Function test 2491 * @tc.level : Level2 2492 */ 2493 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0200', 0, async function (done) { 2494 if (!isSupportCameraVideoProfiles) { 2495 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2496 expect(true).assertTrue(); 2497 done(); 2498 } 2499 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0200 start') 2500 let fileName = avVideoRecorderTestBase.resourceName() 2501 fdObject = await mediaTestBase.getFd(fileName); 2502 fdPath = "fd://" + fdObject.fdNumber; 2503 avConfig.url = fdPath; 2504 let mySteps = new Array( 2505 // init avRecorder 2506 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2507 // reset recorder 2508 RESETRECORDER_CALLBACK_EVENT, 2509 // release avRecorder 2510 RELEASECORDER_CALLBACK_EVENT, 2511 // end 2512 END_EVENT 2513 ); 2514 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2515 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0200 end') 2516 }) 2517 2518 /* * 2519 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0300 2520 * @tc.name : 001.test start-reset 2521 * @tc.desc : Recorder video start-reset 2522 * @tc.size : MediumTest 2523 * @tc.type : Function test 2524 * @tc.level : Level2 2525 */ 2526 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0300', 0, async function (done) { 2527 if (!isSupportCameraVideoProfiles) { 2528 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2529 expect(true).assertTrue(); 2530 done(); 2531 } 2532 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0300 start') 2533 let fileName = avVideoRecorderTestBase.resourceName() 2534 fdObject = await mediaTestBase.getFd(fileName); 2535 fdPath = "fd://" + fdObject.fdNumber; 2536 avConfig.url = fdPath; 2537 let mySteps = new Array( 2538 // init avRecorder 2539 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2540 // init camera 2541 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2542 // start recorder 2543 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2544 // reset recorder 2545 RESETRECORDER_CALLBACK_EVENT, 2546 // stop camera 2547 STOPCAMERA_EVENT, 2548 // release avRecorder and camera 2549 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2550 // end 2551 END_EVENT 2552 ); 2553 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2554 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0300 end') 2555 }) 2556 2557 /* * 2558 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0400 2559 * @tc.name : 001.test start-pause-reset 2560 * @tc.desc : Recorder video start-pause-reset 2561 * @tc.size : MediumTest 2562 * @tc.type : Function test 2563 * @tc.level : Level2 2564 */ 2565 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0400', 0, async function (done) { 2566 if (!isSupportCameraVideoProfiles) { 2567 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2568 expect(true).assertTrue(); 2569 done(); 2570 } 2571 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0400 start') 2572 let fileName = avVideoRecorderTestBase.resourceName() 2573 fdObject = await mediaTestBase.getFd(fileName); 2574 fdPath = "fd://" + fdObject.fdNumber; 2575 avConfig.url = fdPath; 2576 let mySteps = new Array( 2577 // init avRecorder 2578 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2579 // init camera 2580 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2581 // start recorder 2582 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2583 // pause recorder 2584 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2585 // reset recorder 2586 RESETRECORDER_CALLBACK_EVENT, 2587 // release avRecorder and camera 2588 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2589 // end 2590 END_EVENT 2591 ); 2592 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2593 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0400 end') 2594 }) 2595 2596 /* * 2597 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0500 2598 * @tc.name : 001.test start-resume-reset 2599 * @tc.desc : Recorder video start-resume-reset 2600 * @tc.size : MediumTest 2601 * @tc.type : Function test 2602 * @tc.level : Level2 2603 */ 2604 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0500', 0, async function (done) { 2605 if (!isSupportCameraVideoProfiles) { 2606 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2607 expect(true).assertTrue(); 2608 done(); 2609 } 2610 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0500 start') 2611 let fileName = avVideoRecorderTestBase.resourceName() 2612 fdObject = await mediaTestBase.getFd(fileName); 2613 fdPath = "fd://" + fdObject.fdNumber; 2614 avConfig.url = fdPath; 2615 let mySteps = new Array( 2616 // init avRecorder 2617 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2618 // init camera 2619 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2620 // start recorder 2621 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2622 // resume recorder 2623 RESUMERECORDER_CALLBACK_EVENT, 2624 // reset recorder 2625 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2626 // release avRecorder and camera 2627 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2628 // end 2629 END_EVENT 2630 ); 2631 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2632 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0500 end') 2633 }) 2634 2635 /* * 2636 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0600 2637 * @tc.name : 001.test start-stop-reset 2638 * @tc.desc : Recorder video start-stop-reset 2639 * @tc.size : MediumTest 2640 * @tc.type : Function test 2641 * @tc.level : Level2 2642 */ 2643 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0600', 0, async function (done) { 2644 if (!isSupportCameraVideoProfiles) { 2645 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2646 expect(true).assertTrue(); 2647 done(); 2648 } 2649 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0600 start') 2650 let fileName = avVideoRecorderTestBase.resourceName() 2651 fdObject = await mediaTestBase.getFd(fileName); 2652 fdPath = "fd://" + fdObject.fdNumber; 2653 avConfig.url = fdPath; 2654 let mySteps = new Array( 2655 // init avRecorder 2656 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2657 // init camera 2658 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2659 // start recorder 2660 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2661 // stop recorder 2662 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2663 // reset recorder 2664 RESETRECORDER_CALLBACK_EVENT, 2665 // release avRecorder and camera 2666 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2667 // end 2668 END_EVENT 2669 ); 2670 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2671 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0600 end') 2672 }) 2673 2674 /* * 2675 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0700 2676 * @tc.name : 001.test create-prepare-getInputSurface-reset 2677 * @tc.desc : Recorder create-prepare-getInputSurface-reset 2678 * @tc.size : MediumTest 2679 * @tc.type : Function test 2680 * @tc.level : Level2 2681 */ 2682 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0700', 0, async function (done) { 2683 if (!isSupportCameraVideoProfiles) { 2684 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2685 expect(true).assertTrue(); 2686 done(); 2687 } 2688 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0700 start') 2689 let fileName = avVideoRecorderTestBase.resourceName() 2690 fdObject = await mediaTestBase.getFd(fileName); 2691 fdPath = "fd://" + fdObject.fdNumber; 2692 avConfig.url = fdPath; 2693 let mySteps = new Array( 2694 // init avRecorder 2695 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2696 // getInputSurface 2697 GETINPUTSURFACE_CALLBACK_EVENT, 2698 // reset recorder 2699 RESETRECORDER_CALLBACK_EVENT, 2700 // release avRecorder 2701 RELEASECORDER_CALLBACK_EVENT, 2702 // end 2703 END_EVENT 2704 ); 2705 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2706 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0700 end') 2707 }) 2708 2709 /* * 2710 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0800 2711 * @tc.name : 001.test create-prepare-getInputSurface-start-reset-reset-reset 2712 * @tc.desc : Recorder create-prepare-getInputSurface-start-reset-reset-reset 2713 * @tc.size : MediumTest 2714 * @tc.type : Function test 2715 * @tc.level : Level2 2716 */ 2717 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0800', 0, async function (done) { 2718 if (!isSupportCameraVideoProfiles) { 2719 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2720 expect(true).assertTrue(); 2721 done(); 2722 } 2723 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0800 start') 2724 let fileName = avVideoRecorderTestBase.resourceName() 2725 fdObject = await mediaTestBase.getFd(fileName); 2726 fdPath = "fd://" + fdObject.fdNumber; 2727 avConfig.url = fdPath; 2728 let mySteps = new Array( 2729 // init avRecorder 2730 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 2731 // init camera 2732 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 2733 // start recorder 2734 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 2735 // reset recorder 2736 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 2737 // reset recorder 2738 RESETRECORDER_CALLBACK_EVENT, 2739 // reset recorder 2740 RESETRECORDER_CALLBACK_EVENT, 2741 // release avRecorder and camera 2742 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 2743 // end 2744 END_EVENT 2745 ); 2746 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2747 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_CALLBACK_0800 end') 2748 }) 2749 2750 /* * 2751 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0100 2752 * @tc.name : 001.test create-reset 2753 * @tc.desc : Recorder video create-reset 2754 * @tc.size : MediumTest 2755 * @tc.type : Function test 2756 * @tc.level : Level2 2757 */ 2758 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0100', 0, async function (done) { 2759 if (!isSupportCameraVideoProfiles) { 2760 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2761 expect(true).assertTrue(); 2762 done(); 2763 } 2764 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0100 start') 2765 let fileName = avVideoRecorderTestBase.resourceName() 2766 fdObject = await mediaTestBase.getFd(fileName); 2767 fdPath = "fd://" + fdObject.fdNumber; 2768 avConfig.url = fdPath; 2769 let mySteps = new Array( 2770 // init avRecorder 2771 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 2772 // reset recorder 2773 RESETRECORDER_PROMISE_EVENT, 2774 // release avRecorder and camera 2775 RELEASECORDER_PROMISE_EVENT, 2776 // end 2777 END_EVENT 2778 ); 2779 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2780 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0100 end') 2781 }) 2782 2783 /* * 2784 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0200 2785 * @tc.name : 001.test prepare-reset 2786 * @tc.desc : Recorder video prepare-reset 2787 * @tc.size : MediumTest 2788 * @tc.type : Function test 2789 * @tc.level : Level2 2790 */ 2791 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0200', 0, async function (done) { 2792 if (!isSupportCameraVideoProfiles) { 2793 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2794 expect(true).assertTrue(); 2795 done(); 2796 } 2797 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0200 start') 2798 let fileName = avVideoRecorderTestBase.resourceName() 2799 fdObject = await mediaTestBase.getFd(fileName); 2800 fdPath = "fd://" + fdObject.fdNumber; 2801 avConfig.url = fdPath; 2802 let mySteps = new Array( 2803 // init avRecorder 2804 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT,PREPARE_PROMISE_EVENT, 2805 // reset recorder 2806 RESETRECORDER_PROMISE_EVENT, 2807 // release avRecorder and camera 2808 RELEASECORDER_PROMISE_EVENT, 2809 // end 2810 END_EVENT 2811 ); 2812 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2813 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0200 end') 2814 }) 2815 2816 /* * 2817 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0300 2818 * @tc.name : 001.test start-reset 2819 * @tc.desc : Recorder video start-reset 2820 * @tc.size : MediumTest 2821 * @tc.type : Function test 2822 * @tc.level : Level2 2823 */ 2824 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0300', 0, async function (done) { 2825 if (!isSupportCameraVideoProfiles) { 2826 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2827 expect(true).assertTrue(); 2828 done(); 2829 } 2830 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0300 start') 2831 let fileName = avVideoRecorderTestBase.resourceName() 2832 fdObject = await mediaTestBase.getFd(fileName); 2833 fdPath = "fd://" + fdObject.fdNumber; 2834 avConfig.url = fdPath; 2835 let mySteps = new Array( 2836 // init avRecorder 2837 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2838 // init camera 2839 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2840 // start recorder 2841 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 2842 // reset recorder 2843 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 2844 // release avRecorder and camera 2845 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2846 // end 2847 END_EVENT 2848 ); 2849 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2850 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0300 end') 2851 }) 2852 2853 /* * 2854 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0400 2855 * @tc.name : 001.test start-pause-reset 2856 * @tc.desc : Recorder video start-pause-reset 2857 * @tc.size : MediumTest 2858 * @tc.type : Function test 2859 * @tc.level : Level2 2860 */ 2861 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0400', 0, async function (done) { 2862 if (!isSupportCameraVideoProfiles) { 2863 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2864 expect(true).assertTrue(); 2865 done(); 2866 } 2867 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0400 start') 2868 let fileName = avVideoRecorderTestBase.resourceName() 2869 fdObject = await mediaTestBase.getFd(fileName); 2870 fdPath = "fd://" + fdObject.fdNumber; 2871 avConfig.url = fdPath; 2872 let mySteps = new Array( 2873 // init avRecorder 2874 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2875 // init camera 2876 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2877 // start recorder 2878 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 2879 // pause recorder 2880 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 2881 // reset recorder 2882 RESETRECORDER_PROMISE_EVENT, 2883 // release avRecorder and camera 2884 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2885 // end 2886 END_EVENT 2887 ); 2888 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2889 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0400 end') 2890 }) 2891 2892 2893 2894 /* * 2895 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0600 2896 * @tc.name : 001.test start-stop-reset 2897 * @tc.desc : Recorder video start-stop-reset 2898 * @tc.size : MediumTest 2899 * @tc.type : Function test 2900 * @tc.level : Level2 2901 */ 2902 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0600', 0, async function (done) { 2903 if (!isSupportCameraVideoProfiles) { 2904 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2905 expect(true).assertTrue(); 2906 done(); 2907 } 2908 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0600 start') 2909 let fileName = avVideoRecorderTestBase.resourceName() 2910 fdObject = await mediaTestBase.getFd(fileName); 2911 fdPath = "fd://" + fdObject.fdNumber; 2912 avConfig.url = fdPath; 2913 let mySteps = new Array( 2914 // init avRecorder 2915 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2916 // init camera 2917 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2918 // start recorder 2919 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 2920 // stop recorder 2921 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 2922 // reset recorder 2923 RESETRECORDER_PROMISE_EVENT, 2924 // release avRecorder and camera 2925 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 2926 // end 2927 END_EVENT 2928 ); 2929 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2930 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0600 end') 2931 }) 2932 2933 /* * 2934 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0700 2935 * @tc.name : 001.test create-prepare-getInputSurface-reset 2936 * @tc.desc : Recorder create-prepare-getInputSurface-reset 2937 * @tc.size : MediumTest 2938 * @tc.type : Function test 2939 * @tc.level : Level2 2940 */ 2941 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0700', 0, async function (done) { 2942 if (!isSupportCameraVideoProfiles) { 2943 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2944 expect(true).assertTrue(); 2945 done(); 2946 } 2947 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0700 start') 2948 let fileName = avVideoRecorderTestBase.resourceName() 2949 fdObject = await mediaTestBase.getFd(fileName); 2950 fdPath = "fd://" + fdObject.fdNumber; 2951 avConfig.url = fdPath; 2952 let mySteps = new Array( 2953 // init avRecorder 2954 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2955 // init camera 2956 GETINPUTSURFACE_PROMISE_EVENT, 2957 // reset recorder 2958 RESETRECORDER_PROMISE_EVENT, 2959 // release avRecorder and camera 2960 RELEASECORDER_PROMISE_EVENT, 2961 // end 2962 END_EVENT 2963 ); 2964 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 2965 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0700 end') 2966 }) 2967 2968 /* * 2969 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0800 2970 * @tc.name : 001.test create-prepare-getInputSurface-start-reset-reset-reset 2971 * @tc.desc : Recorder create-prepare-getInputSurface-start-reset-reset-reset 2972 * @tc.size : MediumTest 2973 * @tc.type : Function test 2974 * @tc.level : Level2 2975 */ 2976 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0800', 0, async function (done) { 2977 if (!isSupportCameraVideoProfiles) { 2978 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 2979 expect(true).assertTrue(); 2980 done(); 2981 } 2982 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0800 start') 2983 let fileName = avVideoRecorderTestBase.resourceName() 2984 fdObject = await mediaTestBase.getFd(fileName); 2985 fdPath = "fd://" + fdObject.fdNumber; 2986 avConfig.url = fdPath; 2987 let mySteps = new Array( 2988 // init avRecorder 2989 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 2990 // init camera 2991 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 2992 // start recorder 2993 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 2994 // stop recorder 2995 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, 2996 // reset recorder 2997 RESETRECORDER_PROMISE_EVENT, 2998 // reset recorder 2999 RESETRECORDER_PROMISE_EVENT, 3000 // reset recorder 3001 RESETRECORDER_PROMISE_EVENT, 3002 // release avRecorder and camera 3003 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3004 // end 3005 END_EVENT 3006 ); 3007 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3008 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_RESET_PROMISE_0800 end') 3009 }) 3010 3011 // promise prepare 3012 /* * 3013 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0100 3014 * @tc.name : 01. create->prepare 3015 * @tc.desc : 1.create 2.prepare 3016 * @tc.size : MediumTest 3017 * @tc.type : Function 3018 * @tc.level : Level 2 3019 */ 3020 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0100', 0, async function (done) { 3021 if (!isSupportCameraVideoProfiles) { 3022 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3023 expect(true).assertTrue(); 3024 done(); 3025 } 3026 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0100 start') 3027 let fileName = avVideoRecorderTestBase.resourceName() 3028 fdObject = await mediaTestBase.getFd(fileName); 3029 fdPath = "fd://" + fdObject.fdNumber; 3030 avConfig.url = fdPath; 3031 let mySteps = new Array( 3032 // setAvRecorderCallback 3033 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3034 // AVRecorderTestBase.preparePromise 3035 PREPARE_PROMISE_EVENT, 3036 // AVRecorderTestBase.releasePromise 3037 RELEASECORDER_PROMISE_EVENT, 3038 // end 3039 END_EVENT 3040 ); 3041 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3042 3043 // avVideoRecorderTestBase.create2PreparePromise(avConfig, avRecorder, done); 3044 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0100 end') 3045 }) 3046 3047 /* * 3048 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0200 3049 * @tc.name : 02. start->prepare 3050 * @tc.desc : 1.create 2.prepare 3.start 4.prepare 3051 * @tc.size : MediumTest 3052 * @tc.type : Function 3053 * @tc.level : Level 2 3054 */ 3055 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0200', 0, async function (done) { 3056 if (!isSupportCameraVideoProfiles) { 3057 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3058 expect(true).assertTrue(); 3059 done(); 3060 } 3061 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0200 start') 3062 let fileName = avVideoRecorderTestBase.resourceName() 3063 fdObject = await mediaTestBase.getFd(fileName); 3064 fdPath = "fd://" + fdObject.fdNumber; 3065 avConfig.url = fdPath; 3066 let mySteps = new Array( 3067 // setAvRecorderCallback 3068 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3069 // preparePromise 3070 PREPARE_PROMISE_EVENT, 3071 // getInputSurfacePromise 3072 GETINPUTSURFACE_PROMISE_EVENT, 3073 // initCamera 3074 INITCAMERA_EVENT, 3075 // startRecordingProcessPromise 3076 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3077 // prepareErrPromise 3078 PREPARE_PROMISE_EVENT, 3079 // stopCameraOutput 3080 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3081 // releaseRecorderPromise 3082 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3083 // end 3084 END_EVENT 3085 ); 3086 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3087 3088 // avVideoRecorderTestBase.start2PreparePromise(avConfig, avRecorder, recorderTime, done); 3089 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0200 end') 3090 }) 3091 3092 /* * 3093 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0300 3094 * @tc.name : 03. pause->prepare 3095 * @tc.desc : 1.create 2.prepare 3.start 4.pause 5.prepare 3096 * @tc.size : MediumTest 3097 * @tc.type : Function 3098 * @tc.level : Level 2 3099 */ 3100 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0300', 0, async function (done) { 3101 if (!isSupportCameraVideoProfiles) { 3102 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3103 expect(true).assertTrue(); 3104 done(); 3105 } 3106 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0300 start') 3107 let fileName = avVideoRecorderTestBase.resourceName() 3108 fdObject = await mediaTestBase.getFd(fileName); 3109 fdPath = "fd://" + fdObject.fdNumber; 3110 avConfig.url = fdPath; 3111 let mySteps = new Array( 3112 // setAvRecorderCallback 3113 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3114 // preparePromise 3115 PREPARE_PROMISE_EVENT, 3116 // getInputSurfacePromise 3117 GETINPUTSURFACE_PROMISE_EVENT, 3118 // initCamera 3119 INITCAMERA_EVENT, 3120 // startRecordingProcessPromise 3121 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3122 // AVRecorderTestBase.pausePromise 3123 PAUSERECORDER_PROMISE_EVENT, 3124 // prepareErrPromise 3125 PREPARE_PROMISE_EVENT, 3126 // stopCameraOutput 3127 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3128 // releaseRecorderPromise 3129 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3130 END_EVENT 3131 ); 3132 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3133 3134 // avVideoRecorderTestBase.pause2PreparePromise(avConfig, avRecorder, recorderTime, done); 3135 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0300 end') 3136 }) 3137 3138 /* * 3139 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0400 3140 * @tc.name : 04. resume->prepare 3141 * @tc.desc : 1.create 2.prepare 3.start 4.pause 5.resume 6.prepare 3142 * @tc.size : MediumTest 3143 * @tc.type : Function 3144 * @tc.level : Level 2 3145 */ 3146 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0400', 0, async function (done) { 3147 if (!isSupportCameraVideoProfiles) { 3148 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3149 expect(true).assertTrue(); 3150 done(); 3151 } 3152 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0400 start') 3153 let fileName = avVideoRecorderTestBase.resourceName() 3154 fdObject = await mediaTestBase.getFd(fileName); 3155 fdPath = "fd://" + fdObject.fdNumber; 3156 avConfig.url = fdPath; 3157 let mySteps = new Array( 3158 // setAvRecorderCallback 3159 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3160 // preparePromise 3161 PREPARE_PROMISE_EVENT, 3162 // getInputSurfacePromise 3163 GETINPUTSURFACE_PROMISE_EVENT, 3164 // initCamera 3165 INITCAMERA_EVENT, 3166 // startRecordingProcessPromise 3167 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3168 // AVRecorderTestBase.pausePromise 3169 PAUSERECORDER_PROMISE_EVENT, 3170 //? AVRecorderTestBase.resumePromise 3171 RESUMERECORDER_PROMISE_EVENT, 3172 // prepareErrPromise 3173 PREPARE_PROMISE_EVENT, 3174 // stopCameraOutput 3175 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3176 // releaseRecorderPromise 3177 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3178 END_EVENT 3179 ); 3180 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3181 3182 // avVideoRecorderTestBase.resume2PreparePromise(avConfig, avRecorder, recorderTime, done); 3183 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0400 end') 3184 }) 3185 3186 /* * 3187 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0500 3188 * @tc.name : 05. stop->prepare 3189 * @tc.desc : 1.create 2.prepare 3.start 4.stop 5.prepare 3190 * @tc.size : MediumTest 3191 * @tc.type : Function 3192 * @tc.level : Level 2 3193 */ 3194 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0500', 0, async function (done) { 3195 if (!isSupportCameraVideoProfiles) { 3196 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3197 expect(true).assertTrue(); 3198 done(); 3199 } 3200 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0500 start') 3201 let fileName = avVideoRecorderTestBase.resourceName() 3202 fdObject = await mediaTestBase.getFd(fileName); 3203 fdPath = "fd://" + fdObject.fdNumber; 3204 avConfig.url = fdPath; 3205 let mySteps = new Array( 3206 // setAvRecorderCallback 3207 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3208 // preparePromise 3209 PREPARE_PROMISE_EVENT, 3210 // getInputSurfacePromise 3211 GETINPUTSURFACE_PROMISE_EVENT, 3212 // initCamera 3213 INITCAMERA_EVENT, 3214 // startRecordingProcessPromise 3215 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3216 // AVRecorderTestBase.stopPromise 3217 STOPRECORDER_PROMISE_EVENT, 3218 // prepareErrPromise 3219 PREPARE_PROMISE_EVENT, 3220 // stopCameraOutput 3221 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3222 // releaseRecorderPromise 3223 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3224 END_EVENT 3225 ); 3226 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3227 3228 // avVideoRecorderTestBase.stop2PreparePromise(avConfig, avRecorder, recorderTime, done); 3229 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0500 end') 3230 }) 3231 3232 /* * 3233 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0600 3234 * @tc.name : 06. reset->prepare 3235 * @tc.desc : 1.create 2.prepare 3.start 4.reset 5.prepare 3236 * @tc.size : MediumTest 3237 * @tc.type : Function 3238 * @tc.level : Level 2 3239 */ 3240 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0600', 0, async function (done) { 3241 if (!isSupportCameraVideoProfiles) { 3242 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3243 expect(true).assertTrue(); 3244 done(); 3245 } 3246 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0600 start') 3247 let fileName = avVideoRecorderTestBase.resourceName() 3248 fdObject = await mediaTestBase.getFd(fileName); 3249 fdPath = "fd://" + fdObject.fdNumber; 3250 avConfig.url = fdPath; 3251 let mySteps = new Array( 3252 // setAvRecorderCallback 3253 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3254 // preparePromise 3255 PREPARE_PROMISE_EVENT, 3256 // getInputSurfacePromise 3257 GETINPUTSURFACE_PROMISE_EVENT, 3258 // initCamera 3259 INITCAMERA_EVENT, 3260 // startRecordingProcessPromise 3261 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3262 // AVRecorderTestBase.resetPromise 3263 RESETRECORDER_PROMISE_EVENT, 3264 // preparePromise 3265 PREPARE_PROMISE_EVENT, 3266 // stopCameraOutput 3267 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3268 // releaseRecorderPromise 3269 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3270 END_EVENT 3271 ); 3272 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3273 3274 // avVideoRecorderTestBase.reset2PreparePromise(avConfig, avRecorder, recorderTime, done); 3275 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0600 end') 3276 }) 3277 3278 /* * 3279 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0700 3280 * @tc.name : 07. getInputSurface->prepare 3281 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.prepare 3282 * @tc.size : MediumTest 3283 * @tc.type : Function 3284 * @tc.level : Level 2 3285 */ 3286 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0700', 0, async function (done) { 3287 if (!isSupportCameraVideoProfiles) { 3288 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3289 expect(true).assertTrue(); 3290 done(); 3291 } 3292 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0700 start') 3293 let fileName = avVideoRecorderTestBase.resourceName() 3294 fdObject = await mediaTestBase.getFd(fileName); 3295 fdPath = "fd://" + fdObject.fdNumber; 3296 avConfig.url = fdPath; 3297 let mySteps = new Array( 3298 // setAvRecorderCallback 3299 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3300 // preparePromise 3301 PREPARE_PROMISE_EVENT, 3302 // getInputSurfacePromise 3303 GETINPUTSURFACE_PROMISE_EVENT, 3304 // initCamera 3305 INITCAMERA_EVENT, 3306 // prepareErrPromise 3307 PREPARE_PROMISE_EVENT, 3308 // releaseRecorderCallBack 3309 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3310 // end 3311 END_EVENT 3312 ); 3313 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3314 3315 // avVideoRecorderTestBase.getInputSurface2PreparePromise(avConfig, avRecorder, done); 3316 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0700 end') 3317 }) 3318 3319 /* * 3320 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0800 3321 * @tc.name : 08. prepare 3 times 3322 * @tc.desc : 1.create 2.prepare 3.prepare 4.prepare 3323 * @tc.size : MediumTest 3324 * @tc.type : Function 3325 * @tc.level : Level 2 3326 */ 3327 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0800', 0, async function (done) { 3328 if (!isSupportCameraVideoProfiles) { 3329 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3330 expect(true).assertTrue(); 3331 done(); 3332 } 3333 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0800 start') 3334 let fileName = avVideoRecorderTestBase.resourceName() 3335 fdObject = await mediaTestBase.getFd(fileName); 3336 fdPath = "fd://" + fdObject.fdNumber; 3337 avConfig.url = fdPath; 3338 let loopTimes = 3; 3339 let mySteps = new Array( 3340 // setAvRecorderCallback 3341 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT 3342 ); 3343 for (let i = 0; i < loopTimes; i++) 3344 { 3345 mySteps.push( 3346 // preparePromise 3347 PREPARE_PROMISE_EVENT, 3348 // AVRecorderTestBase.resetPromise 3349 RESETRECORDER_PROMISE_EVENT, 3350 ) 3351 } 3352 mySteps.push( 3353 // AVRecorderTestBase.releasePromise 3354 RELEASECORDER_PROMISE_EVENT, 3355 // end 3356 END_EVENT 3357 ) 3358 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3359 3360 // avVideoRecorderTestBase.prepare3TimesPromise(avConfig, avRecorder, loopTimes, done); 3361 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0800 end') 3362 }) 3363 3364 /* * 3365 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0900 3366 * @tc.name : 09.audioBitrate -1 3367 * @tc.desc : 1.create 2.prepare (audioBitrate -1) 3368 * @tc.size : MediumTest 3369 * @tc.type : Function 3370 * @tc.level : Level 2 3371 */ 3372 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0900', 0, async function (done) { 3373 if (!isSupportCameraVideoProfiles) { 3374 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3375 expect(true).assertTrue(); 3376 done(); 3377 } 3378 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0900 start') 3379 let avNewProfile = { 3380 audioBitrate : -1, 3381 audioChannels : 2, 3382 audioCodec : media.CodecMimeType.AUDIO_AAC, 3383 audioSampleRate : 48000, 3384 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 3385 videoBitrate : 280000, // 视频比特率 3386 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 3387 videoFrameWidth : 640, // 视频分辨率的宽 3388 videoFrameHeight : 480, // 视频分辨率的高 3389 videoFrameRate : 30 // 视频帧率 3390 } 3391 let avNewConfig = { 3392 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 3393 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 3394 profile : avNewProfile, 3395 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 3396 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 3397 location : { latitude : 30, longitude : 130 } 3398 } 3399 let fileName = avVideoRecorderTestBase.resourceName() 3400 fdObject = await mediaTestBase.getFd(fileName); 3401 fdPath = "fd://" + fdObject.fdNumber; 3402 avNewConfig.url = fdPath; 3403 checkDevice(avNewConfig) 3404 let mySteps = new Array( 3405 // setAvRecorderCallback 3406 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3407 // prepareErrPromise 3408 PREPARE_PROMISE_EVENT, 3409 // AVRecorderTestBase.releasePromise 3410 RELEASECORDER_PROMISE_EVENT, 3411 // end 3412 END_EVENT 3413 ); 3414 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 3415 3416 // avVideoRecorderTestBase.avConfigChangedPromise(avNewConfig, avRecorder, done); 3417 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_0900 end') 3418 }) 3419 3420 /* * 3421 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1000 3422 * @tc.name : 10.audioSampleRate -1 3423 * @tc.desc : 1.create 2.prepare (audioSampleRate -1) 3424 * @tc.size : MediumTest 3425 * @tc.type : Function 3426 * @tc.level : Level 2 3427 */ 3428 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1000', 0, async function (done) { 3429 if (!isSupportCameraVideoProfiles) { 3430 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3431 expect(true).assertTrue(); 3432 done(); 3433 } 3434 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1000 start') 3435 let avNewProfile = { 3436 audioBitrate : 48000, 3437 audioChannels : 2, 3438 audioCodec : media.CodecMimeType.AUDIO_AAC, 3439 audioSampleRate : -1, 3440 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 3441 videoBitrate : 280000, // 视频比特率 3442 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 3443 videoFrameWidth : 640, // 视频分辨率的宽 3444 videoFrameHeight : 480, // 视频分辨率的高 3445 videoFrameRate : 30 // 视频帧率 3446 } 3447 let avNewConfig = { 3448 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 3449 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 3450 profile : avNewProfile, 3451 url : 'fd://35', 3452 rotation : 0, 3453 location : { latitude : 30, longitude : 130 } 3454 } 3455 let fileName = avVideoRecorderTestBase.resourceName() 3456 fdObject = await mediaTestBase.getFd(fileName); 3457 fdPath = "fd://" + fdObject.fdNumber; 3458 avNewConfig.url = fdPath; 3459 checkDevice(avNewConfig) 3460 let mySteps = new Array( 3461 // setAvRecorderCallback 3462 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3463 // prepareErrPromise 3464 PREPARE_PROMISE_EVENT, 3465 // AVRecorderTestBase.releasePromise 3466 RELEASECORDER_PROMISE_EVENT, 3467 // end 3468 END_EVENT 3469 ); 3470 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 3471 3472 // avVideoRecorderTestBase.avConfigChangedPromise(avNewConfig, avRecorder, done); 3473 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1000 end') 3474 }) 3475 3476 /* * 3477 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1100 3478 * @tc.name : 11.videoBitrateRange -1 3479 * @tc.desc : 1.create 2.prepare (videoBitrateRange -1) 3480 * @tc.size : MediumTest 3481 * @tc.type : Function 3482 * @tc.level : Level 2 3483 */ 3484 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1100', 0, async function (done) { 3485 if (!isSupportCameraVideoProfiles) { 3486 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3487 expect(true).assertTrue(); 3488 done(); 3489 } 3490 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1100 start') 3491 let avNewProfile = { 3492 audioBitrate : 48000, 3493 audioChannels : 2, 3494 audioCodec : media.CodecMimeType.AUDIO_AAC, 3495 audioSampleRate : 48000, 3496 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 3497 videoBitrate : -1, // 视频比特率 3498 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 3499 videoFrameWidth : 640, // 视频分辨率的宽 3500 videoFrameHeight : 480, // 视频分辨率的高 3501 videoFrameRate : 30 // 视频帧率 3502 } 3503 let avNewConfig = { 3504 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 3505 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 3506 profile : avNewProfile, 3507 url : 'fd://35', 3508 rotation : 0, 3509 location : { latitude : 30, longitude : 130 } 3510 } 3511 let fileName = avVideoRecorderTestBase.resourceName() 3512 fdObject = await mediaTestBase.getFd(fileName); 3513 fdPath = "fd://" + fdObject.fdNumber; 3514 avNewConfig.url = fdPath; 3515 checkDevice(avNewConfig) 3516 let mySteps = new Array( 3517 // setAvRecorderCallback 3518 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3519 // prepareErrPromise 3520 PREPARE_PROMISE_EVENT, 3521 // AVRecorderTestBase.releasePromise 3522 RELEASECORDER_PROMISE_EVENT, 3523 // end 3524 END_EVENT 3525 ); 3526 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3527 3528 // avVideoRecorderTestBase.avConfigChangedPromise(avNewConfig, avRecorder, done); 3529 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1100 end') 3530 }) 3531 3532 /* * 3533 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1200 3534 * @tc.name : 12.videoFrameRate -1 3535 * @tc.desc : 1.create 2.prepare (videoFrameRate -1) 3536 * @tc.size : MediumTest 3537 * @tc.type : Function 3538 * @tc.level : Level 2 3539 */ 3540 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1200', 0, async function (done) { 3541 if (!isSupportCameraVideoProfiles) { 3542 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3543 expect(true).assertTrue(); 3544 done(); 3545 } 3546 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1200 start') 3547 let avNewProfile = { 3548 audioBitrate : 48000, 3549 audioChannels : 2, 3550 audioCodec : media.CodecMimeType.AUDIO_AAC, 3551 audioSampleRate : 48000, 3552 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 3553 videoBitrate : 280000, // 视频比特率 3554 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 3555 videoFrameWidth : 640, // 视频分辨率的宽 3556 videoFrameHeight : 480, // 视频分辨率的高 3557 videoFrameRate : -1 // 视频帧率 3558 } 3559 let avNewConfig = { 3560 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 3561 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 3562 profile : avNewProfile, 3563 url : 'fd://35', 3564 rotation : 0, 3565 location : { latitude : 30, longitude : 130 } 3566 } 3567 let fileName = avVideoRecorderTestBase.resourceName() 3568 fdObject = await mediaTestBase.getFd(fileName); 3569 fdPath = "fd://" + fdObject.fdNumber; 3570 avNewConfig.url = fdPath; 3571 checkDevice(avNewConfig) 3572 let mySteps = new Array( 3573 // setAvRecorderCallback 3574 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3575 // prepareErrPromise 3576 PREPARE_PROMISE_EVENT, 3577 // AVRecorderTestBase.releasePromise 3578 RELEASECORDER_PROMISE_EVENT, 3579 // end 3580 END_EVENT 3581 ); 3582 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 3583 3584 // avVideoRecorderTestBase.avConfigChangedPromise(avNewConfig, avRecorder, done); 3585 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_PROMISE_1200 end') 3586 }) 3587 3588 // Promise getInputSurface 3589 /* * 3590 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0100 3591 * @tc.name : 01. create->getInputSurface 3592 * @tc.desc : 1.create 2.getInputSurface 3593 * @tc.size : MediumTest 3594 * @tc.type : Function 3595 * @tc.level : Level 2 3596 */ 3597 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0100', 0, async function (done) { 3598 if (!isSupportCameraVideoProfiles) { 3599 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3600 expect(true).assertTrue(); 3601 done(); 3602 } 3603 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0100 start') 3604 let fileName = avVideoRecorderTestBase.resourceName() 3605 fdObject = await mediaTestBase.getFd(fileName); 3606 fdPath = "fd://" + fdObject.fdNumber; 3607 avConfig.url = fdPath; 3608 let mySteps = new Array( 3609 // setAvRecorderCallback 3610 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3611 //? getInputSurfaceErrPromise 3612 GETINPUTSURFACE_PROMISE_EVENT, 3613 // AVRecorderTestBase.releasePromise 3614 RELEASECORDER_PROMISE_EVENT, 3615 // end 3616 END_EVENT 3617 ); 3618 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3619 3620 // avVideoRecorderTestBase.create2GetInputSurfacePromise(avConfig, avRecorder, done); 3621 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0100 end') 3622 }) 3623 3624 /* * 3625 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0200 3626 * @tc.name : 02. prepare->getInputSurface 3627 * @tc.desc : 1.create 2.prepare 3.getInputSurface 3628 * @tc.size : MediumTest 3629 * @tc.type : Function 3630 * @tc.level : Level 2 3631 */ 3632 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0200', 0, async function (done) { 3633 if (!isSupportCameraVideoProfiles) { 3634 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3635 expect(true).assertTrue(); 3636 done(); 3637 } 3638 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0200 start') 3639 let fileName = avVideoRecorderTestBase.resourceName() 3640 fdObject = await mediaTestBase.getFd(fileName); 3641 fdPath = "fd://" + fdObject.fdNumber; 3642 avConfig.url = fdPath; 3643 let mySteps = new Array( 3644 // setAvRecorderCallback 3645 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3646 // AVRecorderTestBase.preparePromise 3647 PREPARE_PROMISE_EVENT, 3648 //? getInputSurfaceErrPromise 3649 GETINPUTSURFACE_PROMISE_EVENT, 3650 // initCamera 3651 INITCAMERA_EVENT, 3652 // AVRecorderTestBase.releasePromise 3653 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3654 // end 3655 END_EVENT 3656 ); 3657 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3658 3659 // avVideoRecorderTestBase.create2GetInputSurfacePromise2(avConfig, avRecorder, done); 3660 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0200 end') 3661 }) 3662 3663 /* * 3664 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0300 3665 * @tc.name : 03. start->getInputSurface 3666 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.getInputSurface 3667 * @tc.size : MediumTest 3668 * @tc.type : Function 3669 * @tc.level : Level 2 3670 */ 3671 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0300', 0, async function (done) { 3672 if (!isSupportCameraVideoProfiles) { 3673 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3674 expect(true).assertTrue(); 3675 done(); 3676 } 3677 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0300 start') 3678 let fileName = avVideoRecorderTestBase.resourceName() 3679 fdObject = await mediaTestBase.getFd(fileName); 3680 fdPath = "fd://" + fdObject.fdNumber; 3681 avConfig.url = fdPath; 3682 let mySteps = new Array( 3683 // setAvRecorderCallback 3684 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3685 // AVRecorderTestBase.preparePromise 3686 PREPARE_PROMISE_EVENT, 3687 //? getInputSurfaceErrPromise 3688 GETINPUTSURFACE_PROMISE_EVENT, 3689 // initCamera 3690 INITCAMERA_EVENT, 3691 // startRecordingProcessPromise 3692 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3693 //? getInputSurfaceErrPromise 3694 GETINPUTSURFACE_PROMISE_EVENT, 3695 // releaseRecorderPromise 3696 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3697 // end 3698 END_EVENT 3699 ); 3700 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3701 3702 // avVideoRecorderTestBase.create2GetInputSurfacePromise3(avConfig, avRecorder, recorderTime, done); 3703 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0300 end') 3704 }) 3705 3706 /* * 3707 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0400 3708 * @tc.name : 04. pause->getInputSurface 3709 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.getInputSurface 3710 * @tc.size : MediumTest 3711 * @tc.type : Function 3712 * @tc.level : Level 2 3713 */ 3714 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0400', 0, async function (done) { 3715 if (!isSupportCameraVideoProfiles) { 3716 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3717 expect(true).assertTrue(); 3718 done(); 3719 } 3720 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0400 start') 3721 let fileName = avVideoRecorderTestBase.resourceName() 3722 fdObject = await mediaTestBase.getFd(fileName); 3723 fdPath = "fd://" + fdObject.fdNumber; 3724 avConfig.url = fdPath; 3725 let mySteps = new Array( 3726 // setAvRecorderCallback 3727 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3728 // AVRecorderTestBase.preparePromise 3729 PREPARE_PROMISE_EVENT, 3730 //? getInputSurfaceErrPromise 3731 GETINPUTSURFACE_PROMISE_EVENT, 3732 // initCamera 3733 INITCAMERA_EVENT, 3734 // startRecordingProcessPromise 3735 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3736 // AVRecorderTestBase.pausePromise 3737 PAUSERECORDER_PROMISE_EVENT, 3738 //? getInputSurfaceErrPromise 3739 GETINPUTSURFACE_PROMISE_EVENT, 3740 // stopCameraOutput 3741 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3742 // releaseRecorderPromise 3743 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3744 // end 3745 END_EVENT 3746 ); 3747 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3748 3749 // avVideoRecorderTestBase.create2GetInputSurfacePromise4(avConfig, avRecorder, recorderTime, done); 3750 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0400 end') 3751 }) 3752 3753 /* * 3754 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0500 3755 * @tc.name : 05. resume->getInputSurface 3756 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.getInputSurface 3757 * @tc.size : MediumTest 3758 * @tc.type : Function 3759 * @tc.level : Level 2 3760 */ 3761 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0500', 0, async function (done) { 3762 if (!isSupportCameraVideoProfiles) { 3763 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3764 expect(true).assertTrue(); 3765 done(); 3766 } 3767 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0500 start') 3768 let fileName = avVideoRecorderTestBase.resourceName() 3769 fdObject = await mediaTestBase.getFd(fileName); 3770 fdPath = "fd://" + fdObject.fdNumber; 3771 avConfig.url = fdPath; 3772 let mySteps = new Array( 3773 // setAvRecorderCallback 3774 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3775 // AVRecorderTestBase.preparePromise 3776 PREPARE_PROMISE_EVENT, 3777 //? getInputSurfaceErrPromise 3778 GETINPUTSURFACE_PROMISE_EVENT, 3779 // initCamera 3780 INITCAMERA_EVENT, 3781 // startRecordingProcessPromise 3782 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3783 // AVRecorderTestBase.pausePromise 3784 PAUSERECORDER_PROMISE_EVENT, 3785 //? AVRecorderTestBase.resumePromise 3786 RESUMERECORDER_PROMISE_EVENT, 3787 // stopCameraOutput 3788 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3789 //? getInputSurfaceErrPromise 3790 GETINPUTSURFACE_PROMISE_EVENT, 3791 // releaseRecorderPromise 3792 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3793 // end 3794 END_EVENT 3795 ); 3796 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3797 3798 // avVideoRecorderTestBase.create2GetInputSurfacePromise5(avConfig, avRecorder, recorderTime, done); 3799 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0500 end') 3800 }) 3801 3802 /* * 3803 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0600 3804 * @tc.name : 06. stop->getInputSurface 3805 * @tc.desc :1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.getInputSurface 3806 * @tc.size : MediumTest 3807 * @tc.type : Function 3808 * @tc.level : Level 2 3809 */ 3810 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0600', 0, async function (done) { 3811 if (!isSupportCameraVideoProfiles) { 3812 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3813 expect(true).assertTrue(); 3814 done(); 3815 } 3816 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0600 start') 3817 let fileName = avVideoRecorderTestBase.resourceName() 3818 fdObject = await mediaTestBase.getFd(fileName); 3819 fdPath = "fd://" + fdObject.fdNumber; 3820 avConfig.url = fdPath; 3821 let mySteps = new Array( 3822 // setAvRecorderCallback 3823 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3824 // AVRecorderTestBase.preparePromise 3825 PREPARE_PROMISE_EVENT, 3826 //? getInputSurfaceErrPromise 3827 GETINPUTSURFACE_PROMISE_EVENT, 3828 // initCamera 3829 INITCAMERA_EVENT, 3830 // startRecordingProcessPromise 3831 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3832 // AVRecorderTestBase.stopPromise 3833 STOPRECORDER_PROMISE_EVENT, 3834 //? getInputSurfaceErrPromise 3835 GETINPUTSURFACE_PROMISE_EVENT, 3836 // stopCameraOutput 3837 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3838 // releaseRecorderPromise 3839 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3840 // end 3841 END_EVENT 3842 ); 3843 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3844 3845 // avVideoRecorderTestBase.create2GetInputSurfacePromise6(avConfig, avRecorder, recorderTime, done); 3846 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0600 end') 3847 }) 3848 3849 /* * 3850 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0700 3851 * @tc.name : 07. reset->getInputSurface 3852 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.getInputSurface 3853 * @tc.size : MediumTest 3854 * @tc.type : Function 3855 * @tc.level : Level 2 3856 */ 3857 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0700', 0, async function (done) { 3858 if (!isSupportCameraVideoProfiles) { 3859 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3860 expect(true).assertTrue(); 3861 done(); 3862 } 3863 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0700 start') 3864 let fileName = avVideoRecorderTestBase.resourceName() 3865 fdObject = await mediaTestBase.getFd(fileName); 3866 fdPath = "fd://" + fdObject.fdNumber; 3867 avConfig.url = fdPath; 3868 let mySteps = new Array( 3869 // setAvRecorderCallback 3870 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3871 // AVRecorderTestBase.preparePromise 3872 PREPARE_PROMISE_EVENT, 3873 //? getInputSurfaceErrPromise 3874 GETINPUTSURFACE_PROMISE_EVENT, 3875 // initCamera 3876 INITCAMERA_EVENT, 3877 // startRecordingProcessPromise 3878 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 3879 // AVRecorderTestBase.resetPromise 3880 RESETRECORDER_PROMISE_EVENT, 3881 //? getInputSurfaceErrPromise 3882 GETINPUTSURFACE_PROMISE_EVENT, 3883 // stopCameraOutput 3884 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 3885 // releaseRecorderPromise 3886 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3887 // end 3888 END_EVENT 3889 ); 3890 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3891 3892 // avVideoRecorderTestBase.create2GetInputSurfacePromise7(avConfig, avRecorder, recorderTime, done); 3893 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0700 end') 3894 }) 3895 3896 /* * 3897 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0800 3898 * @tc.name : 08. getInputSurface 3 times 3899 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.getInputSurface 5.getInputSurface 3900 * @tc.size : MediumTest 3901 * @tc.type : Function 3902 * @tc.level : Level 2 3903 */ 3904 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0800', 0, async function (done) { 3905 if (!isSupportCameraVideoProfiles) { 3906 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3907 expect(true).assertTrue(); 3908 done(); 3909 } 3910 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0800 start') 3911 let fileName = avVideoRecorderTestBase.resourceName() 3912 fdObject = await mediaTestBase.getFd(fileName); 3913 fdPath = "fd://" + fdObject.fdNumber; 3914 avConfig.url = fdPath; 3915 let loopTimes = 3; 3916 let mySteps = new Array( 3917 // setAvRecorderCallback 3918 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3919 // AVRecorderTestBase.preparePromise 3920 PREPARE_PROMISE_EVENT 3921 ); 3922 for (let i = 0; i < loopTimes; i++) 3923 { 3924 mySteps.push( 3925 // getInputSurfacePromise 3926 GETINPUTSURFACE_PROMISE_EVENT 3927 ) 3928 } 3929 mySteps.push( 3930 // initCamera 3931 INITCAMERA_EVENT, 3932 // releaseRecorderPromise 3933 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 3934 END_EVENT 3935 ) 3936 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3937 3938 // avVideoRecorderTestBase.getInputSurface3TimesPromise(avConfig, avRecorder, loopTimes, done); 3939 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_PROMISE_0800 end') 3940 }) 3941 3942 // Promise start 3943 /* * 3944 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0100 3945 * @tc.name : 01. create->start 3946 * @tc.desc : 1.create 2.start 3947 * @tc.size : MediumTest 3948 * @tc.type : Function 3949 * @tc.level : Level 2 3950 */ 3951 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0100', 0, async function (done) { 3952 if (!isSupportCameraVideoProfiles) { 3953 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3954 expect(true).assertTrue(); 3955 done(); 3956 } 3957 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0100 start') 3958 let fileName = avVideoRecorderTestBase.resourceName() 3959 fdObject = await mediaTestBase.getFd(fileName); 3960 fdPath = "fd://" + fdObject.fdNumber; 3961 avConfig.url = fdPath; 3962 let mySteps = new Array( 3963 // setAvRecorderCallback 3964 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 3965 //? startErrPromise 3966 STARTRECORDER_PROMISE_EVENT, 3967 // AVRecorderTestBase.releasePromise 3968 RELEASECORDER_PROMISE_EVENT, 3969 // end 3970 END_EVENT 3971 ); 3972 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 3973 3974 // avVideoRecorderTestBase.create2StartPromise(avConfig, avRecorder, recorderTime, done); 3975 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0100 end') 3976 }) 3977 3978 /* * 3979 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0200 3980 * @tc.name : 02. prepare->start 3981 * @tc.desc : 1.create 2.prepare 4.start 3982 * @tc.size : MediumTest 3983 * @tc.type : Function 3984 * @tc.level : Level 2 3985 */ 3986 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0200', 0, async function (done) { 3987 if (!isSupportCameraVideoProfiles) { 3988 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 3989 expect(true).assertTrue(); 3990 done(); 3991 } 3992 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0200 start') 3993 let fileName = avVideoRecorderTestBase.resourceName() 3994 fdObject = await mediaTestBase.getFd(fileName); 3995 fdPath = "fd://" + fdObject.fdNumber; 3996 avConfig.url = fdPath; 3997 let mySteps = new Array( 3998 // setAvRecorderCallback 3999 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4000 // AVRecorderTestBase.preparePromise 4001 PREPARE_PROMISE_EVENT, 4002 //? startErrPromise 4003 STARTRECORDER_PROMISE_EVENT, 4004 // AVRecorderTestBase.releasePromise 4005 RELEASECORDER_PROMISE_EVENT, 4006 // end 4007 END_EVENT 4008 ); 4009 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4010 4011 // avVideoRecorderTestBase.prepare2StartPromise(avConfig, avRecorder, recorderTime, done); 4012 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0200 end') 4013 }) 4014 4015 /* * 4016 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0300 4017 * @tc.name : 03. pause->start 4018 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.start 4019 * @tc.size : MediumTest 4020 * @tc.type : Function 4021 * @tc.level : Level 2 4022 */ 4023 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0300', 0, async function (done) { 4024 if (!isSupportCameraVideoProfiles) { 4025 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4026 expect(true).assertTrue(); 4027 done(); 4028 } 4029 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0300 start') 4030 let fileName = avVideoRecorderTestBase.resourceName() 4031 fdObject = await mediaTestBase.getFd(fileName); 4032 fdPath = "fd://" + fdObject.fdNumber; 4033 avConfig.url = fdPath; 4034 let mySteps = new Array( 4035 // setAvRecorderCallback 4036 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4037 // AVRecorderTestBase.preparePromise 4038 PREPARE_PROMISE_EVENT, 4039 // getInputSurfacePromise 4040 GETINPUTSURFACE_PROMISE_EVENT, 4041 // initCamera 4042 INITCAMERA_EVENT, 4043 // startRecordingProcessPromise 4044 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4045 // AVRecorderTestBase.pausePromise 4046 PAUSERECORDER_PROMISE_EVENT, 4047 //? startErrPromise 4048 STARTRECORDER_PROMISE_EVENT, 4049 // stopCameraOutput 4050 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4051 // releaseRecorderPromise 4052 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4053 // end 4054 END_EVENT 4055 ); 4056 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4057 4058 // avVideoRecorderTestBase.pause2StartPromise(avConfig, avRecorder, recorderTime, done); 4059 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0300 end') 4060 }) 4061 4062 /* * 4063 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0400 4064 * @tc.name : 04. resume->start 4065 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.start 4066 * @tc.size : MediumTest 4067 * @tc.type : Function 4068 * @tc.level : Level 2 4069 */ 4070 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0400', 0, async function (done) { 4071 if (!isSupportCameraVideoProfiles) { 4072 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4073 expect(true).assertTrue(); 4074 done(); 4075 } 4076 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0400 start') 4077 let fileName = avVideoRecorderTestBase.resourceName() 4078 fdObject = await mediaTestBase.getFd(fileName); 4079 fdPath = "fd://" + fdObject.fdNumber; 4080 avConfig.url = fdPath; 4081 let mySteps = new Array( 4082 // setAvRecorderCallback 4083 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4084 // AVRecorderTestBase.preparePromise 4085 PREPARE_PROMISE_EVENT, 4086 // getInputSurfacePromise 4087 GETINPUTSURFACE_PROMISE_EVENT, 4088 // initCamera 4089 INITCAMERA_EVENT, 4090 // startRecordingProcessPromise 4091 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4092 // AVRecorderTestBase.pausePromise 4093 PAUSERECORDER_PROMISE_EVENT, 4094 //? AVRecorderTestBase.resumePromise 4095 RESUMERECORDER_PROMISE_EVENT, 4096 //? startErrPromise 4097 STARTRECORDER_PROMISE_EVENT, 4098 // stopCameraOutput 4099 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4100 // releaseRecorderPromise 4101 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4102 // end 4103 END_EVENT 4104 ); 4105 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4106 4107 // avVideoRecorderTestBase.resume2StartPromise(avConfig, avRecorder, recorderTime, done); 4108 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0400 end') 4109 }) 4110 4111 /* * 4112 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0500 4113 * @tc.name : 05. stop->start 4114 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.start 4115 * @tc.size : MediumTest 4116 * @tc.type : Function 4117 * @tc.level : Level 2 4118 */ 4119 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0500', 0, async function (done) { 4120 if (!isSupportCameraVideoProfiles) { 4121 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4122 expect(true).assertTrue(); 4123 done(); 4124 } 4125 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0500 start') 4126 let fileName = avVideoRecorderTestBase.resourceName() 4127 fdObject = await mediaTestBase.getFd(fileName); 4128 fdPath = "fd://" + fdObject.fdNumber; 4129 avConfig.url = fdPath; 4130 let mySteps = new Array( 4131 // setAvRecorderCallback 4132 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4133 // AVRecorderTestBase.preparePromise 4134 PREPARE_PROMISE_EVENT, 4135 // getInputSurfacePromise 4136 GETINPUTSURFACE_PROMISE_EVENT, 4137 // initCamera 4138 INITCAMERA_EVENT, 4139 // startRecordingProcessPromise 4140 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4141 // AVRecorderTestBase.stopPromise 4142 STOPRECORDER_PROMISE_EVENT, 4143 //? startErrPromise 4144 STARTRECORDER_PROMISE_EVENT, 4145 // stopCameraOutput 4146 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4147 // releaseRecorderPromise 4148 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4149 // end 4150 END_EVENT 4151 ); 4152 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4153 4154 // avVideoRecorderTestBase.stop2StartPromise(avConfig, avRecorder, recorderTime, done); 4155 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0500 end') 4156 }) 4157 4158 /* * 4159 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0600 4160 * @tc.name : 06. reset->start 4161 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.start 4162 * @tc.size : MediumTest 4163 * @tc.type : Function 4164 * @tc.level : Level 2 4165 */ 4166 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0600', 0, async function (done) { 4167 if (!isSupportCameraVideoProfiles) { 4168 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4169 expect(true).assertTrue(); 4170 done(); 4171 } 4172 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0600 start') 4173 let fileName = avVideoRecorderTestBase.resourceName() 4174 fdObject = await mediaTestBase.getFd(fileName); 4175 fdPath = "fd://" + fdObject.fdNumber; 4176 avConfig.url = fdPath; 4177 let mySteps = new Array( 4178 // setAvRecorderCallback 4179 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4180 // AVRecorderTestBase.preparePromise 4181 PREPARE_PROMISE_EVENT, 4182 // getInputSurfacePromise 4183 GETINPUTSURFACE_PROMISE_EVENT, 4184 // initCamera 4185 INITCAMERA_EVENT, 4186 // startRecordingProcessPromise 4187 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4188 // AVRecorderTestBase.resetPromise 4189 RESETRECORDER_PROMISE_EVENT, 4190 //? startErrPromise 4191 STARTRECORDER_PROMISE_EVENT, 4192 // stopCameraOutput 4193 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4194 // releaseRecorderPromise 4195 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4196 // end 4197 END_EVENT 4198 ); 4199 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4200 4201 // avVideoRecorderTestBase.reset2StartPromise(avConfig, avRecorder, recorderTime, done); 4202 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0600 end') 4203 }) 4204 4205 /* * 4206 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0700 4207 * @tc.name : 07. getInputSurface->start 4208 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 4209 * @tc.size : MediumTest 4210 * @tc.type : Function 4211 * @tc.level : Level 2 4212 */ 4213 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0700', 0, async function (done) { 4214 if (!isSupportCameraVideoProfiles) { 4215 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4216 expect(true).assertTrue(); 4217 done(); 4218 } 4219 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0700 start') 4220 let fileName = avVideoRecorderTestBase.resourceName() 4221 fdObject = await mediaTestBase.getFd(fileName); 4222 fdPath = "fd://" + fdObject.fdNumber; 4223 avConfig.url = fdPath; 4224 let mySteps = new Array( 4225 // setAvRecorderCallback 4226 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4227 // AVRecorderTestBase.preparePromise 4228 PREPARE_PROMISE_EVENT, 4229 // getInputSurfacePromise 4230 GETINPUTSURFACE_PROMISE_EVENT, 4231 // initCamera 4232 INITCAMERA_EVENT, 4233 // startRecordingProcessPromise 4234 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4235 // releaseRecorderPromise 4236 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4237 // end 4238 END_EVENT 4239 ); 4240 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4241 4242 // avVideoRecorderTestBase.getInputSurface2StartPromise(avConfig, avRecorder, recorderTime, done); 4243 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0700 end') 4244 }) 4245 4246 /* * 4247 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0800 4248 * @tc.name : 08. start 3 times 4249 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.start 6.start 4250 * @tc.size : MediumTest 4251 * @tc.type : Function 4252 * @tc.level : Level 2 4253 */ 4254 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0800', 0, async function (done) { 4255 if (!isSupportCameraVideoProfiles) { 4256 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4257 expect(true).assertTrue(); 4258 done(); 4259 } 4260 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0800 start') 4261 let fileName = avVideoRecorderTestBase.resourceName() 4262 fdObject = await mediaTestBase.getFd(fileName); 4263 fdPath = "fd://" + fdObject.fdNumber; 4264 avConfig.url = fdPath; 4265 let loopTimes = 3; 4266 let mySteps = new Array( 4267 // setAvRecorderCallback 4268 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4269 // AVRecorderTestBase.preparePromise 4270 PREPARE_PROMISE_EVENT, 4271 // getInputSurfacePromise 4272 GETINPUTSURFACE_PROMISE_EVENT, 4273 // initCamera 4274 INITCAMERA_EVENT 4275 ); 4276 for (let i = 0; i < loopTimes; i++) 4277 { 4278 mySteps.push( 4279 // startRecordingProcessPromise 4280 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4281 // AVRecorderTestBase.resetPromise 4282 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 4283 // AVRecorderTestBase.preparePromise 4284 PREPARE_PROMISE_EVENT, 4285 ) 4286 } 4287 mySteps.push( 4288 // releaseRecorderPromise 4289 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4290 // end 4291 END_EVENT 4292 ) 4293 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4294 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_PROMISE_0800 end') 4295 }) 4296 4297 // Promise pause 4298 /* * 4299 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0100 4300 * @tc.name : 01. create->pause 4301 * @tc.desc : 1.create 2.pause 4302 * @tc.size : MediumTest 4303 * @tc.type : Function 4304 * @tc.level : Level 2 4305 */ 4306 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0100', 0, async function (done) { 4307 if (!isSupportCameraVideoProfiles) { 4308 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4309 expect(true).assertTrue(); 4310 done(); 4311 } 4312 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0100 start') 4313 let fileName = avVideoRecorderTestBase.resourceName() 4314 fdObject = await mediaTestBase.getFd(fileName); 4315 fdPath = "fd://" + fdObject.fdNumber; 4316 avConfig.url = fdPath; 4317 let mySteps = new Array( 4318 // setAvRecorderCallback 4319 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4320 //? pauseErrPromise 4321 PAUSERECORDER_PROMISE_EVENT, 4322 // AVRecorderTestBase.releasePromise 4323 RELEASECORDER_PROMISE_EVENT, 4324 // end 4325 END_EVENT 4326 ); 4327 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4328 4329 // avVideoRecorderTestBase.create2PausePromise(avConfig, avRecorder, done); 4330 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0100 end') 4331 }) 4332 4333 /* * 4334 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0200 4335 * @tc.name : 02. prepare->pause 4336 * @tc.desc : 1.create 2.prepare 3.pause 4337 * @tc.size : MediumTest 4338 * @tc.type : Function 4339 * @tc.level : Level 2 4340 */ 4341 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0200', 0, async function (done) { 4342 if (!isSupportCameraVideoProfiles) { 4343 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4344 expect(true).assertTrue(); 4345 done(); 4346 } 4347 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0200 start') 4348 let fileName = avVideoRecorderTestBase.resourceName() 4349 fdObject = await mediaTestBase.getFd(fileName); 4350 fdPath = "fd://" + fdObject.fdNumber; 4351 avConfig.url = fdPath; 4352 let mySteps = new Array( 4353 // setAvRecorderCallback 4354 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4355 // AVRecorderTestBase.preparePromise 4356 PREPARE_PROMISE_EVENT, 4357 //? pauseErrPromise 4358 PAUSERECORDER_PROMISE_EVENT, 4359 // AVRecorderTestBase.releasePromise 4360 RELEASECORDER_PROMISE_EVENT, 4361 // end 4362 END_EVENT 4363 ); 4364 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4365 4366 // avVideoRecorderTestBase.prepare2PausePromise(avConfig, avRecorder, done); 4367 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0200 end') 4368 }) 4369 4370 /* * 4371 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0300 4372 * @tc.name : 03. start->pause 4373 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 4374 * @tc.size : MediumTest 4375 * @tc.type : Function 4376 * @tc.level : Level 2 4377 */ 4378 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0300', 0, async function (done) { 4379 if (!isSupportCameraVideoProfiles) { 4380 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4381 expect(true).assertTrue(); 4382 done(); 4383 } 4384 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0300 start') 4385 let fileName = avVideoRecorderTestBase.resourceName() 4386 fdObject = await mediaTestBase.getFd(fileName); 4387 fdPath = "fd://" + fdObject.fdNumber; 4388 avConfig.url = fdPath; 4389 let mySteps = new Array( 4390 // setAvRecorderCallback 4391 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4392 // AVRecorderTestBase.preparePromise 4393 PREPARE_PROMISE_EVENT, 4394 // getInputSurfacePromise 4395 GETINPUTSURFACE_PROMISE_EVENT, 4396 // initCamera 4397 INITCAMERA_EVENT, 4398 // startRecordingProcessPromise 4399 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4400 // pauseRecordingProcessPromise 4401 PAUSERECORDER_PROMISE_EVENT, STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4402 // releaseRecorderPromise 4403 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4404 // end 4405 END_EVENT 4406 ); 4407 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4408 4409 // avVideoRecorderTestBase.start2PausePromise(avConfig, avRecorder, recorderTime, done); 4410 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0300 end') 4411 }) 4412 4413 /* * 4414 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0400 4415 * @tc.name : 04. resume->pause 4416 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.pause 4417 * @tc.size : MediumTest 4418 * @tc.type : Function 4419 * @tc.level : Level 2 4420 */ 4421 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0400', 0, async function (done) { 4422 if (!isSupportCameraVideoProfiles) { 4423 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4424 expect(true).assertTrue(); 4425 done(); 4426 } 4427 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0400 start') 4428 let fileName = avVideoRecorderTestBase.resourceName() 4429 fdObject = await mediaTestBase.getFd(fileName); 4430 fdPath = "fd://" + fdObject.fdNumber; 4431 avConfig.url = fdPath; 4432 let mySteps = new Array( 4433 // setAvRecorderCallback 4434 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4435 // AVRecorderTestBase.preparePromise 4436 PREPARE_PROMISE_EVENT, 4437 // getInputSurfacePromise 4438 GETINPUTSURFACE_PROMISE_EVENT, 4439 // initCamera 4440 INITCAMERA_EVENT, 4441 // startRecordingProcessPromise 4442 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4443 // pauseRecordingProcessPromise 4444 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4445 //? resumeRecordingProcessPromise 4446 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 4447 // pauseRecordingProcessPromise 4448 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4449 // releaseRecorderPromise 4450 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4451 // end 4452 END_EVENT 4453 ); 4454 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4455 4456 // avVideoRecorderTestBase.resume2PausePromise(avConfig, avRecorder, recorderTime, done); 4457 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0400 end') 4458 }) 4459 4460 /* * 4461 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0500 4462 * @tc.name : 05. stop->pause 4463 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.pause 4464 * @tc.size : MediumTest 4465 * @tc.type : Function 4466 * @tc.level : Level 2 4467 */ 4468 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0500', 0, async function (done) { 4469 if (!isSupportCameraVideoProfiles) { 4470 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4471 expect(true).assertTrue(); 4472 done(); 4473 } 4474 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0500 start') 4475 let fileName = avVideoRecorderTestBase.resourceName() 4476 fdObject = await mediaTestBase.getFd(fileName); 4477 fdPath = "fd://" + fdObject.fdNumber; 4478 avConfig.url = fdPath; 4479 let mySteps = new Array( 4480 // setAvRecorderCallback 4481 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4482 // AVRecorderTestBase.preparePromise 4483 PREPARE_PROMISE_EVENT, 4484 // getInputSurfacePromise 4485 GETINPUTSURFACE_PROMISE_EVENT, 4486 // initCamera 4487 INITCAMERA_EVENT, 4488 // startRecordingProcessPromise 4489 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4490 // AVRecorderTestBase.stopPromise 4491 STOPRECORDER_PROMISE_EVENT, 4492 //? pauseErrPromise 4493 PAUSERECORDER_PROMISE_EVENT, 4494 // stopCameraOutput 4495 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4496 // releaseRecorderPromise 4497 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4498 // end 4499 END_EVENT 4500 ); 4501 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4502 4503 // avVideoRecorderTestBase.stop2PausePromise(avConfig, avRecorder, recorderTime, done); 4504 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0500 end') 4505 }) 4506 4507 /* * 4508 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0600 4509 * @tc.name : 06. reset->pause 4510 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.pause 4511 * @tc.size : MediumTest 4512 * @tc.type : Function 4513 * @tc.level : Level 2 4514 */ 4515 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0600', 0, async function (done) { 4516 if (!isSupportCameraVideoProfiles) { 4517 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4518 expect(true).assertTrue(); 4519 done(); 4520 } 4521 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0600 start') 4522 let fileName = avVideoRecorderTestBase.resourceName() 4523 fdObject = await mediaTestBase.getFd(fileName); 4524 fdPath = "fd://" + fdObject.fdNumber; 4525 avConfig.url = fdPath; 4526 let mySteps = new Array( 4527 // setAvRecorderCallback 4528 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4529 // AVRecorderTestBase.preparePromise 4530 PREPARE_PROMISE_EVENT, 4531 // getInputSurfacePromise 4532 GETINPUTSURFACE_PROMISE_EVENT, 4533 // initCamera 4534 INITCAMERA_EVENT, 4535 // startRecordingProcessPromise 4536 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4537 // AVRecorderTestBase.resetPromise 4538 RESETRECORDER_PROMISE_EVENT, 4539 //? pauseErrPromise 4540 PAUSERECORDER_PROMISE_EVENT, 4541 // stopCameraOutput 4542 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4543 // releaseRecorderPromise 4544 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4545 // end 4546 END_EVENT 4547 ); 4548 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4549 4550 // avVideoRecorderTestBase.reset2PausePromise(avConfig, avRecorder, recorderTime, done); 4551 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0600 end') 4552 }) 4553 4554 /* * 4555 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0700 4556 * @tc.name : 07. getInputSurface->pause 4557 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.pause 4558 * @tc.size : MediumTest 4559 * @tc.type : Function 4560 * @tc.level : Level 2 4561 */ 4562 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0700', 0, async function (done) { 4563 if (!isSupportCameraVideoProfiles) { 4564 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4565 expect(true).assertTrue(); 4566 done(); 4567 } 4568 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0700 start') 4569 let fileName = avVideoRecorderTestBase.resourceName() 4570 fdObject = await mediaTestBase.getFd(fileName); 4571 fdPath = "fd://" + fdObject.fdNumber; 4572 avConfig.url = fdPath; 4573 let mySteps = new Array( 4574 // setAvRecorderCallback 4575 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4576 // AVRecorderTestBase.preparePromise 4577 PREPARE_PROMISE_EVENT, 4578 // getInputSurfacePromise 4579 GETINPUTSURFACE_PROMISE_EVENT, 4580 // initCamera 4581 INITCAMERA_EVENT, 4582 //? pauseErrPromise 4583 PAUSERECORDER_PROMISE_EVENT, 4584 // releaseRecorderPromise 4585 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4586 // end 4587 END_EVENT 4588 ); 4589 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4590 4591 // avVideoRecorderTestBase.getInputSurface2PausePromise(avConfig, avRecorder, done); 4592 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0700 end') 4593 }) 4594 4595 /* * 4596 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0800 4597 * @tc.name : 08. pause 3 times 4598 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.pause 7.pause 4599 * @tc.size : MediumTest 4600 * @tc.type : Function 4601 * @tc.level : Level 2 4602 */ 4603 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0800', 0, async function (done) { 4604 if (!isSupportCameraVideoProfiles) { 4605 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4606 expect(true).assertTrue(); 4607 done(); 4608 } 4609 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0800 start') 4610 let fileName = avVideoRecorderTestBase.resourceName() 4611 fdObject = await mediaTestBase.getFd(fileName); 4612 fdPath = "fd://" + fdObject.fdNumber; 4613 avConfig.url = fdPath; 4614 let loopTimes = 3; 4615 let mySteps = new Array( 4616 // setAvRecorderCallback 4617 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4618 // AVRecorderTestBase.preparePromise 4619 PREPARE_PROMISE_EVENT, 4620 // getInputSurfacePromise 4621 GETINPUTSURFACE_PROMISE_EVENT, 4622 // initCamera 4623 INITCAMERA_EVENT, 4624 // startRecordingProcessPromise 4625 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT 4626 ); 4627 for (let i = 0; i < loopTimes; i++) 4628 { 4629 mySteps.push( 4630 // pauseRecordingProcessPromise 4631 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4632 //? resumeRecordingProcessPromise 4633 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT 4634 ) 4635 } 4636 mySteps.push( 4637 // releaseRecorderPromise 4638 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4639 // end 4640 END_EVENT 4641 ) 4642 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4643 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_PROMISE_0800 end') 4644 }) 4645 4646 // 状态切换 4647 // 01.promise回调方式 4648 /* * 4649 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0100 4650 * @tc.name : 01.AVRecorder test recording 3 seconds 4651 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.release 4652 * @tc.size : MediumTest 4653 * @tc.type : Function 4654 * @tc.level : Level 2 4655 */ 4656 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0100', 0, async function (done) { 4657 if (!isSupportCameraVideoProfiles) { 4658 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4659 expect(true).assertTrue(); 4660 done(); 4661 } 4662 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0100 start') 4663 let fileName = avVideoRecorderTestBase.resourceName() 4664 fdObject = await mediaTestBase.getFd(fileName); 4665 fdPath = "fd://" + fdObject.fdNumber; 4666 avConfig.url = fdPath; 4667 let mySteps = new Array( 4668 // setAvRecorderCallback 4669 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4670 // AVRecorderTestBase.preparePromise 4671 PREPARE_PROMISE_EVENT, 4672 // getInputSurfacePromise 4673 GETINPUTSURFACE_PROMISE_EVENT, 4674 // initCamera 4675 INITCAMERA_EVENT, 4676 // startRecordingProcessPromise 4677 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4678 // releaseRecorderPromise 4679 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4680 // end 4681 END_EVENT 4682 ); 4683 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4684 4685 // avVideoRecorderTestBase.recordStart2ReleaseWithPromise(avConfig, avRecorder, recorderTime, done); 4686 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0100 end') 4687 }) 4688 4689 /* * 4690 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0200 4691 * @tc.name : 02.AVRecorder test recording 3 seconds to pause 4692 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.release 4693 * @tc.size : MediumTest 4694 * @tc.type : Function 4695 * @tc.level : Level 2 4696 */ 4697 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0200', 0, async function (done) { 4698 if (!isSupportCameraVideoProfiles) { 4699 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4700 expect(true).assertTrue(); 4701 done(); 4702 } 4703 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0200 start') 4704 let fileName = avVideoRecorderTestBase.resourceName() 4705 fdObject = await mediaTestBase.getFd(fileName); 4706 fdPath = "fd://" + fdObject.fdNumber; 4707 avConfig.url = fdPath; 4708 let mySteps = new Array( 4709 // setAvRecorderCallback 4710 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4711 // AVRecorderTestBase.preparePromise 4712 PREPARE_PROMISE_EVENT, 4713 // getInputSurfacePromise 4714 GETINPUTSURFACE_PROMISE_EVENT, 4715 // initCamera 4716 INITCAMERA_EVENT, 4717 // startRecordingProcessPromise 4718 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4719 // pauseRecordingProcessPromise 4720 PAUSERECORDER_PROMISE_EVENT, STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4721 // releaseRecorderPromise 4722 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4723 // end 4724 END_EVENT 4725 ); 4726 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4727 4728 // avVideoRecorderTestBase.recordStart2PauseWithPromise(avConfig, avRecorder, recorderTime, done); 4729 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0200 end') 4730 }) 4731 4732 /* * 4733 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0300 4734 * @tc.name : 03.AVRecorder test recording 3 seconds to pause to resume 4735 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.release 4736 * @tc.size : MediumTest 4737 * @tc.type : Function 4738 * @tc.level : Level 2 4739 */ 4740 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0300', 0, async function (done) { 4741 if (!isSupportCameraVideoProfiles) { 4742 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4743 expect(true).assertTrue(); 4744 done(); 4745 } 4746 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0300 start') 4747 let fileName = avVideoRecorderTestBase.resourceName() 4748 fdObject = await mediaTestBase.getFd(fileName); 4749 fdPath = "fd://" + fdObject.fdNumber; 4750 avConfig.url = fdPath; 4751 let mySteps = new Array( 4752 // setAvRecorderCallback 4753 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4754 // AVRecorderTestBase.preparePromise 4755 PREPARE_PROMISE_EVENT, 4756 // getInputSurfacePromise 4757 GETINPUTSURFACE_PROMISE_EVENT, 4758 // initCamera 4759 INITCAMERA_EVENT, 4760 // startRecordingProcessPromise 4761 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4762 // AVRecorderTestBase.pausePromise 4763 PAUSERECORDER_PROMISE_EVENT, 4764 //? AVRecorderTestBase.resumePromise 4765 RESUMERECORDER_PROMISE_EVENT, 4766 // stopCameraOutput 4767 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 4768 // releaseRecorderPromise 4769 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4770 // end 4771 END_EVENT 4772 ); 4773 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4774 4775 // avVideoRecorderTestBase.recordStart2ResumeWithPromise(avConfig, avRecorder, recorderTime, done); 4776 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0300 end') 4777 }) 4778 4779 /* * 4780 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0400 4781 * @tc.name : 04.AVRecorder test recording 3 seconds to stop 4782 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.stop 6.release 4783 * @tc.size : MediumTest 4784 * @tc.type : Function 4785 * @tc.level : Level 2 4786 */ 4787 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0400', 0, async function (done) { 4788 if (!isSupportCameraVideoProfiles) { 4789 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4790 expect(true).assertTrue(); 4791 done(); 4792 } 4793 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0400 start') 4794 let fileName = avVideoRecorderTestBase.resourceName() 4795 fdObject = await mediaTestBase.getFd(fileName); 4796 fdPath = "fd://" + fdObject.fdNumber; 4797 avConfig.url = fdPath; 4798 let mySteps = new Array( 4799 // setAvRecorderCallback 4800 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4801 // AVRecorderTestBase.preparePromise 4802 PREPARE_PROMISE_EVENT, 4803 // getInputSurfacePromise 4804 GETINPUTSURFACE_PROMISE_EVENT, 4805 // initCamera 4806 INITCAMERA_EVENT, 4807 // startRecordingProcessPromise 4808 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4809 // stopRecordingProcessPromise 4810 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4811 // releaseRecorderPromise 4812 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4813 // end 4814 END_EVENT 4815 ); 4816 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4817 4818 // avVideoRecorderTestBase.recordStart2StopWithPromise(avConfig, avRecorder, recorderTime, done); 4819 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0400 end') 4820 }) 4821 4822 /* * 4823 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0500 4824 * @tc.name : 05.AVRecorder test recording 3 seconds to reset 4825 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.reset 6.release 4826 * @tc.size : MediumTest 4827 * @tc.type : Function 4828 * @tc.level : Level 2 4829 */ 4830 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0500', 0, async function (done) { 4831 if (!isSupportCameraVideoProfiles) { 4832 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4833 expect(true).assertTrue(); 4834 done(); 4835 } 4836 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0500 start') 4837 let fileName = avVideoRecorderTestBase.resourceName() 4838 fdObject = await mediaTestBase.getFd(fileName); 4839 fdPath = "fd://" + fdObject.fdNumber; 4840 avConfig.url = fdPath; 4841 let mySteps = new Array( 4842 // setAvRecorderCallback 4843 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4844 // AVRecorderTestBase.preparePromise 4845 PREPARE_PROMISE_EVENT, 4846 // getInputSurfacePromise 4847 GETINPUTSURFACE_PROMISE_EVENT, 4848 // initCamera 4849 INITCAMERA_EVENT, 4850 // startRecordingProcessPromise 4851 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4852 // resetRecordingProcessPromise 4853 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4854 // releaseRecorderPromise 4855 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4856 // end 4857 END_EVENT 4858 ); 4859 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4860 4861 // avVideoRecorderTestBase.recordStart2ResetWithPromise(avConfig, avRecorder, recorderTime, done); 4862 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0500 end') 4863 }) 4864 4865 /* * 4866 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0600 4867 * @tc.name : 06.AVRecorder test stop recording after recording 3 seconds 4868 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.stop 7.release 4869 * @tc.size : MediumTest 4870 * @tc.type : Function 4871 * @tc.level : Level 2 4872 */ 4873 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0600', 0, async function (done) { 4874 if (!isSupportCameraVideoProfiles) { 4875 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4876 expect(true).assertTrue(); 4877 done(); 4878 } 4879 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0600 start') 4880 let fileName = avVideoRecorderTestBase.resourceName() 4881 fdObject = await mediaTestBase.getFd(fileName); 4882 fdPath = "fd://" + fdObject.fdNumber; 4883 avConfig.url = fdPath; 4884 let mySteps = new Array( 4885 // setAvRecorderCallback 4886 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4887 // AVRecorderTestBase.preparePromise 4888 PREPARE_PROMISE_EVENT, 4889 // getInputSurfacePromise 4890 GETINPUTSURFACE_PROMISE_EVENT, 4891 // initCamera 4892 INITCAMERA_EVENT, 4893 // startRecordingProcessPromise 4894 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4895 // AVRecorderTestBase.pausePromise 4896 PAUSERECORDER_PROMISE_EVENT, 4897 // stopRecordingProcessPromise 4898 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4899 // releaseRecorderPromise 4900 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4901 // end 4902 END_EVENT 4903 ); 4904 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4905 4906 // avVideoRecorderTestBase.recordStart2Pause2StopWithPromise(avConfig, avRecorder, recorderTime, done); 4907 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0600 end') 4908 }) 4909 4910 /* * 4911 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0700 4912 * @tc.name : 07.AVRecorder test reset recording after recording 3 seconds 4913 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.reset 7.release 4914 * @tc.size : MediumTest 4915 * @tc.type : Function 4916 * @tc.level : Level 2 4917 */ 4918 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0700', 0, async function (done) { 4919 if (!isSupportCameraVideoProfiles) { 4920 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4921 expect(true).assertTrue(); 4922 done(); 4923 } 4924 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0700 start') 4925 let fileName = avVideoRecorderTestBase.resourceName() 4926 fdObject = await mediaTestBase.getFd(fileName); 4927 fdPath = "fd://" + fdObject.fdNumber; 4928 avConfig.url = fdPath; 4929 let mySteps = new Array( 4930 // setAvRecorderCallback 4931 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4932 // AVRecorderTestBase.preparePromise 4933 PREPARE_PROMISE_EVENT, 4934 // getInputSurfacePromise 4935 GETINPUTSURFACE_PROMISE_EVENT, 4936 // initCamera 4937 INITCAMERA_EVENT, 4938 // startRecordingProcessPromise 4939 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4940 // AVRecorderTestBase.pausePromise 4941 PAUSERECORDER_PROMISE_EVENT, 4942 // resetRecordingProcessPromise 4943 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4944 // releaseRecorderPromise 4945 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4946 // end 4947 END_EVENT 4948 ); 4949 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4950 4951 // avVideoRecorderTestBase.recordStart2Pause2ResetWithPromise(avConfig, avRecorder, recorderTime, done); 4952 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0700 end') 4953 }) 4954 4955 /* * 4956 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0800 4957 * @tc.name : 08.AVRecorder test resume recording after pause and stop recording 4958 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.stop 8.release 4959 * @tc.size : MediumTest 4960 * @tc.type : Function 4961 * @tc.level : Level 2 4962 */ 4963 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0800', 0, async function (done) { 4964 if (!isSupportCameraVideoProfiles) { 4965 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 4966 expect(true).assertTrue(); 4967 done(); 4968 } 4969 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0800 start') 4970 let fileName = avVideoRecorderTestBase.resourceName() 4971 fdObject = await mediaTestBase.getFd(fileName); 4972 fdPath = "fd://" + fdObject.fdNumber; 4973 avConfig.url = fdPath; 4974 let mySteps = new Array( 4975 // setAvRecorderCallback 4976 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 4977 // AVRecorderTestBase.preparePromise 4978 PREPARE_PROMISE_EVENT, 4979 // getInputSurfacePromise 4980 GETINPUTSURFACE_PROMISE_EVENT, 4981 // initCamera 4982 INITCAMERA_EVENT, 4983 // startRecordingProcessPromise 4984 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 4985 // AVRecorderTestBase.pausePromise 4986 PAUSERECORDER_PROMISE_EVENT, 4987 //? AVRecorderTestBase.resumePromise 4988 RESUMERECORDER_PROMISE_EVENT, 4989 // stopRecordingProcessPromise 4990 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 4991 // releaseRecorderPromise 4992 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 4993 // end 4994 END_EVENT 4995 ); 4996 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 4997 4998 // avVideoRecorderTestBase.recordStart2Resume2WithPromise(avConfig, avRecorder, recorderTime, done); 4999 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0800 end') 5000 }) 5001 5002 /* * 5003 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0900 5004 * @tc.name : 09.AVRecorder test resume recording after pause and reset recording 5005 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.reset 8.release 5006 * @tc.size : MediumTest 5007 * @tc.type : Function 5008 * @tc.level : Level 2 5009 */ 5010 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0900', 0, async function (done) { 5011 if (!isSupportCameraVideoProfiles) { 5012 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5013 expect(true).assertTrue(); 5014 done(); 5015 } 5016 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0900 start') 5017 let fileName = avVideoRecorderTestBase.resourceName() 5018 fdObject = await mediaTestBase.getFd(fileName); 5019 fdPath = "fd://" + fdObject.fdNumber; 5020 avConfig.url = fdPath; 5021 let mySteps = new Array( 5022 // setAvRecorderCallback 5023 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5024 // AVRecorderTestBase.preparePromise 5025 PREPARE_PROMISE_EVENT, 5026 // getInputSurfacePromise 5027 GETINPUTSURFACE_PROMISE_EVENT, 5028 // initCamera 5029 INITCAMERA_EVENT, 5030 // startRecordingProcessPromise 5031 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5032 // AVRecorderTestBase.pausePromise 5033 PAUSERECORDER_PROMISE_EVENT, 5034 //? AVRecorderTestBase.resumePromise 5035 RESUMERECORDER_PROMISE_EVENT, 5036 // resetRecordingProcessPromise 5037 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 5038 // releaseRecorderPromise 5039 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5040 // end 5041 END_EVENT 5042 ); 5043 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5044 5045 // avVideoRecorderTestBase.recordStart2reset2WithPromise(avConfig, avRecorder, recorderTime, done); 5046 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_0900 end') 5047 }) 5048 5049 /* * 5050 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1000 5051 * @tc.name : 10.AVRecorder test recording 3 seconds (only video) 5052 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.release 5053 * @tc.size : MediumTest 5054 * @tc.type : Function 5055 * @tc.level : Level 2 5056 */ 5057 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1000', 0, async function (done) { 5058 if (!isSupportCameraVideoProfiles) { 5059 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5060 expect(true).assertTrue(); 5061 done(); 5062 } 5063 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1000 start') 5064 let avNewProfile = { 5065 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 5066 videoBitrate : 280000, // 视频比特率 5067 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 5068 videoFrameWidth : 640, // 视频分辨率的宽 5069 videoFrameHeight : 480, // 视频分辨率的高 5070 videoFrameRate : 30 // 视频帧率 5071 } 5072 let avNewConfig = { 5073 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 5074 profile : avNewProfile, 5075 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 5076 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 5077 location : { latitude : 30, longitude : 130 } 5078 } 5079 let fileName = avVideoRecorderTestBase.resourceName() 5080 fdObject = await mediaTestBase.getFd(fileName); 5081 fdPath = "fd://" + fdObject.fdNumber; 5082 avNewConfig.url = fdPath; 5083 checkDevice(avNewConfig) 5084 let mySteps = new Array( 5085 // setAvRecorderCallback 5086 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5087 // AVRecorderTestBase.preparePromise 5088 PREPARE_PROMISE_EVENT, 5089 // getInputSurfacePromise 5090 GETINPUTSURFACE_PROMISE_EVENT, 5091 // initCamera 5092 INITCAMERA_EVENT, 5093 // startRecordingProcessPromise 5094 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5095 // stop camera 5096 STOPCAMERA_EVENT, 5097 // releaseRecorderPromise 5098 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5099 // end 5100 END_EVENT 5101 ); 5102 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 5103 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1000 end') 5104 }) 5105 5106 /* * 5107 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1100 5108 * @tc.name : 11.AVRecorder test recording 3 seconds to pause (only video) 5109 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.release 5110 * @tc.size : MediumTest 5111 * @tc.type : Function 5112 * @tc.level : Level 2 5113 */ 5114 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1100', 0, async function (done) { 5115 if (!isSupportCameraVideoProfiles) { 5116 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5117 expect(true).assertTrue(); 5118 done(); 5119 } 5120 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1100 start') 5121 let avNewProfile = { 5122 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 5123 videoBitrate : 280000, // 视频比特率 5124 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 5125 videoFrameWidth : 640, // 视频分辨率的宽 5126 videoFrameHeight : 480, // 视频分辨率的高 5127 videoFrameRate : 30 // 视频帧率 5128 } 5129 let avNewConfig = { 5130 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 5131 profile : avNewProfile, 5132 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 5133 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 5134 location : { latitude : 30, longitude : 130 } 5135 } 5136 let fileName = avVideoRecorderTestBase.resourceName() 5137 fdObject = await mediaTestBase.getFd(fileName); 5138 fdPath = "fd://" + fdObject.fdNumber; 5139 avNewConfig.url = fdPath; 5140 checkDevice(avNewConfig) 5141 let mySteps = new Array( 5142 // setAvRecorderCallback 5143 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5144 // AVRecorderTestBase.preparePromise 5145 PREPARE_PROMISE_EVENT, 5146 // getInputSurfacePromise 5147 GETINPUTSURFACE_PROMISE_EVENT, 5148 // initCamera 5149 INITCAMERA_EVENT, 5150 // startRecordingProcessPromise 5151 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5152 // pauseRecordingProcessPromise 5153 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 5154 // releaseRecorderPromise 5155 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5156 // end 5157 END_EVENT 5158 ); 5159 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 5160 5161 // avVideoRecorderTestBase.recordStart2PauseWithPromise(avConfig, avRecorder, recorderTime, done); 5162 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1100 end') 5163 }) 5164 5165 /* * 5166 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1200 5167 * @tc.name : 12.AVRecorder test recording 3 seconds to pause to resume (only video) 5168 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.release 5169 * @tc.size : MediumTest 5170 * @tc.type : Function 5171 * @tc.level : Level 2 5172 */ 5173 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1200', 0, async function (done) { 5174 if (!isSupportCameraVideoProfiles) { 5175 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5176 expect(true).assertTrue(); 5177 done(); 5178 } 5179 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1200 start') 5180 let avNewProfile = { 5181 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 5182 videoBitrate : 280000, // 视频比特率 5183 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 5184 videoFrameWidth : 640, // 视频分辨率的宽 5185 videoFrameHeight : 480, // 视频分辨率的高 5186 videoFrameRate : 30 // 视频帧率 5187 } 5188 let avNewConfig = { 5189 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 5190 profile : avNewProfile, 5191 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 5192 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 5193 location : { latitude : 30, longitude : 130 } 5194 } 5195 let fileName = avVideoRecorderTestBase.resourceName() 5196 fdObject = await mediaTestBase.getFd(fileName); 5197 fdPath = "fd://" + fdObject.fdNumber; 5198 avNewConfig.url = fdPath; 5199 checkDevice(avNewConfig) 5200 let mySteps = new Array( 5201 // setAvRecorderCallback 5202 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5203 // AVRecorderTestBase.preparePromise 5204 PREPARE_PROMISE_EVENT, 5205 // getInputSurfacePromise 5206 GETINPUTSURFACE_PROMISE_EVENT, 5207 // initCamera 5208 INITCAMERA_EVENT, 5209 // startRecordingProcessPromise 5210 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5211 // AVRecorderTestBase.pausePromise 5212 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 5213 //? AVRecorderTestBase.resumePromise 5214 RESUMERECORDER_PROMISE_EVENT, 5215 // stopCameraOutput 5216 STOPRECORDER_CALLBACK_EVENT, 5217 // releaseRecorderPromise 5218 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5219 // end 5220 END_EVENT 5221 ); 5222 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 5223 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1200 end') 5224 }) 5225 5226 /* * 5227 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1300 5228 * @tc.name : 13.AVRecorder test recording 3 seconds to stop (only video) 5229 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.stop 6.release 5230 * @tc.size : MediumTest 5231 * @tc.type : Function 5232 * @tc.level : Level 2 5233 */ 5234 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1300', 0, async function (done) { 5235 if (!isSupportCameraVideoProfiles) { 5236 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5237 expect(true).assertTrue(); 5238 done(); 5239 } 5240 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1300 start') 5241 let avNewProfile = { 5242 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 5243 videoBitrate : 280000, // 视频比特率 5244 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 5245 videoFrameWidth : 640, // 视频分辨率的宽 5246 videoFrameHeight : 480, // 视频分辨率的高 5247 videoFrameRate : 30 // 视频帧率 5248 } 5249 let avNewConfig = { 5250 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 5251 profile : avNewProfile, 5252 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 5253 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 5254 location : { latitude : 30, longitude : 130 } 5255 } 5256 let fileName = avVideoRecorderTestBase.resourceName() 5257 fdObject = await mediaTestBase.getFd(fileName); 5258 fdPath = "fd://" + fdObject.fdNumber; 5259 avNewConfig.url = fdPath; 5260 checkDevice(avNewConfig) 5261 let mySteps = new Array( 5262 // setAvRecorderCallback 5263 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5264 // AVRecorderTestBase.preparePromise 5265 PREPARE_PROMISE_EVENT, 5266 // getInputSurfacePromise 5267 GETINPUTSURFACE_PROMISE_EVENT, 5268 // initCamera 5269 INITCAMERA_EVENT, 5270 // startRecordingProcessPromise 5271 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5272 // stopRecordingProcessPromise 5273 STOPRECORDER_PROMISE_EVENT,STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 5274 // releaseRecorderPromise 5275 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5276 // end 5277 END_EVENT 5278 ); 5279 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 5280 5281 // avVideoRecorderTestBase.recordStart2StopWithPromise(avConfig, avRecorder, recorderTime, done); 5282 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1300 end') 5283 }) 5284 5285 /* * 5286 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1400 5287 * @tc.name : 14.AVRecorder test recording 3 seconds to reset (only video) 5288 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.reset 6.release 5289 * @tc.size : MediumTest 5290 * @tc.type : Function 5291 * @tc.level : Level 2 5292 */ 5293 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1400', 0, async function (done) { 5294 if (!isSupportCameraVideoProfiles) { 5295 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5296 expect(true).assertTrue(); 5297 done(); 5298 } 5299 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1400 start') 5300 let avNewProfile = { 5301 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 5302 videoBitrate : 280000, // 视频比特率 5303 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 5304 videoFrameWidth : 640, // 视频分辨率的宽 5305 videoFrameHeight : 480, // 视频分辨率的高 5306 videoFrameRate : 30 // 视频帧率 5307 } 5308 let avNewConfig = { 5309 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, // 视频源类型，支持YUV和ES两种格式 5310 profile : avNewProfile, 5311 url : 'fd://35', // 参考应用文件访问与管理开发示例新建并读写一个文件 5312 rotation : 0, // 视频旋转角度，默认为0不旋转，支持的值为0、90、180、270 5313 location : { latitude : 30, longitude : 130 } 5314 } 5315 let fileName = avVideoRecorderTestBase.resourceName() 5316 fdObject = await mediaTestBase.getFd(fileName); 5317 fdPath = "fd://" + fdObject.fdNumber; 5318 avNewConfig.url = fdPath; 5319 checkDevice(avNewConfig) 5320 let mySteps = new Array( 5321 // setAvRecorderCallback 5322 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 5323 // AVRecorderTestBase.preparePromise 5324 PREPARE_PROMISE_EVENT, 5325 // getInputSurfacePromise 5326 GETINPUTSURFACE_PROMISE_EVENT, 5327 // initCamera 5328 INITCAMERA_EVENT, 5329 // startRecordingProcessPromise 5330 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 5331 // resetRecordingProcessPromise 5332 RESETRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, STOPRECORDER_CALLBACK_EVENT, 5333 // releaseRecorderPromise 5334 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 5335 // end 5336 END_EVENT 5337 ); 5338 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 5339 5340 // avVideoRecorderTestBase.recordStart2ResetWithPromise(avConfig, avRecorder, recorderTime, done); 5341 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_1400 end') 5342 }) 5343 5344 // 02.callback回调 5345 /* * 5346 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0100 5347 * @tc.name : 01.AVRecorder test recording 3 seconds 5348 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.release 5349 * @tc.size : MediumTest 5350 * @tc.type : Function 5351 * @tc.level : Level 2 5352 */ 5353 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0100', 0, async function (done) { 5354 if (!isSupportCameraVideoProfiles) { 5355 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5356 expect(true).assertTrue(); 5357 done(); 5358 } 5359 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0100 start') 5360 let fileName = avVideoRecorderTestBase.resourceName() 5361 fdObject = await mediaTestBase.getFd(fileName); 5362 fdPath = "fd://" + fdObject.fdNumber; 5363 avConfig.url = fdPath; 5364 let mySteps = new Array( 5365 // init avRecorder 5366 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5367 // init camera 5368 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5369 // start avRecorder 5370 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5371 // stop camera 5372 STOPCAMERA_EVENT, 5373 // release avRecorder and camera 5374 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5375 // end 5376 END_EVENT 5377 ); 5378 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5379 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0100 end') 5380 }) 5381 5382 /* * 5383 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0200 5384 * @tc.name : 02.AVRecorder test recording 3 seconds to pause 5385 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.release 5386 * @tc.size : MediumTest 5387 * @tc.type : Function 5388 * @tc.level : Level 2 5389 */ 5390 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0200', 0, async function (done) { 5391 if (!isSupportCameraVideoProfiles) { 5392 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5393 expect(true).assertTrue(); 5394 done(); 5395 } 5396 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0200 start') 5397 let fileName = avVideoRecorderTestBase.resourceName() 5398 fdObject = await mediaTestBase.getFd(fileName); 5399 fdPath = "fd://" + fdObject.fdNumber; 5400 avConfig.url = fdPath; 5401 let mySteps = new Array( 5402 // init avRecorder 5403 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5404 // init camera 5405 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5406 // start avRecorder 5407 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5408 // pause avRecorder 5409 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5410 // release avRecorder and camera 5411 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5412 // end 5413 END_EVENT 5414 ); 5415 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5416 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0200 end') 5417 }) 5418 5419 /* * 5420 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0300 5421 * @tc.name : 03.AVRecorder test recording 3 seconds to pause to resume 5422 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.release 5423 * @tc.size : MediumTest 5424 * @tc.type : Function 5425 * @tc.level : Level 2 5426 */ 5427 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0300', 0, async function (done) { 5428 if (!isSupportCameraVideoProfiles) { 5429 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5430 expect(true).assertTrue(); 5431 done(); 5432 } 5433 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0300 start') 5434 let fileName = avVideoRecorderTestBase.resourceName() 5435 fdObject = await mediaTestBase.getFd(fileName); 5436 fdPath = "fd://" + fdObject.fdNumber; 5437 avConfig.url = fdPath; 5438 let mySteps = new Array( 5439 // init avRecorder 5440 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5441 // init camera 5442 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5443 // start avRecorder 5444 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5445 // pause avRecorder 5446 PAUSERECORDER_CALLBACK_EVENT, 5447 // resume avRecorder 5448 RESUMERECORDER_CALLBACK_EVENT, 5449 // stop camera 5450 STOPCAMERA_EVENT, 5451 // release avRecorder and camera 5452 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5453 // end 5454 END_EVENT 5455 ); 5456 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5457 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0300 end') 5458 }) 5459 5460 /* * 5461 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0400 5462 * @tc.name : 04.AVRecorder test recording 3 seconds to stop 5463 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.stop 6.release 5464 * @tc.size : MediumTest 5465 * @tc.type : Function 5466 * @tc.level : Level 2 5467 */ 5468 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0400', 0, async function (done) { 5469 if (!isSupportCameraVideoProfiles) { 5470 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5471 expect(true).assertTrue(); 5472 done(); 5473 } 5474 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0400 start') 5475 let fileName = avVideoRecorderTestBase.resourceName() 5476 fdObject = await mediaTestBase.getFd(fileName); 5477 fdPath = "fd://" + fdObject.fdNumber; 5478 avConfig.url = fdPath; 5479 let mySteps = new Array( 5480 // init avRecorder 5481 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5482 // init camera 5483 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5484 // start avRecorder 5485 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5486 // stop avRecorder 5487 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5488 // release avRecorder and camera 5489 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5490 // end 5491 END_EVENT 5492 ); 5493 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5494 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0400 end') 5495 }) 5496 5497 /* * 5498 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0500 5499 * @tc.name : 05.AVRecorder test recording 3 seconds to reset 5500 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.reset 6.release 5501 * @tc.size : MediumTest 5502 * @tc.type : Function 5503 * @tc.level : Level 2 5504 */ 5505 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0500', 0, async function (done) { 5506 if (!isSupportCameraVideoProfiles) { 5507 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5508 expect(true).assertTrue(); 5509 done(); 5510 } 5511 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0500 start') 5512 let fileName = avVideoRecorderTestBase.resourceName() 5513 fdObject = await mediaTestBase.getFd(fileName); 5514 fdPath = "fd://" + fdObject.fdNumber; 5515 avConfig.url = fdPath; 5516 let mySteps = new Array( 5517 // init avRecorder 5518 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5519 // init camera 5520 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5521 // start avRecorder 5522 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5523 // reset avRecorder 5524 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5525 // release avRecorder and camera 5526 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5527 // end 5528 END_EVENT 5529 ); 5530 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5531 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0500 end') 5532 }) 5533 5534 /* * 5535 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0600 5536 * @tc.name : 06.AVRecorder test stop recording after recording 3 seconds 5537 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.stop 7.release 5538 * @tc.size : MediumTest 5539 * @tc.type : Function 5540 * @tc.level : Level 2 5541 */ 5542 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0600', 0, async function (done) { 5543 if (!isSupportCameraVideoProfiles) { 5544 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5545 expect(true).assertTrue(); 5546 done(); 5547 } 5548 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0600 start') 5549 let fileName = avVideoRecorderTestBase.resourceName() 5550 fdObject = await mediaTestBase.getFd(fileName); 5551 fdPath = "fd://" + fdObject.fdNumber; 5552 avConfig.url = fdPath; 5553 let mySteps = new Array( 5554 // init avRecorder 5555 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5556 // init camera 5557 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5558 // start avRecorder 5559 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5560 // pause avRecorder 5561 PAUSERECORDER_CALLBACK_EVENT, 5562 // stop avRecorder 5563 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5564 // release avRecorder and camera 5565 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5566 // end 5567 END_EVENT 5568 ); 5569 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5570 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0600 end') 5571 }) 5572 5573 /* * 5574 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0700 5575 * @tc.name : 07.AVRecorder test reset recording after recording 3 seconds 5576 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.reset 7.release 5577 * @tc.size : MediumTest 5578 * @tc.type : Function 5579 * @tc.level : Level 2 5580 */ 5581 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0700', 0, async function (done) { 5582 if (!isSupportCameraVideoProfiles) { 5583 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5584 expect(true).assertTrue(); 5585 done(); 5586 } 5587 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0700 start') 5588 let fileName = avVideoRecorderTestBase.resourceName() 5589 fdObject = await mediaTestBase.getFd(fileName); 5590 fdPath = "fd://" + fdObject.fdNumber; 5591 avConfig.url = fdPath; 5592 let mySteps = new Array( 5593 // init avRecorder 5594 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5595 // init camera 5596 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5597 // start avRecorder 5598 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5599 // pause avRecorder 5600 PAUSERECORDER_CALLBACK_EVENT, 5601 // reset avRecorder 5602 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5603 // release avRecorder and camera 5604 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5605 // end 5606 END_EVENT 5607 ); 5608 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5609 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0700 end') 5610 }) 5611 5612 /* * 5613 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0800 5614 * @tc.name : 08.AVRecorder test resume recording after pause and stop recording 5615 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.stop 8.release 5616 * @tc.size : MediumTest 5617 * @tc.type : Function 5618 * @tc.level : Level 2 5619 */ 5620 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0800', 0, async function (done) { 5621 if (!isSupportCameraVideoProfiles) { 5622 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5623 expect(true).assertTrue(); 5624 done(); 5625 } 5626 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0800 start') 5627 let fileName = avVideoRecorderTestBase.resourceName() 5628 fdObject = await mediaTestBase.getFd(fileName); 5629 fdPath = "fd://" + fdObject.fdNumber; 5630 avConfig.url = fdPath; 5631 let mySteps = new Array( 5632 // init avRecorder 5633 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5634 // init camera 5635 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5636 // start avRecorder 5637 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5638 // pause avRecorder 5639 PAUSERECORDER_CALLBACK_EVENT, 5640 // resume avRecorder 5641 RESUMERECORDER_CALLBACK_EVENT, 5642 // stop avRecorder 5643 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5644 // release avRecorder and camera 5645 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5646 // end 5647 END_EVENT 5648 ); 5649 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5650 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0800 end') 5651 }) 5652 5653 /* * 5654 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0900 5655 * @tc.name : 09.AVRecorder test resume recording after pause and reset recording 5656 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.reset 8.release 5657 * @tc.size : MediumTest 5658 * @tc.type : Function 5659 * @tc.level : Level 2 5660 */ 5661 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0900', 0, async function (done) { 5662 if (!isSupportCameraVideoProfiles) { 5663 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5664 expect(true).assertTrue(); 5665 done(); 5666 } 5667 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0900 start') 5668 let fileName = avVideoRecorderTestBase.resourceName() 5669 fdObject = await mediaTestBase.getFd(fileName); 5670 fdPath = "fd://" + fdObject.fdNumber; 5671 avConfig.url = fdPath; 5672 let mySteps = new Array( 5673 // init avRecorder 5674 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5675 // init camera 5676 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5677 // start avRecorder 5678 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5679 // pause avRecorder 5680 PAUSERECORDER_CALLBACK_EVENT, 5681 // resume avRecorder 5682 RESUMERECORDER_CALLBACK_EVENT, 5683 // reset avRecorder 5684 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5685 // release avRecorder and camera 5686 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5687 // end 5688 END_EVENT 5689 ); 5690 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5691 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_0900 end') 5692 }) 5693 5694 /* * 5695 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1000 5696 * @tc.name : 10.AVRecorder test recording 3 seconds (only video) 5697 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.release 5698 * @tc.size : MediumTest 5699 * @tc.type : Function 5700 * @tc.level : Level 2 5701 */ 5702 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1000', 0, async function (done) { 5703 if (!isSupportCameraVideoProfiles) { 5704 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5705 expect(true).assertTrue(); 5706 done(); 5707 } 5708 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1000 start') 5709 let fileName = avVideoRecorderTestBase.resourceName() 5710 fdObject = await mediaTestBase.getFd(fileName); 5711 fdPath = "fd://" + fdObject.fdNumber; 5712 avConfig.url = fdPath; 5713 let mySteps = new Array( 5714 // init avRecorder 5715 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5716 // init camera 5717 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5718 // start avRecorder 5719 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5720 // stop camera 5721 STOPCAMERA_EVENT, 5722 // release avRecorder and camera 5723 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5724 // end 5725 END_EVENT 5726 ); 5727 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5728 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1000 end') 5729 }) 5730 5731 /* * 5732 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1100 5733 * @tc.name : 11.AVRecorder test recording 3 seconds to pause (only video) 5734 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.release 5735 * @tc.size : MediumTest 5736 * @tc.type : Function 5737 * @tc.level : Level 2 5738 */ 5739 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1100', 0, async function (done) { 5740 if (!isSupportCameraVideoProfiles) { 5741 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5742 expect(true).assertTrue(); 5743 done(); 5744 } 5745 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1100 start') 5746 let fileName = avVideoRecorderTestBase.resourceName() 5747 fdObject = await mediaTestBase.getFd(fileName); 5748 fdPath = "fd://" + fdObject.fdNumber; 5749 avConfig.url = fdPath; 5750 let mySteps = new Array( 5751 // init avRecorder 5752 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5753 // init camera 5754 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5755 // start avRecorder 5756 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5757 // pause avRecorder 5758 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5759 // release avRecorder and camera 5760 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5761 // end 5762 END_EVENT 5763 ); 5764 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5765 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1100 end') 5766 }) 5767 5768 /* * 5769 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1200 5770 * @tc.name : 12.AVRecorder test recording 3 seconds to pause to resume (only video) 5771 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.release 5772 * @tc.size : MediumTest 5773 * @tc.type : Function 5774 * @tc.level : Level 2 5775 */ 5776 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1200', 0, async function (done) { 5777 if (!isSupportCameraVideoProfiles) { 5778 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5779 expect(true).assertTrue(); 5780 done(); 5781 } 5782 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1200 start') 5783 let fileName = avVideoRecorderTestBase.resourceName() 5784 fdObject = await mediaTestBase.getFd(fileName); 5785 fdPath = "fd://" + fdObject.fdNumber; 5786 avConfig.url = fdPath; 5787 let mySteps = new Array( 5788 // init avRecorder 5789 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5790 // init camera 5791 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5792 // start avRecorder 5793 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5794 // pause avRecorder 5795 PAUSERECORDER_CALLBACK_EVENT, 5796 // resume avRecorder 5797 RESUMERECORDER_CALLBACK_EVENT, 5798 // stop camera 5799 STOPCAMERA_EVENT, 5800 // release avRecorder and camera 5801 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5802 // end 5803 END_EVENT 5804 ); 5805 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5806 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1200 end') 5807 }) 5808 5809 /* * 5810 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1300 5811 * @tc.name : 13.AVRecorder test recording 3 seconds to stop (only video) 5812 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.stop 6.release 5813 * @tc.size : MediumTest 5814 * @tc.type : Function 5815 * @tc.level : Level 2 5816 */ 5817 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1300', 0, async function (done) { 5818 if (!isSupportCameraVideoProfiles) { 5819 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5820 expect(true).assertTrue(); 5821 done(); 5822 } 5823 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1300 start') 5824 let fileName = avVideoRecorderTestBase.resourceName() 5825 fdObject = await mediaTestBase.getFd(fileName); 5826 fdPath = "fd://" + fdObject.fdNumber; 5827 avConfig.url = fdPath; 5828 let mySteps = new Array( 5829 // init avRecorder 5830 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5831 // init camera 5832 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5833 // start avRecorder 5834 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5835 // stop avRecorder 5836 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5837 // release avRecorder and camera 5838 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5839 // end 5840 END_EVENT 5841 ); 5842 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5843 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1300 end') 5844 }) 5845 5846 /* * 5847 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1400 5848 * @tc.name : 14.AVRecorder test recording 3 seconds to reset (only video) 5849 * @tc.desc : 1.createAVRecorder 2.prepare 3.getInputSurface 4.start 5.reset 6.release 5850 * @tc.size : MediumTest 5851 * @tc.type : Function 5852 * @tc.level : Level 2 5853 */ 5854 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1400', 0, async function (done) { 5855 if (!isSupportCameraVideoProfiles) { 5856 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5857 expect(true).assertTrue(); 5858 done(); 5859 } 5860 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1400 start') 5861 let fileName = avVideoRecorderTestBase.resourceName() 5862 fdObject = await mediaTestBase.getFd(fileName); 5863 fdPath = "fd://" + fdObject.fdNumber; 5864 avConfig.url = fdPath; 5865 let mySteps = new Array( 5866 // init avRecorder 5867 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5868 // init camera 5869 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5870 // start avRecorder 5871 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5872 // reset avRecorder 5873 RESETRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5874 // release avRecorder and camera 5875 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5876 // end 5877 END_EVENT 5878 ); 5879 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5880 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_1400 end') 5881 }) 5882 5883 // Callback prepare 5884 /* * 5885 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0100 5886 * @tc.name : 01. create->prepare 5887 * @tc.desc : 1.create 2.prepare 5888 * @tc.size : MediumTest 5889 * @tc.type : Function 5890 * @tc.level : Level 2 5891 */ 5892 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0100', 0, async function (done) { 5893 if (!isSupportCameraVideoProfiles) { 5894 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5895 expect(true).assertTrue(); 5896 done(); 5897 } 5898 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0100 start') 5899 let fileName = avVideoRecorderTestBase.resourceName() 5900 fdObject = await mediaTestBase.getFd(fileName); 5901 fdPath = "fd://" + fdObject.fdNumber; 5902 avConfig.url = fdPath; 5903 let mySteps = new Array( 5904 // init avRecorder 5905 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5906 // release avRecorde 5907 RELEASECORDER_CALLBACK_EVENT, 5908 // end 5909 END_EVENT 5910 ); 5911 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5912 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0100 end') 5913 }) 5914 5915 /* * 5916 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0200 5917 * @tc.name : 02. start->prepare 5918 * @tc.desc : 1.create 2.prepare 3.start 4.prepare 5919 * @tc.size : MediumTest 5920 * @tc.type : Function 5921 * @tc.level : Level 2 5922 */ 5923 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0200', 0, async function (done) { 5924 if (!isSupportCameraVideoProfiles) { 5925 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5926 expect(true).assertTrue(); 5927 done(); 5928 } 5929 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0200 start') 5930 let fileName = avVideoRecorderTestBase.resourceName() 5931 fdObject = await mediaTestBase.getFd(fileName); 5932 fdPath = "fd://" + fdObject.fdNumber; 5933 avConfig.url = fdPath; 5934 let mySteps = new Array( 5935 // init avRecorder 5936 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5937 // init camera 5938 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5939 // start avRecorder 5940 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5941 // prepare avRecorder 5942 PREPARE_CALLBACK_EVENT, 5943 // release avRecorder and camera 5944 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5945 // end 5946 END_EVENT 5947 ); 5948 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5949 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0200 end') 5950 }) 5951 5952 /* * 5953 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0300 5954 * @tc.name : 03. pause->prepare 5955 * @tc.desc : 1.create 2.prepare 3.start 4.pause 5.prepare 5956 * @tc.size : MediumTest 5957 * @tc.type : Function 5958 * @tc.level : Level 2 5959 */ 5960 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0300', 0, async function (done) { 5961 if (!isSupportCameraVideoProfiles) { 5962 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 5963 expect(true).assertTrue(); 5964 done(); 5965 } 5966 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0300 start') 5967 let fileName = avVideoRecorderTestBase.resourceName() 5968 fdObject = await mediaTestBase.getFd(fileName); 5969 fdPath = "fd://" + fdObject.fdNumber; 5970 avConfig.url = fdPath; 5971 let mySteps = new Array( 5972 // init avRecorder 5973 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 5974 // init camera 5975 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 5976 // start avRecorder 5977 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 5978 // pasue avRecorder 5979 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 5980 // prepare avRecorder 5981 PREPARE_CALLBACK_EVENT, 5982 // release avRecorder and camera 5983 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 5984 // end 5985 END_EVENT 5986 ); 5987 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 5988 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0300 end') 5989 }) 5990 5991 /* * 5992 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0400 5993 * @tc.name : 04. resume->prepare 5994 * @tc.desc : 1.create 2.prepare 3.start 4.pause 5.resume 6.prepare 5995 * @tc.size : MediumTest 5996 * @tc.type : Function 5997 * @tc.level : Level 2 5998 */ 5999 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0400', 0, async function (done) { 6000 if (!isSupportCameraVideoProfiles) { 6001 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6002 expect(true).assertTrue(); 6003 done(); 6004 } 6005 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0400 start') 6006 let fileName = avVideoRecorderTestBase.resourceName() 6007 fdObject = await mediaTestBase.getFd(fileName); 6008 fdPath = "fd://" + fdObject.fdNumber; 6009 avConfig.url = fdPath; 6010 let mySteps = new Array( 6011 // init avRecorder 6012 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6013 // init camera 6014 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6015 // start avRecorder 6016 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6017 // pasue avRecorder 6018 PAUSERECORDER_CALLBACK_EVENT, 6019 // resume avRecorder 6020 RESUMERECORDER_CALLBACK_EVENT, 6021 // prepare avRecorder 6022 PREPARE_CALLBACK_EVENT, 6023 // stop camera 6024 STOPCAMERA_EVENT, 6025 // release avRecorder and camera 6026 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6027 // end 6028 END_EVENT 6029 ); 6030 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6031 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0400 end') 6032 }) 6033 6034 /* * 6035 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0500 6036 * @tc.name : 05. stop->prepare 6037 * @tc.desc : 1.create 2.prepare 3.start 4.stop 5.prepare 6038 * @tc.size : MediumTest 6039 * @tc.type : Function 6040 * @tc.level : Level 2 6041 */ 6042 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0500', 0, async function (done) { 6043 if (!isSupportCameraVideoProfiles) { 6044 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6045 expect(true).assertTrue(); 6046 done(); 6047 } 6048 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0500 start') 6049 let fileName = avVideoRecorderTestBase.resourceName() 6050 fdObject = await mediaTestBase.getFd(fileName); 6051 fdPath = "fd://" + fdObject.fdNumber; 6052 avConfig.url = fdPath; 6053 let mySteps = new Array( 6054 // init avRecorder 6055 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6056 // init camera 6057 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6058 // start avRecorder 6059 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6060 // stop avRecorder 6061 STOPRECORDER_CALLBACK_EVENT, 6062 // prepare avRecorder 6063 PREPARE_CALLBACK_EVENT, 6064 // stop camera 6065 STOPCAMERA_EVENT, 6066 // release avRecorder and camera 6067 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6068 // end 6069 END_EVENT 6070 ); 6071 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6072 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0500 end') 6073 }) 6074 6075 /* * 6076 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0600 6077 * @tc.name : 06. reset->prepare 6078 * @tc.desc : 1.create 2.prepare 3.start 4.reset 5.prepare 6079 * @tc.size : MediumTest 6080 * @tc.type : Function 6081 * @tc.level : Level 2 6082 */ 6083 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0600', 0, async function (done) { 6084 if (!isSupportCameraVideoProfiles) { 6085 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6086 expect(true).assertTrue(); 6087 done(); 6088 } 6089 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0600 start') 6090 let fileName = avVideoRecorderTestBase.resourceName() 6091 fdObject = await mediaTestBase.getFd(fileName); 6092 fdPath = "fd://" + fdObject.fdNumber; 6093 avConfig.url = fdPath; 6094 let mySteps = new Array( 6095 // init avRecorder 6096 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6097 // init camera 6098 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6099 // start avRecorder 6100 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6101 // reset avRecorder 6102 RESETRECORDER_CALLBACK_EVENT, 6103 // prepare avRecorder 6104 PREPARE_CALLBACK_EVENT, 6105 // stop camera 6106 STOPCAMERA_EVENT, 6107 // release avRecorder and camera 6108 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6109 // end 6110 END_EVENT 6111 ); 6112 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6113 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0600 end') 6114 }) 6115 6116 /* * 6117 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0700 6118 * @tc.name : 07. getInputSurface->prepare 6119 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.prepare 6120 * @tc.size : MediumTest 6121 * @tc.type : Function 6122 * @tc.level : Level 2 6123 */ 6124 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0700', 0, async function (done) { 6125 if (!isSupportCameraVideoProfiles) { 6126 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6127 expect(true).assertTrue(); 6128 done(); 6129 } 6130 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0700 start') 6131 let fileName = avVideoRecorderTestBase.resourceName() 6132 fdObject = await mediaTestBase.getFd(fileName); 6133 fdPath = "fd://" + fdObject.fdNumber; 6134 avConfig.url = fdPath; 6135 let mySteps = new Array( 6136 // init avRecorder 6137 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6138 // init camera 6139 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6140 // prepare avRecorder 6141 PREPARE_CALLBACK_EVENT, 6142 // release avRecorder and camera 6143 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6144 // end 6145 END_EVENT 6146 ); 6147 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6148 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0700 end') 6149 }) 6150 6151 /* * 6152 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0800 6153 * @tc.name : 08. prepare 3 times 6154 * @tc.desc : 1.create 2.prepare 3.prepare 4.prepare 6155 * @tc.size : MediumTest 6156 * @tc.type : Function 6157 * @tc.level : Level 2 6158 */ 6159 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0800', 0, async function (done) { 6160 if (!isSupportCameraVideoProfiles) { 6161 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6162 expect(true).assertTrue(); 6163 done(); 6164 } 6165 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0800 start') 6166 let fileName = avVideoRecorderTestBase.resourceName() 6167 fdObject = await mediaTestBase.getFd(fileName); 6168 fdPath = "fd://" + fdObject.fdNumber; 6169 avConfig.url = fdPath; 6170 let mySteps = new Array( 6171 // init avRecorder 6172 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6173 // prepare avRecorder 6174 PREPARE_CALLBACK_EVENT, 6175 // prepare avRecorder 6176 PREPARE_CALLBACK_EVENT, 6177 // release avRecorder and camera 6178 RELEASECORDER_CALLBACK_EVENT, 6179 // end 6180 END_EVENT 6181 ); 6182 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6183 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0800 end') 6184 }) 6185 6186 /* * 6187 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0900 6188 * @tc.name : 09.audioBitrate -1 6189 * @tc.desc : 1.create 2.prepare (audioBitrate -1) 6190 * @tc.size : MediumTest 6191 * @tc.type : Function 6192 * @tc.level : Level 2 6193 */ 6194 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0900', 0, async function (done) { 6195 if (!isSupportCameraVideoProfiles) { 6196 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6197 expect(true).assertTrue(); 6198 done(); 6199 } 6200 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0900 start') 6201 let avNewProfile = { 6202 audioBitrate : -1, 6203 audioChannels : 2, 6204 audioSampleRate : 48000, 6205 audioCodec : media.CodecMimeType.AUDIO_AAC, 6206 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 6207 videoBitrate : 280000, 6208 videoCodec : media.CodecMimeType.VIDEO_AVC, 6209 videoFrameWidth : 640, 6210 videoFrameHeight : 480, 6211 videoFrameRate : 30, 6212 } 6213 let avNewConfig = { 6214 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 6215 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 6216 profile : avNewProfile, 6217 url : 'fd://35', 6218 rotation : 0, 6219 location : { latitude : 30, longitude : 130 } 6220 } 6221 let fileName = avVideoRecorderTestBase.resourceName() 6222 fdObject = await mediaTestBase.getFd(fileName); 6223 fdPath = "fd://" + fdObject.fdNumber; 6224 avNewConfig.url = fdPath; 6225 checkDevice(avNewConfig) 6226 let mySteps = new Array( 6227 // init avRecorder 6228 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6229 // release avRecorder 6230 RELEASECORDER_CALLBACK_EVENT, 6231 // end 6232 END_EVENT 6233 ); 6234 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 6235 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_0900 end') 6236 }) 6237 6238 /* * 6239 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1000 6240 * @tc.name : 10.audioSampleRate -1 6241 * @tc.desc : 1.create 2.prepare (audioSampleRate -1) 6242 * @tc.size : MediumTest 6243 * @tc.type : Function 6244 * @tc.level : Level 2 6245 */ 6246 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1000', 0, async function (done) { 6247 if (!isSupportCameraVideoProfiles) { 6248 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6249 expect(true).assertTrue(); 6250 done(); 6251 } 6252 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1000 start') 6253 let avNewProfile = { 6254 audioBitrate : 48000, 6255 audioChannels : 2, 6256 audioSampleRate : -1, 6257 audioCodec : media.CodecMimeType.AUDIO_AAC, 6258 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 6259 videoBitrate : 280000, 6260 videoCodec : media.CodecMimeType.VIDEO_AVC, 6261 videoFrameWidth : 640, 6262 videoFrameHeight : 480, 6263 videoFrameRate : 30, 6264 } 6265 let avNewConfig = { 6266 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 6267 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 6268 profile : avNewProfile, 6269 url : 'fd://35', 6270 rotation : 0, 6271 location : { latitude : 30, longitude : 130 } 6272 } 6273 let fileName = avVideoRecorderTestBase.resourceName() 6274 fdObject = await mediaTestBase.getFd(fileName); 6275 fdPath = "fd://" + fdObject.fdNumber; 6276 avNewConfig.url = fdPath; 6277 checkDevice(avNewConfig) 6278 let mySteps = new Array( 6279 // init avRecorder 6280 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6281 // release avRecorder 6282 RELEASECORDER_CALLBACK_EVENT, 6283 // end 6284 END_EVENT 6285 ); 6286 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 6287 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1000 end') 6288 }) 6289 6290 /* * 6291 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1100 6292 * @tc.name : 11.videoBitrateRange -1 6293 * @tc.desc : 1.create 2.prepare (videoBitrateRange -1) 6294 * @tc.size : MediumTest 6295 * @tc.type : Function 6296 * @tc.level : Level 2 6297 */ 6298 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1100', 0, async function (done) { 6299 if (!isSupportCameraVideoProfiles) { 6300 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6301 expect(true).assertTrue(); 6302 done(); 6303 } 6304 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1100 start') 6305 let avNewProfile = { 6306 audioBitrate : 48000, 6307 audioChannels : 2, 6308 audioCodec : media.CodecMimeType.AUDIO_AAC, 6309 audioSampleRate : 48000, 6310 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 6311 videoBitrate : -1, // 视频比特率 6312 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 6313 videoFrameWidth : 640, // 视频分辨率的宽 6314 videoFrameHeight : 480, // 视频分辨率的高 6315 videoFrameRate : 30 // 视频帧率 6316 } 6317 let avNewConfig = { 6318 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 6319 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 6320 profile : avNewProfile, 6321 url : 'fd://35', 6322 rotation : 0, 6323 location : { latitude : 30, longitude : 130 } 6324 } 6325 let fileName = avVideoRecorderTestBase.resourceName() 6326 fdObject = await mediaTestBase.getFd(fileName); 6327 fdPath = "fd://" + fdObject.fdNumber; 6328 avNewConfig.url = fdPath; 6329 checkDevice(avNewConfig) 6330 let mySteps = new Array( 6331 // init avRecorder 6332 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6333 // release avRecorder 6334 RELEASECORDER_CALLBACK_EVENT, 6335 // end 6336 END_EVENT 6337 ); 6338 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 6339 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1100 end') 6340 }) 6341 6342 /* * 6343 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1200 6344 * @tc.name : 12.videoFrameRate -1 6345 * @tc.desc : 1.create 2.prepare (videoFrameRate -1) 6346 * @tc.size : MediumTest 6347 * @tc.type : Function 6348 * @tc.level : Level 2 6349 */ 6350 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1200', 0, async function (done) { 6351 if (!isSupportCameraVideoProfiles) { 6352 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6353 expect(true).assertTrue(); 6354 done(); 6355 } 6356 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1200 start') 6357 let avNewProfile = { 6358 audioBitrate : 48000, 6359 audioChannels : 2, 6360 audioCodec : media.CodecMimeType.AUDIO_AAC, 6361 audioSampleRate : 48000, 6362 fileFormat : media.ContainerFormatType.CFT_MPEG_4, // 视频文件封装格式，只支持MP4 6363 videoBitrate : 280000, // 视频比特率 6364 videoCodec : media.CodecMimeType.VIDEO_AVC, // 视频文件编码格式，支持mpeg4和avc两种格式 6365 videoFrameWidth : 640, // 视频分辨率的宽 6366 videoFrameHeight : 480, // 视频分辨率的高 6367 videoFrameRate : -1 // 视频帧率 6368 } 6369 let avNewConfig = { 6370 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, 6371 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 6372 profile : avNewProfile, 6373 url : 'fd://35', 6374 rotation : 0, 6375 location : { latitude : 30, longitude : 130 } 6376 } 6377 let fileName = avVideoRecorderTestBase.resourceName() 6378 fdObject = await mediaTestBase.getFd(fileName); 6379 fdPath = "fd://" + fdObject.fdNumber; 6380 avNewConfig.url = fdPath; 6381 checkDevice(avNewConfig) 6382 let mySteps = new Array( 6383 // init avRecorder 6384 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6385 // release avRecorder 6386 RELEASECORDER_CALLBACK_EVENT, 6387 // end 6388 END_EVENT 6389 ); 6390 eventEmitter.emit(mySteps[0], avRecorder, avNewConfig, recorderTime, mySteps, done); 6391 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PREPARE_CALLBACK_1200 end') 6392 }) 6393 6394 // Callback getInputSurface 6395 /* * 6396 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0100 6397 * @tc.name : 01. create->getInputSurface 6398 * @tc.desc : 1.create 2.getInputSurface 6399 * @tc.size : MediumTest 6400 * @tc.type : Function 6401 * @tc.level : Level 2 6402 */ 6403 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0100', 0, async function (done) { 6404 if (!isSupportCameraVideoProfiles) { 6405 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6406 expect(true).assertTrue(); 6407 done(); 6408 } 6409 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0100 start') 6410 let fileName = avVideoRecorderTestBase.resourceName() 6411 fdObject = await mediaTestBase.getFd(fileName); 6412 fdPath = "fd://" + fdObject.fdNumber; 6413 avConfig.url = fdPath; 6414 let mySteps = new Array( 6415 // init avRecorder 6416 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 6417 // getInputSurface 6418 GETINPUTSURFACE_CALLBACK_EVENT, 6419 // release avRecorder 6420 RELEASECORDER_CALLBACK_EVENT, 6421 // end 6422 END_EVENT 6423 ); 6424 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6425 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0100 end') 6426 }) 6427 6428 /* * 6429 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0200 6430 * @tc.name : 02. prepare->getInputSurface 6431 * @tc.desc : 1.create 2.prepare 3.getInputSurface 6432 * @tc.size : MediumTest 6433 * @tc.type : Function 6434 * @tc.level : Level 2 6435 */ 6436 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0200', 0, async function (done) { 6437 if (!isSupportCameraVideoProfiles) { 6438 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6439 expect(true).assertTrue(); 6440 done(); 6441 } 6442 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0200 start') 6443 let fileName = avVideoRecorderTestBase.resourceName() 6444 fdObject = await mediaTestBase.getFd(fileName); 6445 fdPath = "fd://" + fdObject.fdNumber; 6446 avConfig.url = fdPath; 6447 let mySteps = new Array( 6448 // init avRecorder 6449 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6450 // getInputSurface 6451 GETINPUTSURFACE_CALLBACK_EVENT, 6452 // release avRecorder 6453 RELEASECORDER_CALLBACK_EVENT, 6454 // end 6455 END_EVENT 6456 ); 6457 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6458 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0200 end') 6459 }) 6460 6461 /* * 6462 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0300 6463 * @tc.name : 03. start->getInputSurface 6464 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.getInputSurface 6465 * @tc.size : MediumTest 6466 * @tc.type : Function 6467 * @tc.level : Level 2 6468 */ 6469 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0300', 0, async function (done) { 6470 if (!isSupportCameraVideoProfiles) { 6471 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6472 expect(true).assertTrue(); 6473 done(); 6474 } 6475 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0300 start') 6476 let fileName = avVideoRecorderTestBase.resourceName() 6477 fdObject = await mediaTestBase.getFd(fileName); 6478 fdPath = "fd://" + fdObject.fdNumber; 6479 avConfig.url = fdPath; 6480 let mySteps = new Array( 6481 // init avRecorder 6482 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6483 // init camera 6484 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6485 // start avRecorder 6486 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6487 // getInputSurface 6488 GETINPUTSURFACE_CALLBACK_EVENT, 6489 // release avRecorder and camera 6490 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6491 // end 6492 END_EVENT 6493 ); 6494 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6495 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0300 end') 6496 }) 6497 6498 /* * 6499 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0400 6500 * @tc.name : 04. pause->getInputSurface 6501 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.getInputSurface 6502 * @tc.size : MediumTest 6503 * @tc.type : Function 6504 * @tc.level : Level 2 6505 */ 6506 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0400', 0, async function (done) { 6507 if (!isSupportCameraVideoProfiles) { 6508 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6509 expect(true).assertTrue(); 6510 done(); 6511 } 6512 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0400 start') 6513 let fileName = avVideoRecorderTestBase.resourceName() 6514 fdObject = await mediaTestBase.getFd(fileName); 6515 fdPath = "fd://" + fdObject.fdNumber; 6516 avConfig.url = fdPath; 6517 let mySteps = new Array( 6518 // init avRecorder 6519 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6520 // init camera 6521 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6522 // start avRecorder 6523 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6524 // pause avRecorder 6525 PAUSERECORDER_CALLBACK_EVENT, 6526 // getInputSurface 6527 GETINPUTSURFACE_CALLBACK_EVENT, 6528 // stop camera 6529 STOPCAMERA_EVENT, 6530 // release avRecorder and camera 6531 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6532 // end 6533 END_EVENT 6534 ); 6535 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6536 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0400 end') 6537 }) 6538 6539 /* * 6540 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0500 6541 * @tc.name : 05. resume->getInputSurface 6542 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.getInputSurface 6543 * @tc.size : MediumTest 6544 * @tc.type : Function 6545 * @tc.level : Level 2 6546 */ 6547 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0500', 0, async function (done) { 6548 if (!isSupportCameraVideoProfiles) { 6549 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6550 expect(true).assertTrue(); 6551 done(); 6552 } 6553 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0500 start') 6554 let fileName = avVideoRecorderTestBase.resourceName() 6555 fdObject = await mediaTestBase.getFd(fileName); 6556 fdPath = "fd://" + fdObject.fdNumber; 6557 avConfig.url = fdPath; 6558 let mySteps = new Array( 6559 // init avRecorder 6560 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6561 // init camera 6562 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6563 // start avRecorder 6564 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6565 // pause avRecorder 6566 PAUSERECORDER_CALLBACK_EVENT, 6567 // resume avRecorder 6568 RESUMERECORDER_CALLBACK_EVENT, 6569 // getInputSurface 6570 GETINPUTSURFACE_CALLBACK_EVENT, 6571 // stop camera 6572 STOPCAMERA_EVENT, 6573 // release avRecorder and camera 6574 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6575 // end 6576 END_EVENT 6577 ); 6578 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6579 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0500 end') 6580 }) 6581 6582 /* * 6583 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0600 6584 * @tc.name : 06. stop->getInputSurface 6585 * @tc.desc :1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.getInputSurface 6586 * @tc.size : MediumTest 6587 * @tc.type : Function 6588 * @tc.level : Level 2 6589 */ 6590 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0600', 0, async function (done) { 6591 if (!isSupportCameraVideoProfiles) { 6592 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6593 expect(true).assertTrue(); 6594 done(); 6595 } 6596 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0600 start') 6597 let fileName = avVideoRecorderTestBase.resourceName() 6598 fdObject = await mediaTestBase.getFd(fileName); 6599 fdPath = "fd://" + fdObject.fdNumber; 6600 avConfig.url = fdPath; 6601 let mySteps = new Array( 6602 // init avRecorder 6603 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6604 // init camera 6605 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6606 // start avRecorder 6607 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6608 // stop avRecorder 6609 STOPRECORDER_CALLBACK_EVENT, 6610 // getInputSurface 6611 GETINPUTSURFACE_CALLBACK_EVENT, 6612 // stop camera 6613 STOPCAMERA_EVENT, 6614 // release avRecorder and camera 6615 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6616 // end 6617 END_EVENT 6618 ); 6619 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6620 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0600 end') 6621 }) 6622 6623 /* * 6624 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0700 6625 * @tc.name : 07. reset->getInputSurface 6626 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.getInputSurface 6627 * @tc.size : MediumTest 6628 * @tc.type : Function 6629 * @tc.level : Level 2 6630 */ 6631 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0700', 0, async function (done) { 6632 if (!isSupportCameraVideoProfiles) { 6633 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6634 expect(true).assertTrue(); 6635 done(); 6636 } 6637 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0700 start') 6638 let fileName = avVideoRecorderTestBase.resourceName() 6639 fdObject = await mediaTestBase.getFd(fileName); 6640 fdPath = "fd://" + fdObject.fdNumber; 6641 avConfig.url = fdPath; 6642 let mySteps = new Array( 6643 // init avRecorder 6644 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6645 // init camera 6646 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6647 // start avRecorder 6648 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6649 // reset avRecorder 6650 RESETRECORDER_CALLBACK_EVENT, 6651 // getInputSurface 6652 GETINPUTSURFACE_CALLBACK_EVENT, 6653 // stop camera 6654 STOPCAMERA_EVENT, 6655 // release avRecorder and camera 6656 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6657 // end 6658 END_EVENT 6659 ); 6660 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6661 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0700 end') 6662 }) 6663 6664 /* * 6665 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0800 6666 * @tc.name : 08. getInputSurface 3 times 6667 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.getInputSurface 5.getInputSurface 6668 * @tc.size : MediumTest 6669 * @tc.type : Function 6670 * @tc.level : Level 2 6671 */ 6672 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0800', 0, async function (done) { 6673 if (!isSupportCameraVideoProfiles) { 6674 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6675 expect(true).assertTrue(); 6676 done(); 6677 } 6678 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0800 start') 6679 let fileName = avVideoRecorderTestBase.resourceName() 6680 fdObject = await mediaTestBase.getFd(fileName); 6681 fdPath = "fd://" + fdObject.fdNumber; 6682 avConfig.url = fdPath; 6683 let mySteps = new Array( 6684 // init avRecorder 6685 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6686 // getInputSurface 6687 GETINPUTSURFACE_CALLBACK_EVENT, 6688 // getInputSurface 6689 GETINPUTSURFACE_CALLBACK_EVENT, 6690 // getInputSurface 6691 GETINPUTSURFACE_CALLBACK_EVENT, 6692 // release avRecorder 6693 RELEASECORDER_CALLBACK_EVENT, 6694 // end 6695 END_EVENT 6696 ); 6697 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6698 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETSURFACE_CALLBACK_0800 end') 6699 }) 6700 6701 // Callback start 6702 /* * 6703 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0100 6704 * @tc.name : 01. create->start 6705 * @tc.desc : 1.create 2.start 6706 * @tc.size : MediumTest 6707 * @tc.type : Function 6708 * @tc.level : Level 2 6709 */ 6710 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0100', 0, async function (done) { 6711 if (!isSupportCameraVideoProfiles) { 6712 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6713 expect(true).assertTrue(); 6714 done(); 6715 } 6716 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0100 start') 6717 let fileName = avVideoRecorderTestBase.resourceName() 6718 fdObject = await mediaTestBase.getFd(fileName); 6719 fdPath = "fd://" + fdObject.fdNumber; 6720 avConfig.url = fdPath; 6721 let mySteps = new Array( 6722 // init avRecorder 6723 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 6724 // start avRecorder 6725 STARTRECORDER_CALLBACK_EVENT, 6726 // release avRecorder 6727 RELEASECORDER_CALLBACK_EVENT, 6728 // end 6729 END_EVENT 6730 ); 6731 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6732 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0100 end') 6733 }) 6734 6735 /* * 6736 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0200 6737 * @tc.name : 02. prepare->start 6738 * @tc.desc : 1.create 2.prepare 4.start 6739 * @tc.size : MediumTest 6740 * @tc.type : Function 6741 * @tc.level : Level 2 6742 */ 6743 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0200', 0, async function (done) { 6744 if (!isSupportCameraVideoProfiles) { 6745 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6746 expect(true).assertTrue(); 6747 done(); 6748 } 6749 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0200 start') 6750 let fileName = avVideoRecorderTestBase.resourceName() 6751 fdObject = await mediaTestBase.getFd(fileName); 6752 fdPath = "fd://" + fdObject.fdNumber; 6753 avConfig.url = fdPath; 6754 let mySteps = new Array( 6755 // init avRecorder 6756 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6757 // start avRecorder 6758 STARTRECORDER_CALLBACK_EVENT, 6759 // release avRecorder 6760 RELEASECORDER_CALLBACK_EVENT, 6761 // end 6762 END_EVENT 6763 ); 6764 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6765 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0200 end') 6766 }) 6767 6768 /* * 6769 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0300 6770 * @tc.name : 03. pause->start 6771 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.start 6772 * @tc.size : MediumTest 6773 * @tc.type : Function 6774 * @tc.level : Level 2 6775 */ 6776 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0300', 0, async function (done) { 6777 if (!isSupportCameraVideoProfiles) { 6778 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6779 expect(true).assertTrue(); 6780 done(); 6781 } 6782 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0300 start') 6783 let fileName = avVideoRecorderTestBase.resourceName() 6784 fdObject = await mediaTestBase.getFd(fileName); 6785 fdPath = "fd://" + fdObject.fdNumber; 6786 avConfig.url = fdPath; 6787 let mySteps = new Array( 6788 // init avRecorder 6789 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6790 // init camera 6791 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6792 // start avRecorder 6793 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6794 // pause avRecorder 6795 PAUSERECORDER_CALLBACK_EVENT, 6796 // start avRecorder 6797 STARTRECORDER_CALLBACK_EVENT, 6798 // stop camera 6799 STOPCAMERA_EVENT, 6800 // release avRecorder and camera 6801 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6802 // end 6803 END_EVENT 6804 ); 6805 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6806 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0300 end') 6807 }) 6808 6809 /* * 6810 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0400 6811 * @tc.name : 04. resume->start 6812 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.start 6813 * @tc.size : MediumTest 6814 * @tc.type : Function 6815 * @tc.level : Level 2 6816 */ 6817 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0400', 0, async function (done) { 6818 if (!isSupportCameraVideoProfiles) { 6819 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6820 expect(true).assertTrue(); 6821 done(); 6822 } 6823 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0400 start') 6824 let fileName = avVideoRecorderTestBase.resourceName() 6825 fdObject = await mediaTestBase.getFd(fileName); 6826 fdPath = "fd://" + fdObject.fdNumber; 6827 avConfig.url = fdPath; 6828 let mySteps = new Array( 6829 // init avRecorder 6830 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6831 // init camera 6832 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6833 // start avRecorder 6834 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6835 // pause avRecorder 6836 PAUSERECORDER_CALLBACK_EVENT, 6837 // resume avRecorder 6838 RESUMERECORDER_CALLBACK_EVENT, 6839 // start avRecorder 6840 STARTRECORDER_CALLBACK_EVENT, 6841 // stop camera 6842 STOPCAMERA_EVENT, 6843 // release avRecorder and camera 6844 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6845 // end 6846 END_EVENT 6847 ); 6848 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6849 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0400 end') 6850 }) 6851 6852 /* * 6853 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0500 6854 * @tc.name : 05. stop->start 6855 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.start 6856 * @tc.size : MediumTest 6857 * @tc.type : Function 6858 * @tc.level : Level 2 6859 */ 6860 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0500', 0, async function (done) { 6861 if (!isSupportCameraVideoProfiles) { 6862 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6863 expect(true).assertTrue(); 6864 done(); 6865 } 6866 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0500 start') 6867 let fileName = avVideoRecorderTestBase.resourceName() 6868 fdObject = await mediaTestBase.getFd(fileName); 6869 fdPath = "fd://" + fdObject.fdNumber; 6870 avConfig.url = fdPath; 6871 let mySteps = new Array( 6872 // init avRecorder 6873 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6874 // init camera 6875 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6876 // start avRecorder 6877 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6878 // stop avRecorder 6879 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 6880 // start avRecorder 6881 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6882 // stop camera 6883 STOPCAMERA_EVENT, 6884 // release avRecorder and camera 6885 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6886 // end 6887 END_EVENT 6888 ); 6889 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6890 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0500 end') 6891 }) 6892 6893 /* * 6894 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0600 6895 * @tc.name : 06. reset->start 6896 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.start 6897 * @tc.size : MediumTest 6898 * @tc.type : Function 6899 * @tc.level : Level 2 6900 */ 6901 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0600', 0, async function (done) { 6902 if (!isSupportCameraVideoProfiles) { 6903 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6904 expect(true).assertTrue(); 6905 done(); 6906 } 6907 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0600 start') 6908 let fileName = avVideoRecorderTestBase.resourceName() 6909 fdObject = await mediaTestBase.getFd(fileName); 6910 fdPath = "fd://" + fdObject.fdNumber; 6911 avConfig.url = fdPath; 6912 let mySteps = new Array( 6913 // init avRecorder 6914 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6915 // init camera 6916 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6917 // start avRecorder 6918 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6919 // reset avRecorder 6920 RESETRECORDER_CALLBACK_EVENT, 6921 // start avRecorder 6922 STARTRECORDER_CALLBACK_EVENT, 6923 // stop camera 6924 STOPCAMERA_EVENT, 6925 // release avRecorder and camera 6926 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6927 // end 6928 END_EVENT 6929 ); 6930 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6931 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0600 end') 6932 }) 6933 6934 /* * 6935 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0700 6936 * @tc.name : 07. getInputSurface->start 6937 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 6938 * @tc.size : MediumTest 6939 * @tc.type : Function 6940 * @tc.level : Level 2 6941 */ 6942 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0700', 0, async function (done) { 6943 if (!isSupportCameraVideoProfiles) { 6944 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6945 expect(true).assertTrue(); 6946 done(); 6947 } 6948 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0700 start') 6949 let fileName = avVideoRecorderTestBase.resourceName() 6950 fdObject = await mediaTestBase.getFd(fileName); 6951 fdPath = "fd://" + fdObject.fdNumber; 6952 avConfig.url = fdPath; 6953 let mySteps = new Array( 6954 // init avRecorder 6955 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6956 // init camera 6957 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6958 // start avRecorder 6959 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6960 // release avRecorder and camera 6961 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 6962 // end 6963 END_EVENT 6964 ); 6965 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 6966 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0700 end') 6967 }) 6968 6969 /* * 6970 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0800 6971 * @tc.name : 08. start 3 times 6972 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.start 6.start 6973 * @tc.size : MediumTest 6974 * @tc.type : Function 6975 * @tc.level : Level 2 6976 */ 6977 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0800', 0, async function (done) { 6978 if (!isSupportCameraVideoProfiles) { 6979 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 6980 expect(true).assertTrue(); 6981 done(); 6982 } 6983 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0800 start') 6984 let fileName = avVideoRecorderTestBase.resourceName() 6985 fdObject = await mediaTestBase.getFd(fileName); 6986 fdPath = "fd://" + fdObject.fdNumber; 6987 avConfig.url = fdPath; 6988 let mySteps = new Array( 6989 // init avRecorder 6990 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 6991 // init camera 6992 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 6993 // start avRecorder 6994 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 6995 // start avRecorder 6996 STARTRECORDER_CALLBACK_EVENT, 6997 // start avRecorder 6998 STARTRECORDER_CALLBACK_EVENT, 6999 // release avRecorder and camera 7000 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7001 // end 7002 END_EVENT 7003 ); 7004 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7005 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_START_CALLBACK_0800 end') 7006 }) 7007 7008 // Callback pause 7009 /* * 7010 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0100 7011 * @tc.name : 01. create->pause 7012 * @tc.desc : 1.create 2.pause 7013 * @tc.size : MediumTest 7014 * @tc.type : Function 7015 * @tc.level : Level 2 7016 */ 7017 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0100', 0, async function (done) { 7018 if (!isSupportCameraVideoProfiles) { 7019 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7020 expect(true).assertTrue(); 7021 done(); 7022 } 7023 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0100 start') 7024 let fileName = avVideoRecorderTestBase.resourceName() 7025 fdObject = await mediaTestBase.getFd(fileName); 7026 fdPath = "fd://" + fdObject.fdNumber; 7027 avConfig.url = fdPath; 7028 let mySteps = new Array( 7029 // init avRecorder 7030 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 7031 // pause avRecorder 7032 PAUSERECORDER_CALLBACK_EVENT, 7033 // release avRecorder 7034 RELEASECORDER_CALLBACK_EVENT, 7035 // end 7036 END_EVENT 7037 ); 7038 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7039 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0100 end') 7040 }) 7041 7042 /* * 7043 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0200 7044 * @tc.name : 02. prepare->pause 7045 * @tc.desc : 1.create 2.prepare 3.pause 7046 * @tc.size : MediumTest 7047 * @tc.type : Function 7048 * @tc.level : Level 2 7049 */ 7050 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0200', 0, async function (done) { 7051 if (!isSupportCameraVideoProfiles) { 7052 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7053 expect(true).assertTrue(); 7054 done(); 7055 } 7056 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0200 start') 7057 let fileName = avVideoRecorderTestBase.resourceName() 7058 fdObject = await mediaTestBase.getFd(fileName); 7059 fdPath = "fd://" + fdObject.fdNumber; 7060 avConfig.url = fdPath; 7061 let mySteps = new Array( 7062 // init avRecorder 7063 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7064 // pause avRecorder 7065 PAUSERECORDER_CALLBACK_EVENT, 7066 // release avRecorder 7067 RELEASECORDER_CALLBACK_EVENT, 7068 // end 7069 END_EVENT 7070 ); 7071 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7072 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0200 end') 7073 }) 7074 7075 /* * 7076 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0300 7077 * @tc.name : 03. start->pause 7078 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 7079 * @tc.size : MediumTest 7080 * @tc.type : Function 7081 * @tc.level : Level 2 7082 */ 7083 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0300', 0, async function (done) { 7084 if (!isSupportCameraVideoProfiles) { 7085 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7086 expect(true).assertTrue(); 7087 done(); 7088 } 7089 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0300 start') 7090 let fileName = avVideoRecorderTestBase.resourceName() 7091 fdObject = await mediaTestBase.getFd(fileName); 7092 fdPath = "fd://" + fdObject.fdNumber; 7093 avConfig.url = fdPath; 7094 let mySteps = new Array( 7095 // init avRecorder 7096 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7097 // init camera 7098 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7099 // start avRecorder 7100 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7101 // pause avRecorder 7102 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7103 // release avRecorder and camera 7104 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7105 // end 7106 END_EVENT 7107 ); 7108 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7109 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0300 end') 7110 }) 7111 7112 /* * 7113 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0400 7114 * @tc.name : 04. resume->pause 7115 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.resume 7.pause 7116 * @tc.size : MediumTest 7117 * @tc.type : Function 7118 * @tc.level : Level 2 7119 */ 7120 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0400', 0, async function (done) { 7121 if (!isSupportCameraVideoProfiles) { 7122 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7123 expect(true).assertTrue(); 7124 done(); 7125 } 7126 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0400 start') 7127 let fileName = avVideoRecorderTestBase.resourceName() 7128 fdObject = await mediaTestBase.getFd(fileName); 7129 fdPath = "fd://" + fdObject.fdNumber; 7130 avConfig.url = fdPath; 7131 let mySteps = new Array( 7132 // init avRecorder 7133 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7134 // init camera 7135 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7136 // start avRecorder 7137 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7138 // pause avRecorder 7139 PAUSERECORDER_CALLBACK_EVENT, 7140 // resume avRecorder 7141 RESUMERECORDER_CALLBACK_EVENT, 7142 // pause avRecorder 7143 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7144 // release avRecorder and camera 7145 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7146 // end 7147 END_EVENT 7148 ); 7149 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7150 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0400 end') 7151 }) 7152 7153 /* * 7154 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0500 7155 * @tc.name : 05. stop->pause 7156 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.stop 6.pause 7157 * @tc.size : MediumTest 7158 * @tc.type : Function 7159 * @tc.level : Level 2 7160 */ 7161 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0500', 0, async function (done) { 7162 if (!isSupportCameraVideoProfiles) { 7163 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7164 expect(true).assertTrue(); 7165 done(); 7166 } 7167 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0500 start') 7168 let fileName = avVideoRecorderTestBase.resourceName() 7169 fdObject = await mediaTestBase.getFd(fileName); 7170 fdPath = "fd://" + fdObject.fdNumber; 7171 avConfig.url = fdPath; 7172 let mySteps = new Array( 7173 // init avRecorder 7174 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7175 // init camera 7176 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7177 // start avRecorder 7178 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7179 // stop avRecorder 7180 STOPRECORDER_CALLBACK_EVENT, 7181 // pause avRecorder 7182 PAUSERECORDER_CALLBACK_EVENT, 7183 // stop camera 7184 STOPCAMERA_EVENT, 7185 // release avRecorder and camera 7186 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7187 // end 7188 END_EVENT 7189 ); 7190 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7191 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0500 end') 7192 }) 7193 7194 /* * 7195 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0600 7196 * @tc.name : 06. reset->pause 7197 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.reset 6.pause 7198 * @tc.size : MediumTest 7199 * @tc.type : Function 7200 * @tc.level : Level 2 7201 */ 7202 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0600', 0, async function (done) { 7203 if (!isSupportCameraVideoProfiles) { 7204 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7205 expect(true).assertTrue(); 7206 done(); 7207 } 7208 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0600 start') 7209 let fileName = avVideoRecorderTestBase.resourceName() 7210 fdObject = await mediaTestBase.getFd(fileName); 7211 fdPath = "fd://" + fdObject.fdNumber; 7212 avConfig.url = fdPath; 7213 let mySteps = new Array( 7214 // init avRecorder 7215 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7216 // init camera 7217 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7218 // start avRecorder 7219 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7220 // reset avRecorder 7221 RESETRECORDER_CALLBACK_EVENT, 7222 // pause avRecorder 7223 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7224 // release avRecorder and camera 7225 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7226 // end 7227 END_EVENT 7228 ); 7229 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7230 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0600 end') 7231 }) 7232 7233 /* * 7234 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0700 7235 * @tc.name : 07. getInputSurface->pause 7236 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.pause 7237 * @tc.size : MediumTest 7238 * @tc.type : Function 7239 * @tc.level : Level 2 7240 */ 7241 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0700', 0, async function (done) { 7242 if (!isSupportCameraVideoProfiles) { 7243 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7244 expect(true).assertTrue(); 7245 done(); 7246 } 7247 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0700 start') 7248 let fileName = avVideoRecorderTestBase.resourceName() 7249 fdObject = await mediaTestBase.getFd(fileName); 7250 fdPath = "fd://" + fdObject.fdNumber; 7251 avConfig.url = fdPath; 7252 let mySteps = new Array( 7253 // init avRecorder 7254 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7255 // init camera 7256 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7257 // start avRecorder 7258 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7259 // reset avRecorder 7260 RESETRECORDER_CALLBACK_EVENT, 7261 // pause avRecorder 7262 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7263 // release avRecorder and camera 7264 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7265 // end 7266 END_EVENT 7267 ); 7268 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7269 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0700 end') 7270 }) 7271 7272 /* * 7273 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0800 7274 * @tc.name : 08. pause 3 times 7275 * @tc.desc : 1.create 2.prepare 3.getInputSurface 4.start 5.pause 6.pause 7.pause 7276 * @tc.size : MediumTest 7277 * @tc.type : Function 7278 * @tc.level : Level 2 7279 */ 7280 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0800', 0, async function (done) { 7281 if (!isSupportCameraVideoProfiles) { 7282 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7283 expect(true).assertTrue(); 7284 done(); 7285 } 7286 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0800 start') 7287 let fileName = avVideoRecorderTestBase.resourceName() 7288 fdObject = await mediaTestBase.getFd(fileName); 7289 fdPath = "fd://" + fdObject.fdNumber; 7290 avConfig.url = fdPath; 7291 let mySteps = new Array( 7292 // init avRecorder 7293 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7294 // init camera 7295 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7296 // start avRecorder 7297 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7298 // pause avRecorder 7299 PAUSERECORDER_CALLBACK_EVENT, 7300 // pause avRecorder 7301 PAUSERECORDER_CALLBACK_EVENT, 7302 // pause avRecorder 7303 PAUSERECORDER_CALLBACK_EVENT, 7304 // stop camera 7305 STOPCAMERA_EVENT, 7306 // release avRecorder and camera 7307 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7308 // end 7309 END_EVENT 7310 ); 7311 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 7312 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_PAUSE_CALLBACK_0800 end') 7313 }) 7314 7315 /* * 7316 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0200 7317 * @tc.name : 02.AVRecorder recording(audioBitrate 8000,audioSampleRate 8000,videoBitrateRange 280000) 7318 * @tc.desc : Recorder video 7319 * @tc.size : MediumTest 7320 * @tc.type : Function test 7321 * @tc.level : Level2 7322 */ 7323 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0200', 0, async function (done) { 7324 if (!isSupportCameraVideoProfiles) { 7325 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7326 expect(true).assertTrue(); 7327 done(); 7328 } 7329 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0200 start') 7330 7331 avProfileMpegAac.audioBitrate = 8000 7332 avProfileMpegAac.audioSampleRate = 8000 7333 avProfileMpegAac.videoBitrate = 280000 7334 7335 let fileName = avVideoRecorderTestBase.resourceName() 7336 fdObject = await mediaTestBase.getFd(fileName); 7337 fdPath = "fd://" + fdObject.fdNumber; 7338 avConfigMpegAac.url = fdPath; 7339 let mySteps = new Array( 7340 // init avRecorder 7341 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7342 // init camera 7343 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7344 // start recorder 7345 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7346 // pause recorder 7347 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7348 // resume recorder 7349 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7350 // stop recorder 7351 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7352 // release avRecorder and camera 7353 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7354 // end 7355 END_EVENT 7356 ); 7357 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7358 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0200 end') 7359 }) 7360 7361 /* * 7362 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0300 7363 * @tc.name : 03.AVRecorder recording(audioBitrate 16000,audioSampleRate 32000,videoBitrateRange 560000) 7364 * @tc.desc : Recorder video 7365 * @tc.size : MediumTest 7366 * @tc.type : Function test 7367 * @tc.level : Level2 7368 */ 7369 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0300', 0, async function (done) { 7370 if (!isSupportCameraVideoProfiles) { 7371 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7372 expect(true).assertTrue(); 7373 done(); 7374 } 7375 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0300 start') 7376 7377 avProfileMpegAac.audioBitrate = 16000 7378 avProfileMpegAac.audioSampleRate = 32000 7379 avProfileMpegAac.videoBitrate = 560000 7380 7381 let fileName = avVideoRecorderTestBase.resourceName() 7382 fdObject = await mediaTestBase.getFd(fileName); 7383 fdPath = "fd://" + fdObject.fdNumber; 7384 avConfigMpegAac.url = fdPath; 7385 let mySteps = new Array( 7386 // init avRecorder 7387 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7388 // init camera 7389 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7390 // start recorder 7391 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7392 // pause recorder 7393 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7394 // resume recorder 7395 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7396 // stop recorder 7397 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7398 // release avRecorder and camera 7399 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7400 // end 7401 END_EVENT 7402 ); 7403 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7404 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0300 end') 7405 }) 7406 7407 /* * 7408 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0400 7409 * @tc.name : 04.AVRecorder recording(audioBitrate 32000,audioSampleRate 44100,videoBitrateRange 1120000) 7410 * @tc.desc : Recorder video 7411 * @tc.size : MediumTest 7412 * @tc.type : Function test 7413 * @tc.level : Level2 7414 */ 7415 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0400', 0, async function (done) { 7416 if (!isSupportCameraVideoProfiles) { 7417 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7418 expect(true).assertTrue(); 7419 done(); 7420 } 7421 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0400 start') 7422 7423 avProfileMpegAac.audioBitrate = 32000 7424 avProfileMpegAac.audioSampleRate = 44100 7425 avProfileMpegAac.videoBitrate = 1120000 7426 7427 let fileName = avVideoRecorderTestBase.resourceName() 7428 fdObject = await mediaTestBase.getFd(fileName); 7429 fdPath = "fd://" + fdObject.fdNumber; 7430 avConfigMpegAac.url = fdPath; 7431 let mySteps = new Array( 7432 // init avRecorder 7433 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7434 // init camera 7435 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7436 // start recorder 7437 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7438 // pause recorder 7439 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7440 // resume recorder 7441 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7442 // stop recorder 7443 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7444 // release avRecorder and camera 7445 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7446 // end 7447 END_EVENT 7448 ); 7449 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7450 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0400 end') 7451 }) 7452 7453 /* * 7454 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0500 7455 * @tc.name : 05.AVRecorder recording(audioBitrate 112000,audioSampleRate 96000,videoBitrateRange 2240000) 7456 * @tc.desc : Recorder video 7457 * @tc.size : MediumTest 7458 * @tc.type : Function test 7459 * @tc.level : Level2 7460 */ 7461 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0500', 0, async function (done) { 7462 if (!isSupportCameraVideoProfiles) { 7463 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7464 expect(true).assertTrue(); 7465 done(); 7466 } 7467 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0500 start') 7468 7469 avProfileMpegAac.audioBitrate = 112000 7470 avProfileMpegAac.audioSampleRate = 96000 7471 avProfileMpegAac.videoBitrate = 2240000 7472 7473 let fileName = avVideoRecorderTestBase.resourceName() 7474 fdObject = await mediaTestBase.getFd(fileName); 7475 fdPath = "fd://" + fdObject.fdNumber; 7476 avConfigMpegAac.url = fdPath; 7477 let mySteps = new Array( 7478 // init avRecorder 7479 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7480 // init camera 7481 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7482 // start recorder 7483 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7484 // pause recorder 7485 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7486 // resume recorder 7487 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7488 // stop recorder 7489 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7490 // release avRecorder and camera 7491 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7492 // end 7493 END_EVENT 7494 ); 7495 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7496 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0500 end') 7497 }) 7498 7499 /* * 7500 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0600 7501 * @tc.name : 06.AVRecorder recording orientationHint:90 7502 * @tc.desc : Recorder video 7503 * @tc.size : MediumTest 7504 * @tc.type : Function test 7505 * @tc.level : Level2 7506 */ 7507 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0600', 0, async function (done) { 7508 if (!isSupportCameraVideoProfiles) { 7509 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7510 expect(true).assertTrue(); 7511 done(); 7512 } 7513 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0600 start') 7514 7515 avConfigMpegAac.orientationHint = 90 7516 7517 let fileName = avVideoRecorderTestBase.resourceName() 7518 fdObject = await mediaTestBase.getFd(fileName); 7519 fdPath = "fd://" + fdObject.fdNumber; 7520 avConfigMpegAac.url = fdPath; 7521 let mySteps = new Array( 7522 // init avRecorder 7523 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7524 // init camera 7525 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7526 // start recorder 7527 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7528 // pause recorder 7529 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7530 // resume recorder 7531 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7532 // stop recorder 7533 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7534 // release avRecorder and camera 7535 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7536 // end 7537 END_EVENT 7538 ); 7539 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7540 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0600 end') 7541 }) 7542 7543 /* * 7544 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0700 7545 * @tc.name : 07.AVRecorder recording orientationHint:180 7546 * @tc.desc : Recorder video 7547 * @tc.size : MediumTest 7548 * @tc.type : Function test 7549 * @tc.level : Level2 7550 */ 7551 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0700', 0, async function (done) { 7552 if (!isSupportCameraVideoProfiles) { 7553 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7554 expect(true).assertTrue(); 7555 done(); 7556 } 7557 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0700 start') 7558 7559 avConfigMpegAac.orientationHint = 180 7560 7561 let fileName = avVideoRecorderTestBase.resourceName() 7562 fdObject = await mediaTestBase.getFd(fileName); 7563 fdPath = "fd://" + fdObject.fdNumber; 7564 avConfigMpegAac.url = fdPath; 7565 let mySteps = new Array( 7566 // init avRecorder 7567 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7568 // init camera 7569 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7570 // start recorder 7571 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7572 // pause recorder 7573 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7574 // resume recorder 7575 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7576 // stop recorder 7577 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7578 // release avRecorder and camera 7579 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7580 // end 7581 END_EVENT 7582 ); 7583 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7584 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0700 end') 7585 }) 7586 7587 /* * 7588 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0800 7589 * @tc.name : 08.AVRecorder recording orientationHint:270 7590 * @tc.desc : Recorder video 7591 * @tc.size : MediumTest 7592 * @tc.type : Function test 7593 * @tc.level : Level2 7594 */ 7595 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0800', 0, async function (done) { 7596 if (!isSupportCameraVideoProfiles) { 7597 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7598 expect(true).assertTrue(); 7599 done(); 7600 } 7601 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0800 start') 7602 7603 avConfigMpegAac.orientationHint = 270 7604 7605 let fileName = avVideoRecorderTestBase.resourceName() 7606 fdObject = await mediaTestBase.getFd(fileName); 7607 fdPath = "fd://" + fdObject.fdNumber; 7608 avConfigMpegAac.url = fdPath; 7609 let mySteps = new Array( 7610 // init avRecorder 7611 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7612 // init camera 7613 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7614 // start recorder 7615 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7616 // pause recorder 7617 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7618 // resume recorder 7619 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7620 // stop recorder 7621 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7622 // release avRecorder and camera 7623 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7624 // end 7625 END_EVENT 7626 ); 7627 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7628 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0800 end') 7629 }) 7630 7631 /* * 7632 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0900 7633 * @tc.name : 09.AVRecorder recording videoFrameRate:5 7634 * @tc.desc : Recorder video 7635 * @tc.size : MediumTest 7636 * @tc.type : Function test 7637 * @tc.level : Level2 7638 */ 7639 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0900', 0, async function (done) { 7640 if (!isSupportCameraVideoProfiles) { 7641 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7642 expect(true).assertTrue(); 7643 done(); 7644 } 7645 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0900 start') 7646 7647 avProfileMpegAac.videoFrameRate = 5 7648 7649 let fileName = avVideoRecorderTestBase.resourceName() 7650 fdObject = await mediaTestBase.getFd(fileName); 7651 fdPath = "fd://" + fdObject.fdNumber; 7652 avConfigMpegAac.url = fdPath; 7653 let mySteps = new Array( 7654 // init avRecorder 7655 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7656 // init camera 7657 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7658 // start recorder 7659 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7660 // pause recorder 7661 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7662 // resume recorder 7663 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7664 // stop recorder 7665 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7666 // release avRecorder and camera 7667 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7668 // end 7669 END_EVENT 7670 ); 7671 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7672 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_0900 end') 7673 }) 7674 7675 /* * 7676 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1000 7677 * @tc.name : 10.AVRecorder recording videoFrameRate:30 7678 * @tc.desc : Recorder video 7679 * @tc.size : MediumTest 7680 * @tc.type : Function test 7681 * @tc.level : Level2 7682 */ 7683 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1000', 0, async function (done) { 7684 if (!isSupportCameraVideoProfiles) { 7685 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7686 expect(true).assertTrue(); 7687 done(); 7688 } 7689 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1000 start') 7690 7691 avProfileMpegAac.videoFrameRate = 30 7692 7693 let fileName = avVideoRecorderTestBase.resourceName() 7694 fdObject = await mediaTestBase.getFd(fileName); 7695 fdPath = "fd://" + fdObject.fdNumber; 7696 avConfigMpegAac.url = fdPath; 7697 let mySteps = new Array( 7698 // init avRecorder 7699 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7700 // init camera 7701 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7702 // start recorder 7703 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7704 // pause recorder 7705 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7706 // resume recorder 7707 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7708 // stop recorder 7709 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7710 // release avRecorder and camera 7711 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7712 // end 7713 END_EVENT 7714 ); 7715 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7716 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1000 end') 7717 }) 7718 7719 /* * 7720 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1200 7721 * @tc.name : 12.AVRecorder Record MPEG4 7722 * @tc.desc : Recorder video 7723 * @tc.size : MediumTest 7724 * @tc.type : Function test 7725 * @tc.level : Level2 7726 */ 7727 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1200', 0, async function (done) { 7728 if (!isSupportCameraVideoProfiles) { 7729 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7730 expect(true).assertTrue(); 7731 done(); 7732 } 7733 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1200 start') 7734 7735 let fileName = avVideoRecorderTestBase.resourceName() 7736 fdObject = await mediaTestBase.getFd(fileName); 7737 fdPath = "fd://" + fdObject.fdNumber; 7738 avConfigMpeg.url = fdPath 7739 let mySteps = new Array( 7740 // init avRecorder 7741 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 7742 // init camera 7743 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 7744 // start recorder 7745 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 7746 // pause recorder 7747 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7748 // resume recorder 7749 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 7750 // stop recorder 7751 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 7752 // release avRecorder and camera 7753 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 7754 // end 7755 END_EVENT 7756 ); 7757 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpeg, recorderTime, mySteps, done); 7758 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_MPEG4_1200 end') 7759 }) 7760 7761 /* * 7762 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0100 7763 * @tc.name : 001.test 1，record 3s； 2，pause 3，resume 4，stop 5，restart 7764 * @tc.desc : Recorder video 1，record 3s； 2，pause 3，resume 4，stop 5，restart 7765 * @tc.size : MediumTest 7766 * @tc.type : Function test 7767 * @tc.level : Level2 7768 */ 7769 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0100', 0, async function (done) { 7770 if (!isSupportCameraVideoProfiles) { 7771 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7772 expect(true).assertTrue(); 7773 done(); 7774 } 7775 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0100 start') 7776 let fileName = avVideoRecorderTestBase.resourceName() 7777 fdObject = await mediaTestBase.getFd(fileName); 7778 fdPath = "fd://" + fdObject.fdNumber; 7779 avConfigMpegAac.url = fdPath; 7780 7781 let mySteps = new Array( 7782 // init avRecorder 7783 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7784 // init camera 7785 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7786 // start recorder 7787 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7788 // pause recorder 7789 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7790 // resume recorder 7791 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 7792 // stop recorder 7793 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7794 // release avRecorder and camera 7795 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7796 // end 7797 END_EVENT 7798 ); 7799 7800 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7801 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0100 end') 7802 }) 7803 7804 /* * 7805 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0200 7806 * @tc.name : 02.AVRecorder recording(audioBitrate 8000,audioSampleRate 8000,videoBitrateRange 280000) 7807 * @tc.desc : Recorder video 7808 * @tc.size : MediumTest 7809 * @tc.type : Function test 7810 * @tc.level : Level2 7811 */ 7812 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0200', 0, async function (done) { 7813 if (!isSupportCameraVideoProfiles) { 7814 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7815 expect(true).assertTrue(); 7816 done(); 7817 } 7818 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0200 start') 7819 7820 avProfileMpegAac.audioBitrate = 8000 7821 avProfileMpegAac.audioSampleRate = 8000 7822 avProfileMpegAac.videoBitrate = 280000 7823 7824 let fileName = avVideoRecorderTestBase.resourceName() 7825 fdObject = await mediaTestBase.getFd(fileName); 7826 fdPath = "fd://" + fdObject.fdNumber; 7827 avConfigMpegAac.url = fdPath; 7828 7829 let mySteps = new Array( 7830 // init avRecorder 7831 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7832 // init camera 7833 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7834 // start recorder 7835 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7836 // pause recorder 7837 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7838 // resume recorder 7839 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 7840 // stop recorder 7841 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7842 // release avRecorder and camera 7843 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7844 // end 7845 END_EVENT 7846 ); 7847 7848 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7849 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0200 end') 7850 }) 7851 7852 /* * 7853 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0300 7854 * @tc.name : 03.AVRecorder recording(audioBitrate 16000,audioSampleRate 32000,videoBitrateRange 560000) 7855 * @tc.desc : Recorder video 7856 * @tc.size : MediumTest 7857 * @tc.type : Function test 7858 * @tc.level : Level2 7859 */ 7860 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0300', 0, async function (done) { 7861 if (!isSupportCameraVideoProfiles) { 7862 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7863 expect(true).assertTrue(); 7864 done(); 7865 } 7866 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0300 start') 7867 7868 avProfileMpegAac.audioBitrate = 16000 7869 avProfileMpegAac.audioSampleRate = 32000 7870 avProfileMpegAac.videoBitrate = 560000 7871 7872 let fileName = avVideoRecorderTestBase.resourceName() 7873 fdObject = await mediaTestBase.getFd(fileName); 7874 fdPath = "fd://" + fdObject.fdNumber; 7875 avConfigMpegAac.url = fdPath; 7876 7877 let mySteps = new Array( 7878 // init avRecorder 7879 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7880 // init camera 7881 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7882 // start recorder 7883 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7884 // pause recorder 7885 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7886 // resume recorder 7887 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 7888 // stop recorder 7889 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7890 // release avRecorder and camera 7891 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7892 // end 7893 END_EVENT 7894 ); 7895 7896 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7897 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0300 end') 7898 }) 7899 7900 /* * 7901 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0400 7902 * @tc.name : 04.AVRecorder recording(audioBitrate 32000,audioSampleRate 44100,videoBitrateRange 1120000) 7903 * @tc.desc : Recorder video 7904 * @tc.size : MediumTest 7905 * @tc.type : Function test 7906 * @tc.level : Level2 7907 */ 7908 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0400', 0, async function (done) { 7909 if (!isSupportCameraVideoProfiles) { 7910 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7911 expect(true).assertTrue(); 7912 done(); 7913 } 7914 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0400 start') 7915 7916 avProfileMpegAac.audioBitrate = 32000 7917 avProfileMpegAac.audioSampleRate = 44100 7918 avProfileMpegAac.videoBitrate = 1120000 7919 7920 let fileName = avVideoRecorderTestBase.resourceName() 7921 fdObject = await mediaTestBase.getFd(fileName); 7922 fdPath = "fd://" + fdObject.fdNumber; 7923 avConfigMpegAac.url = fdPath; 7924 7925 let mySteps = new Array( 7926 // init avRecorder 7927 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7928 // init camera 7929 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7930 // start recorder 7931 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7932 // pause recorder 7933 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7934 // resume recorder 7935 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 7936 // stop recorder 7937 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7938 // release avRecorder and camera 7939 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7940 // end 7941 END_EVENT 7942 ); 7943 7944 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7945 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0400 end') 7946 }) 7947 7948 /* * 7949 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0500 7950 * @tc.name : 05.AVRecorder recording(audioBitrate 112000,audioSampleRate 96000,videoBitrateRange 2240000) 7951 * @tc.desc : Recorder video 7952 * @tc.size : MediumTest 7953 * @tc.type : Function test 7954 * @tc.level : Level2 7955 */ 7956 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0500', 0, async function (done) { 7957 if (!isSupportCameraVideoProfiles) { 7958 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 7959 expect(true).assertTrue(); 7960 done(); 7961 } 7962 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0500 start') 7963 7964 avProfileMpegAac.audioBitrate = 112000 7965 avProfileMpegAac.audioSampleRate = 96000 7966 avProfileMpegAac.videoBitrate = 2240000 7967 7968 let fileName = avVideoRecorderTestBase.resourceName() 7969 fdObject = await mediaTestBase.getFd(fileName); 7970 fdPath = "fd://" + fdObject.fdNumber; 7971 avConfigMpegAac.url = fdPath; 7972 7973 let mySteps = new Array( 7974 // init avRecorder 7975 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 7976 // init camera 7977 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 7978 // start recorder 7979 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 7980 // pause recorder 7981 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7982 // resume recorder 7983 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 7984 // stop recorder 7985 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 7986 // release avRecorder and camera 7987 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 7988 // end 7989 END_EVENT 7990 ); 7991 7992 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 7993 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0500 end') 7994 }) 7995 7996 /* * 7997 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0600 7998 * @tc.name : 06.AVRecorder recording orientationHint:90 7999 * @tc.desc : Recorder video 8000 * @tc.size : MediumTest 8001 * @tc.type : Function test 8002 * @tc.level : Level2 8003 */ 8004 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0600', 0, async function (done) { 8005 if (!isSupportCameraVideoProfiles) { 8006 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8007 expect(true).assertTrue(); 8008 done(); 8009 } 8010 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0600 start') 8011 8012 avConfigMpegAac.orientationHint = 90 8013 8014 let fileName = avVideoRecorderTestBase.resourceName() 8015 fdObject = await mediaTestBase.getFd(fileName); 8016 fdPath = "fd://" + fdObject.fdNumber; 8017 avConfigMpegAac.url = fdPath; 8018 8019 let mySteps = new Array( 8020 // init avRecorder 8021 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8022 // init camera 8023 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8024 // start recorder 8025 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8026 // pause recorder 8027 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8028 // resume recorder 8029 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8030 // stop recorder 8031 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8032 // release avRecorder and camera 8033 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8034 // end 8035 END_EVENT 8036 ); 8037 8038 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 8039 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0600 end') 8040 }) 8041 8042 /* * 8043 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0700 8044 * @tc.name : 07.AVRecorder recording orientationHint:180 8045 * @tc.desc : Recorder video 8046 * @tc.size : MediumTest 8047 * @tc.type : Function test 8048 * @tc.level : Level2 8049 */ 8050 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0700', 0, async function (done) { 8051 if (!isSupportCameraVideoProfiles) { 8052 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8053 expect(true).assertTrue(); 8054 done(); 8055 } 8056 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0700 start') 8057 8058 avConfigMpegAac.orientationHint = 180 8059 8060 let fileName = avVideoRecorderTestBase.resourceName() 8061 fdObject = await mediaTestBase.getFd(fileName); 8062 fdPath = "fd://" + fdObject.fdNumber; 8063 avConfigMpegAac.url = fdPath; 8064 8065 let mySteps = new Array( 8066 // init avRecorder 8067 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8068 // init camera 8069 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8070 // start recorder 8071 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8072 // pause recorder 8073 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8074 // resume recorder 8075 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8076 // stop recorder 8077 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8078 // release avRecorder and camera 8079 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8080 // end 8081 END_EVENT 8082 ); 8083 8084 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 8085 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0700 end') 8086 }) 8087 8088 /* * 8089 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0800 8090 * @tc.name : 08.AVRecorder recording orientationHint:270 8091 * @tc.desc : Recorder video 8092 * @tc.size : MediumTest 8093 * @tc.type : Function test 8094 * @tc.level : Level2 8095 */ 8096 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0800', 0, async function (done) { 8097 if (!isSupportCameraVideoProfiles) { 8098 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8099 expect(true).assertTrue(); 8100 done(); 8101 } 8102 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0800 start') 8103 8104 avConfigMpegAac.orientationHint = 270 8105 8106 let fileName = avVideoRecorderTestBase.resourceName() 8107 fdObject = await mediaTestBase.getFd(fileName); 8108 fdPath = "fd://" + fdObject.fdNumber; 8109 avConfigMpegAac.url = fdPath; 8110 8111 let mySteps = new Array( 8112 // init avRecorder 8113 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8114 // init camera 8115 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8116 // start recorder 8117 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8118 // pause recorder 8119 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8120 // resume recorder 8121 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8122 // stop recorder 8123 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8124 // release avRecorder and camera 8125 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8126 // end 8127 END_EVENT 8128 ); 8129 8130 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 8131 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0800 end') 8132 }) 8133 8134 // /* * 8135 // * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0900 8136 // * @tc.name : 09.AVRecorder recording videoFrameRate:5 8137 // * @tc.desc : Recorder video (test failed) 8138 // * @tc.size : MediumTest 8139 // * @tc.type : Function test 8140 // * @tc.level : Level2 8141 // */ 8142 // it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0900', 0, async function (done) { 8143 // if (!isSupportCameraVideoProfiles) { 8144 // console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8145 // expect(true).assertTrue(); 8146 // done(); 8147 // } 8148 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0900 start') 8149 // 8150 // avProfileMpegAac.videoFrameRate = 5 8151 // 8152 // let fileName = avVideoRecorderTestBase.resourceName() 8153 // fdObject = await mediaTestBase.getFd(fileName); 8154 // fdPath = "fd://" + fdObject.fdNumber; 8155 // avConfigMpegAac.url = fdPath; 8156 // 8157 // let mySteps = new Array( 8158 // // init avRecorder 8159 // CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8160 // // init camera 8161 // GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8162 // // start recorder 8163 // STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8164 // // pause recorder 8165 // PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8166 // // resume recorder 8167 // STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8168 // // stop recorder 8169 // STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8170 // // release avRecorder and camera 8171 // RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8172 // // end 8173 // END_EVENT 8174 // ); 8175 // 8176 // eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 8177 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_0900 end') 8178 // }) 8179 8180 /* * 8181 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1000 8182 * @tc.name : 10.AVRecorder recording videoFrameRate:30 8183 * @tc.desc : Recorder video 8184 * @tc.size : MediumTest 8185 * @tc.type : Function test 8186 * @tc.level : Level2 8187 */ 8188 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1000', 0, async function (done) { 8189 if (!isSupportCameraVideoProfiles) { 8190 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8191 expect(true).assertTrue(); 8192 done(); 8193 } 8194 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1000 start') 8195 8196 avProfileMpegAac.videoFrameRate = 30 8197 8198 let fileName = avVideoRecorderTestBase.resourceName() 8199 fdObject = await mediaTestBase.getFd(fileName); 8200 fdPath = "fd://" + fdObject.fdNumber; 8201 avConfigMpegAac.url = fdPath; 8202 8203 let mySteps = new Array( 8204 // init avRecorder 8205 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8206 // init camera 8207 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8208 // start recorder 8209 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8210 // pause recorder 8211 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8212 // resume recorder 8213 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8214 // stop recorder 8215 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8216 // release avRecorder and camera 8217 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8218 // end 8219 END_EVENT 8220 ); 8221 8222 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpegAac, recorderTime, mySteps, done); 8223 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1000 end') 8224 }) 8225 8226 /* * 8227 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1200 8228 * @tc.name : 12.AVRecorder Record MPEG4 8229 * @tc.desc : Recorder video 8230 * @tc.size : MediumTest 8231 * @tc.type : Function test 8232 * @tc.level : Level2 8233 */ 8234 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1200', 0, async function (done) { 8235 if (!isSupportCameraVideoProfiles) { 8236 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8237 expect(true).assertTrue(); 8238 done(); 8239 } 8240 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1200 start') 8241 8242 let fileName = avVideoRecorderTestBase.resourceName() 8243 fdObject = await mediaTestBase.getFd(fileName); 8244 fdPath = "fd://" + fdObject.fdNumber; 8245 avConfigMpeg.url = fdPath 8246 8247 let mySteps = new Array( 8248 // init avRecorder 8249 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8250 // init camera 8251 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8252 // start recorder 8253 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8254 // pause recorder 8255 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8256 // resume recorder 8257 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8258 // stop recorder 8259 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8260 // release avRecorder and camera 8261 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8262 // end 8263 END_EVENT 8264 ); 8265 8266 eventEmitter.emit(mySteps[0], avRecorder, avConfigMpeg, recorderTime, mySteps, done); 8267 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_MPEG4_1200 end') 8268 }) 8269 8270 /* * 8271 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0100 8272 * @tc.name : 01.AVRecorder Record H264+AAC 8273 * @tc.desc : Recorder video 8274 * @tc.size : MediumTest 8275 * @tc.type : Function test 8276 * @tc.level : Level2 8277 */ 8278 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0100', 0, async function (done) { 8279 if (!isSupportCameraVideoProfiles) { 8280 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8281 expect(true).assertTrue(); 8282 done(); 8283 } 8284 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0100 start') 8285 let fileName = avVideoRecorderTestBase.resourceName() 8286 fdObject = await mediaTestBase.getFd(fileName); 8287 fdPath = "fd://" + fdObject.fdNumber; 8288 avConfigH264Aac.url = fdPath; 8289 let mySteps = new Array( 8290 // init avRecorder 8291 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8292 // init camera 8293 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8294 // start recorder 8295 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8296 // pause recorder 8297 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8298 // resume recorder 8299 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8300 // stop recorder 8301 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8302 // release avRecorder and camera 8303 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8304 // end 8305 END_EVENT 8306 ); 8307 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8308 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0100 end') 8309 }) 8310 8311 /* * 8312 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0200 8313 * @tc.name : 02.AVRecorder recording(audioBitrate 8000,audioSampleRate 8000,videoBitrateRange 280000) 8314 * @tc.desc : Recorder video 8315 * @tc.size : MediumTest 8316 * @tc.type : Function test 8317 * @tc.level : Level2 8318 */ 8319 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0200', 0, async function (done) { 8320 if (!isSupportCameraVideoProfiles) { 8321 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8322 expect(true).assertTrue(); 8323 done(); 8324 } 8325 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0200 start') 8326 8327 avProfileH264Aac.audioBitrate = 8000 8328 avProfileH264Aac.audioSampleRate = 8000 8329 avProfileH264Aac.videoBitrate = 280000 8330 8331 let fileName = avVideoRecorderTestBase.resourceName() 8332 fdObject = await mediaTestBase.getFd(fileName); 8333 fdPath = "fd://" + fdObject.fdNumber; 8334 avConfigH264Aac.url = fdPath; 8335 let mySteps = new Array( 8336 // init avRecorder 8337 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8338 // init camera 8339 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8340 // start recorder 8341 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8342 // pause recorder 8343 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8344 // resume recorder 8345 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8346 // stop recorder 8347 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8348 // release avRecorder and camera 8349 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8350 // end 8351 END_EVENT 8352 ); 8353 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8354 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0200 end') 8355 }) 8356 8357 /* * 8358 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0300 8359 * @tc.name : 03.AVRecorder recording(audioBitrate 16000,audioSampleRate 32000,videoBitrateRange 560000) 8360 * @tc.desc : Recorder video 8361 * @tc.size : MediumTest 8362 * @tc.type : Function test 8363 * @tc.level : Level2 8364 */ 8365 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0300', 0, async function (done) { 8366 if (!isSupportCameraVideoProfiles) { 8367 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8368 expect(true).assertTrue(); 8369 done(); 8370 } 8371 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0300 start') 8372 8373 avProfileH264Aac.audioBitrate = 16000 8374 avProfileH264Aac.audioSampleRate = 32000 8375 avProfileH264Aac.videoBitrate = 560000 8376 8377 let fileName = avVideoRecorderTestBase.resourceName() 8378 fdObject = await mediaTestBase.getFd(fileName); 8379 fdPath = "fd://" + fdObject.fdNumber; 8380 avConfigH264Aac.url = fdPath; 8381 let mySteps = new Array( 8382 // init avRecorder 8383 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8384 // init camera 8385 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8386 // start recorder 8387 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8388 // pause recorder 8389 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8390 // resume recorder 8391 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8392 // stop recorder 8393 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8394 // release avRecorder and camera 8395 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8396 // end 8397 END_EVENT 8398 ); 8399 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8400 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0300 end') 8401 }) 8402 8403 /* * 8404 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0400 8405 * @tc.name : 04.AVRecorder recording(audioBitrate 32000,audioSampleRate 44100,videoBitrateRange 1120000) 8406 * @tc.desc : Recorder video 8407 * @tc.size : MediumTest 8408 * @tc.type : Function test 8409 * @tc.level : Level2 8410 */ 8411 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0400', 0, async function (done) { 8412 if (!isSupportCameraVideoProfiles) { 8413 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8414 expect(true).assertTrue(); 8415 done(); 8416 } 8417 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0400 start') 8418 8419 avProfileH264Aac.audioBitrate = 32000 8420 avProfileH264Aac.audioSampleRate = 44100 8421 avProfileH264Aac.videoBitrate = 1120000 8422 8423 let fileName = avVideoRecorderTestBase.resourceName() 8424 fdObject = await mediaTestBase.getFd(fileName); 8425 fdPath = "fd://" + fdObject.fdNumber; 8426 avConfigH264Aac.url = fdPath; 8427 let mySteps = new Array( 8428 // init avRecorder 8429 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8430 // init camera 8431 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8432 // start recorder 8433 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8434 // pause recorder 8435 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8436 // resume recorder 8437 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8438 // stop recorder 8439 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8440 // release avRecorder and camera 8441 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8442 // end 8443 END_EVENT 8444 ); 8445 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8446 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0400 end') 8447 }) 8448 8449 /* * 8450 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0500 8451 * @tc.name : 05.AVRecorder recording(audioBitrate 112000,audioSampleRate 96000,videoBitrateRange 2240000) 8452 * @tc.desc : Recorder video 8453 * @tc.size : MediumTest 8454 * @tc.type : Function test 8455 * @tc.level : Level2 8456 */ 8457 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0500', 0, async function (done) { 8458 if (!isSupportCameraVideoProfiles) { 8459 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8460 expect(true).assertTrue(); 8461 done(); 8462 } 8463 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0500 start') 8464 8465 avProfileH264Aac.audioBitrate = 112000 8466 avProfileH264Aac.audioSampleRate = 96000 8467 avProfileH264Aac.videoBitrate = 2240000 8468 8469 let fileName = avVideoRecorderTestBase.resourceName() 8470 fdObject = await mediaTestBase.getFd(fileName); 8471 fdPath = "fd://" + fdObject.fdNumber; 8472 avConfigH264Aac.url = fdPath; 8473 let mySteps = new Array( 8474 // init avRecorder 8475 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8476 // init camera 8477 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8478 // start recorder 8479 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8480 // pause recorder 8481 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8482 // resume recorder 8483 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8484 // stop recorder 8485 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8486 // release avRecorder and camera 8487 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8488 // end 8489 END_EVENT 8490 ); 8491 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8492 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0500 end') 8493 }) 8494 8495 /* * 8496 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0600 8497 * @tc.name : 06.AVRecorder recording orientationHint:90 8498 * @tc.desc : Recorder video 8499 * @tc.size : MediumTest 8500 * @tc.type : Function test 8501 * @tc.level : Level2 8502 */ 8503 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0600', 0, async function (done) { 8504 if (!isSupportCameraVideoProfiles) { 8505 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8506 expect(true).assertTrue(); 8507 done(); 8508 } 8509 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0600 start') 8510 8511 avConfigH264Aac.orientationHint = 90 8512 8513 let fileName = avVideoRecorderTestBase.resourceName() 8514 fdObject = await mediaTestBase.getFd(fileName); 8515 fdPath = "fd://" + fdObject.fdNumber; 8516 avConfigH264Aac.url = fdPath; 8517 let mySteps = new Array( 8518 // init avRecorder 8519 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8520 // init camera 8521 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8522 // start recorder 8523 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8524 // pause recorder 8525 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8526 // resume recorder 8527 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8528 // stop recorder 8529 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8530 // release avRecorder and camera 8531 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8532 // end 8533 END_EVENT 8534 ); 8535 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8536 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0600 end') 8537 }) 8538 8539 /* * 8540 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0700 8541 * @tc.name : 07.AVRecorder recording orientationHint:180 8542 * @tc.desc : Recorder video 8543 * @tc.size : MediumTest 8544 * @tc.type : Function test 8545 * @tc.level : Level2 8546 */ 8547 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0700', 0, async function (done) { 8548 if (!isSupportCameraVideoProfiles) { 8549 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8550 expect(true).assertTrue(); 8551 done(); 8552 } 8553 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0700 start') 8554 8555 avConfigH264Aac.orientationHint = 180 8556 8557 let fileName = avVideoRecorderTestBase.resourceName() 8558 fdObject = await mediaTestBase.getFd(fileName); 8559 fdPath = "fd://" + fdObject.fdNumber; 8560 avConfigH264Aac.url = fdPath; 8561 let mySteps = new Array( 8562 // init avRecorder 8563 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8564 // init camera 8565 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8566 // start recorder 8567 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8568 // pause recorder 8569 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8570 // resume recorder 8571 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8572 // stop recorder 8573 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8574 // release avRecorder and camera 8575 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8576 // end 8577 END_EVENT 8578 ); 8579 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8580 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0700 end') 8581 }) 8582 8583 /* * 8584 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0800 8585 * @tc.name : 08.AVRecorder recording orientationHint:270 8586 * @tc.desc : Recorder video 8587 * @tc.size : MediumTest 8588 * @tc.type : Function test 8589 * @tc.level : Level2 8590 */ 8591 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0800', 0, async function (done) { 8592 if (!isSupportCameraVideoProfiles) { 8593 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8594 expect(true).assertTrue(); 8595 done(); 8596 } 8597 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0800 start') 8598 8599 avConfigH264Aac.orientationHint = 270 8600 8601 let fileName = avVideoRecorderTestBase.resourceName() 8602 fdObject = await mediaTestBase.getFd(fileName); 8603 fdPath = "fd://" + fdObject.fdNumber; 8604 avConfigH264Aac.url = fdPath; 8605 let mySteps = new Array( 8606 // init avRecorder 8607 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8608 // init camera 8609 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8610 // start recorder 8611 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8612 // pause recorder 8613 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8614 // resume recorder 8615 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8616 // stop recorder 8617 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8618 // release avRecorder and camera 8619 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8620 // end 8621 END_EVENT 8622 ); 8623 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8624 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0800 end') 8625 }) 8626 8627 /* * 8628 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0900 8629 * @tc.name : 09.AVRecorder recording videoFrameRate:5 8630 * @tc.desc : Recorder video 8631 * @tc.size : MediumTest 8632 * @tc.type : Function test 8633 * @tc.level : Level2 8634 */ 8635 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0900', 0, async function (done) { 8636 if (!isSupportCameraVideoProfiles) { 8637 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8638 expect(true).assertTrue(); 8639 done(); 8640 } 8641 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0900 start') 8642 8643 avProfileH264Aac.videoFrameRate = 5 8644 8645 let fileName = avVideoRecorderTestBase.resourceName() 8646 fdObject = await mediaTestBase.getFd(fileName); 8647 fdPath = "fd://" + fdObject.fdNumber; 8648 avConfigH264Aac.url = fdPath; 8649 let mySteps = new Array( 8650 // init avRecorder 8651 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8652 // init camera 8653 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8654 // start recorder 8655 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8656 // pause recorder 8657 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8658 // resume recorder 8659 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8660 // stop recorder 8661 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8662 // release avRecorder and camera 8663 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8664 // end 8665 END_EVENT 8666 ); 8667 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8668 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_0900 end') 8669 }) 8670 8671 /* * 8672 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1000 8673 * @tc.name : 10.AVRecorder recording videoFrameRate:30 8674 * @tc.desc : Recorder video 8675 * @tc.size : MediumTest 8676 * @tc.type : Function test 8677 * @tc.level : Level2 8678 */ 8679 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1000', 0, async function (done) { 8680 if (!isSupportCameraVideoProfiles) { 8681 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8682 expect(true).assertTrue(); 8683 done(); 8684 } 8685 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1000 start') 8686 8687 avProfileH264Aac.videoFrameRate = 30 8688 8689 let fileName = avVideoRecorderTestBase.resourceName() 8690 fdObject = await mediaTestBase.getFd(fileName); 8691 fdPath = "fd://" + fdObject.fdNumber; 8692 avConfigH264Aac.url = fdPath; 8693 let mySteps = new Array( 8694 // init avRecorder 8695 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8696 // init camera 8697 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8698 // start recorder 8699 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8700 // pause recorder 8701 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8702 // resume recorder 8703 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8704 // stop recorder 8705 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8706 // release avRecorder and camera 8707 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8708 // end 8709 END_EVENT 8710 ); 8711 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8712 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1000 end') 8713 }) 8714 8715 /* * 8716 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1200 8717 * @tc.name : 12.AVRecorder Record MPEG4 8718 * @tc.desc : Recorder video 8719 * @tc.size : MediumTest 8720 * @tc.type : Function test 8721 * @tc.level : Level2 8722 */ 8723 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1200', 0, async function (done) { 8724 if (!isSupportCameraVideoProfiles) { 8725 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8726 expect(true).assertTrue(); 8727 done(); 8728 } 8729 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1200 start') 8730 8731 let fileName = avVideoRecorderTestBase.resourceName() 8732 fdObject = await mediaTestBase.getFd(fileName); 8733 fdPath = "fd://" + fdObject.fdNumber; 8734 avConfigH264.url = fdPath 8735 let mySteps = new Array( 8736 // init avRecorder 8737 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 8738 // init camera 8739 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 8740 // start recorder 8741 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 8742 // pause recorder 8743 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8744 // resume recorder 8745 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 8746 // stop recorder 8747 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 8748 // release avRecorder and camera 8749 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 8750 // end 8751 END_EVENT 8752 ); 8753 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264, recorderTime, mySteps, done); 8754 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H264_1200 end') 8755 }) 8756 8757 // /* * 8758 // * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0100 8759 // * @tc.name : 01.AVRecorder Record H264+AAC 8760 // * @tc.desc : Recorder video (test failed) 8761 // * @tc.size : MediumTest 8762 // * @tc.type : Function test 8763 // * @tc.level : Level2 8764 // */ 8765 // it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0100', 0, async function (done) { 8766 // if (!isSupportCameraVideoProfiles) { 8767 // console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8768 // expect(true).assertTrue(); 8769 // done(); 8770 // } 8771 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0100 start') 8772 // let fileName = avVideoRecorderTestBase.resourceName() 8773 // fdObject = await mediaTestBase.getFd(fileName); 8774 // fdPath = "fd://" + fdObject.fdNumber; 8775 // avConfigH264Aac.url = fdPath; 8776 // 8777 // let mySteps = new Array( 8778 // // init avRecorder 8779 // CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8780 // // init camera 8781 // GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8782 // // start recorder 8783 // STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8784 // // pause recorder 8785 // PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8786 // // resume recorder 8787 // STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8788 // // stop recorder 8789 // STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8790 // // release avRecorder and camera 8791 // RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8792 // // end 8793 // END_EVENT 8794 // ); 8795 // 8796 // eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8797 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0100 end') 8798 // }) 8799 8800 /* * 8801 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0200 8802 * @tc.name : 02.AVRecorder recording(audioBitrate 8000,audioSampleRate 8000,videoBitrateRange 280000) 8803 * @tc.desc : Recorder video 8804 * @tc.size : MediumTest 8805 * @tc.type : Function test 8806 * @tc.level : Level2 8807 */ 8808 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0200', 0, async function (done) { 8809 if (!isSupportCameraVideoProfiles) { 8810 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8811 expect(true).assertTrue(); 8812 done(); 8813 } 8814 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0200 start') 8815 8816 avProfileH264Aac.audioBitrate = 8000 8817 avProfileH264Aac.audioSampleRate = 8000 8818 avProfileH264Aac.videoBitrate = 280000 8819 8820 let fileName = avVideoRecorderTestBase.resourceName() 8821 fdObject = await mediaTestBase.getFd(fileName); 8822 fdPath = "fd://" + fdObject.fdNumber; 8823 avConfigH264Aac.url = fdPath; 8824 8825 let mySteps = new Array( 8826 // init avRecorder 8827 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8828 // init camera 8829 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8830 // start recorder 8831 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8832 // pause recorder 8833 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8834 // resume recorder 8835 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8836 // stop recorder 8837 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8838 // release avRecorder and camera 8839 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8840 // end 8841 END_EVENT 8842 ); 8843 8844 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8845 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0200 end') 8846 }) 8847 8848 /* * 8849 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0300 8850 * @tc.name : 03.AVRecorder recording(audioBitrate 16000,audioSampleRate 32000,videoBitrateRange 560000) 8851 * @tc.desc : Recorder video 8852 * @tc.size : MediumTest 8853 * @tc.type : Function test 8854 * @tc.level : Level2 8855 */ 8856 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0300', 0, async function (done) { 8857 if (!isSupportCameraVideoProfiles) { 8858 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8859 expect(true).assertTrue(); 8860 done(); 8861 } 8862 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0300 start') 8863 8864 avProfileH264Aac.audioBitrate = 16000 8865 avProfileH264Aac.audioSampleRate = 32000 8866 avProfileH264Aac.videoBitrate = 560000 8867 8868 let fileName = avVideoRecorderTestBase.resourceName() 8869 fdObject = await mediaTestBase.getFd(fileName); 8870 fdPath = "fd://" + fdObject.fdNumber; 8871 avConfigH264Aac.url = fdPath; 8872 8873 let mySteps = new Array( 8874 // init avRecorder 8875 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8876 // init camera 8877 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8878 // start recorder 8879 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8880 // pause recorder 8881 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8882 // resume recorder 8883 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8884 // stop recorder 8885 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8886 // release avRecorder and camera 8887 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8888 // end 8889 END_EVENT 8890 ); 8891 8892 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8893 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0300 end') 8894 }) 8895 8896 /* * 8897 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0400 8898 * @tc.name : 04.AVRecorder recording(audioBitrate 32000,audioSampleRate 44100,videoBitrateRange 1120000) 8899 * @tc.desc : Recorder video 8900 * @tc.size : MediumTest 8901 * @tc.type : Function test 8902 * @tc.level : Level2 8903 */ 8904 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0400', 0, async function (done) { 8905 if (!isSupportCameraVideoProfiles) { 8906 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8907 expect(true).assertTrue(); 8908 done(); 8909 } 8910 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0400 start') 8911 8912 avProfileH264Aac.audioBitrate = 32000 8913 avProfileH264Aac.audioSampleRate = 44100 8914 avProfileH264Aac.videoBitrate = 1120000 8915 8916 let fileName = avVideoRecorderTestBase.resourceName() 8917 fdObject = await mediaTestBase.getFd(fileName); 8918 fdPath = "fd://" + fdObject.fdNumber; 8919 avConfigH264Aac.url = fdPath; 8920 8921 let mySteps = new Array( 8922 // init avRecorder 8923 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8924 // init camera 8925 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8926 // start recorder 8927 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8928 // pause recorder 8929 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8930 // resume recorder 8931 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8932 // stop recorder 8933 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8934 // release avRecorder and camera 8935 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8936 // end 8937 END_EVENT 8938 ); 8939 8940 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8941 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0400 end') 8942 }) 8943 8944 /* * 8945 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0500 8946 * @tc.name : 05.AVRecorder recording(audioBitrate 112000,audioSampleRate 96000,videoBitrateRange 2240000) 8947 * @tc.desc : Recorder video 8948 * @tc.size : MediumTest 8949 * @tc.type : Function test 8950 * @tc.level : Level2 8951 */ 8952 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0500', 0, async function (done) { 8953 if (!isSupportCameraVideoProfiles) { 8954 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 8955 expect(true).assertTrue(); 8956 done(); 8957 } 8958 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0500 start') 8959 8960 avProfileH264Aac.audioBitrate = 112000 8961 avProfileH264Aac.audioSampleRate = 96000 8962 avProfileH264Aac.videoBitrate = 2240000 8963 8964 let fileName = avVideoRecorderTestBase.resourceName() 8965 fdObject = await mediaTestBase.getFd(fileName); 8966 fdPath = "fd://" + fdObject.fdNumber; 8967 avConfigH264Aac.url = fdPath; 8968 8969 let mySteps = new Array( 8970 // init avRecorder 8971 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 8972 // init camera 8973 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 8974 // start recorder 8975 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 8976 // pause recorder 8977 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8978 // resume recorder 8979 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 8980 // stop recorder 8981 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 8982 // release avRecorder and camera 8983 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 8984 // end 8985 END_EVENT 8986 ); 8987 8988 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 8989 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0500 end') 8990 }) 8991 8992 /* * 8993 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0600 8994 * @tc.name : 06.AVRecorder recording orientationHint:90 8995 * @tc.desc : Recorder video 8996 * @tc.size : MediumTest 8997 * @tc.type : Function test 8998 * @tc.level : Level2 8999 */ 9000 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0600', 0, async function (done) { 9001 if (!isSupportCameraVideoProfiles) { 9002 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9003 expect(true).assertTrue(); 9004 done(); 9005 } 9006 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0600 start') 9007 9008 avConfigH264Aac.orientationHint = 90 9009 9010 let fileName = avVideoRecorderTestBase.resourceName() 9011 fdObject = await mediaTestBase.getFd(fileName); 9012 fdPath = "fd://" + fdObject.fdNumber; 9013 avConfigH264Aac.url = fdPath; 9014 9015 let mySteps = new Array( 9016 // init avRecorder 9017 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9018 // init camera 9019 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9020 // start recorder 9021 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9022 // pause recorder 9023 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9024 // resume recorder 9025 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9026 // stop recorder 9027 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9028 // release avRecorder and camera 9029 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9030 // end 9031 END_EVENT 9032 ); 9033 9034 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9035 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0600 end') 9036 }) 9037 9038 /* * 9039 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0700 9040 * @tc.name : 07.AVRecorder recording orientationHint:180 9041 * @tc.desc : Recorder video 9042 * @tc.size : MediumTest 9043 * @tc.type : Function test 9044 * @tc.level : Level2 9045 */ 9046 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0700', 0, async function (done) { 9047 if (!isSupportCameraVideoProfiles) { 9048 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9049 expect(true).assertTrue(); 9050 done(); 9051 } 9052 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0700 start') 9053 9054 avConfigH264Aac.orientationHint = 180 9055 9056 let fileName = avVideoRecorderTestBase.resourceName() 9057 fdObject = await mediaTestBase.getFd(fileName); 9058 fdPath = "fd://" + fdObject.fdNumber; 9059 avConfigH264Aac.url = fdPath; 9060 9061 let mySteps = new Array( 9062 // init avRecorder 9063 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9064 // init camera 9065 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9066 // start recorder 9067 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9068 // pause recorder 9069 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9070 // resume recorder 9071 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9072 // stop recorder 9073 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9074 // release avRecorder and camera 9075 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9076 // end 9077 END_EVENT 9078 ); 9079 9080 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9081 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0700 end') 9082 }) 9083 9084 /* * 9085 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0800 9086 * @tc.name : 08.AVRecorder recording orientationHint:270 9087 * @tc.desc : Recorder video 9088 * @tc.size : MediumTest 9089 * @tc.type : Function test 9090 * @tc.level : Level2 9091 */ 9092 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0800', 0, async function (done) { 9093 if (!isSupportCameraVideoProfiles) { 9094 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9095 expect(true).assertTrue(); 9096 done(); 9097 } 9098 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0800 start') 9099 9100 avConfigH264Aac.orientationHint = 270 9101 9102 let fileName = avVideoRecorderTestBase.resourceName() 9103 fdObject = await mediaTestBase.getFd(fileName); 9104 fdPath = "fd://" + fdObject.fdNumber; 9105 avConfigH264Aac.url = fdPath; 9106 9107 let mySteps = new Array( 9108 // init avRecorder 9109 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9110 // init camera 9111 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9112 // start recorder 9113 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9114 // pause recorder 9115 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9116 // resume recorder 9117 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9118 // stop recorder 9119 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9120 // release avRecorder and camera 9121 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9122 // end 9123 END_EVENT 9124 ); 9125 9126 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9127 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0800 end') 9128 }) 9129 9130 // /* * 9131 // * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0900 9132 // * @tc.name : 09.AVRecorder recording videoFrameRate:5 9133 // * @tc.desc : Recorder video (test failed) 9134 // * @tc.size : MediumTest 9135 // * @tc.type : Function test 9136 // * @tc.level : Level2 9137 // */ 9138 // it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0900', 0, async function (done) { 9139 // if (!isSupportCameraVideoProfiles) { 9140 // console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9141 // expect(true).assertTrue(); 9142 // done(); 9143 // } 9144 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0900 start') 9145 // 9146 // avProfileH264Aac.videoFrameRate = 5 9147 // 9148 // let fileName = avVideoRecorderTestBase.resourceName() 9149 // fdObject = await mediaTestBase.getFd(fileName); 9150 // fdPath = "fd://" + fdObject.fdNumber; 9151 // avConfigH264Aac.url = fdPath; 9152 // 9153 // let mySteps = new Array( 9154 // // init avRecorder 9155 // CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9156 // // init camera 9157 // GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9158 // // start recorder 9159 // STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9160 // // pause recorder 9161 // PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9162 // // resume recorder 9163 // STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9164 // // stop recorder 9165 // STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9166 // // release avRecorder and camera 9167 // RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9168 // // end 9169 // END_EVENT 9170 // ); 9171 // 9172 // eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9173 // console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_0900 end') 9174 // }) 9175 9176 /* * 9177 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1000 9178 * @tc.name : 10.AVRecorder recording videoFrameRate:30 9179 * @tc.desc : Recorder video 9180 * @tc.size : MediumTest 9181 * @tc.type : Function test 9182 * @tc.level : Level2 9183 */ 9184 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1000', 0, async function (done) { 9185 if (!isSupportCameraVideoProfiles) { 9186 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9187 expect(true).assertTrue(); 9188 done(); 9189 } 9190 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1000 start') 9191 9192 avProfileH264Aac.videoFrameRate = 30 9193 9194 let fileName = avVideoRecorderTestBase.resourceName() 9195 fdObject = await mediaTestBase.getFd(fileName); 9196 fdPath = "fd://" + fdObject.fdNumber; 9197 avConfigH264Aac.url = fdPath; 9198 9199 let mySteps = new Array( 9200 // init avRecorder 9201 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9202 // init camera 9203 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9204 // start recorder 9205 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9206 // pause recorder 9207 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9208 // resume recorder 9209 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9210 // stop recorder 9211 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9212 // release avRecorder and camera 9213 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9214 // end 9215 END_EVENT 9216 ); 9217 9218 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9219 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1000 end') 9220 }) 9221 9222 /* * 9223 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1200 9224 * @tc.name : 12.AVRecorder Record MPEG4 9225 * @tc.desc : Recorder video 9226 * @tc.size : MediumTest 9227 * @tc.type : Function test 9228 * @tc.level : Level2 9229 */ 9230 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1200', 0, async function (done) { 9231 if (!isSupportCameraVideoProfiles) { 9232 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9233 expect(true).assertTrue(); 9234 done(); 9235 } 9236 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1200 start') 9237 9238 let fileName = avVideoRecorderTestBase.resourceName() 9239 fdObject = await mediaTestBase.getFd(fileName); 9240 fdPath = "fd://" + fdObject.fdNumber; 9241 avConfigH264.url = fdPath 9242 9243 let mySteps = new Array( 9244 // init avRecorder 9245 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9246 // init camera 9247 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9248 // start recorder 9249 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9250 // pause recorder 9251 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9252 // resume recorder 9253 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9254 // stop recorder 9255 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9256 // release avRecorder and camera 9257 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9258 // end 9259 END_EVENT 9260 ); 9261 9262 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264, recorderTime, mySteps, done); 9263 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H264_1200 end') 9264 }) 9265 9266 /* * 9267 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETAVRECORDERCONFIG_PROMISE_0100 9268 * @tc.name : 02. prepare->getAVRecorderConfig 9269 * @tc.desc : 1.create 2.prepare 3.getAVRecorderConfig 9270 * @tc.size : MediumTest 9271 * @tc.type : Function 9272 * @tc.level : Level 2 9273 */ 9274 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETAVRECORDERCONFIG_PROMISE_0100', 0, async function (done) { 9275 if (!isSupportCameraVideoProfiles) { 9276 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9277 expect(true).assertTrue(); 9278 done(); 9279 } 9280 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETAVRECORDERCONFIG_PROMISE_0100 start') 9281 let fileName = avVideoRecorderTestBase.resourceName() 9282 fdObject = await mediaTestBase.getFd(fileName); 9283 fdPath = "fd://" + fdObject.fdNumber; 9284 avConfigH264Aac.url = fdPath; 9285 let mySteps = new Array( 9286 // init avRecorder 9287 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 9288 // init camera 9289 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 9290 // getAVRecorderConfigPromise 9291 GETAVRECORDERCONFIG_PROMISE_EVENT, 9292 // release avRecorder and camera 9293 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 9294 // end 9295 END_EVENT 9296 ); 9297 eventEmitter.emit(mySteps[0], avRecorder, avConfigH264Aac, recorderTime, mySteps, done); 9298 9299 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_GETAVRECORDERCONFIG_PROMISE_0100 end') 9300 }) 9301 9302 /* * 9303 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H265_0100 9304 * @tc.name : 01.AVRecorder Record H265+AAC 9305 * @tc.desc : Recorder video 9306 * @tc.size : MediumTest 9307 * @tc.type : Function test 9308 * @tc.level : Level2 9309 */ 9310 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H265_0100', 0, async function (done) { 9311 if (!isSupportCameraVideoProfiles) { 9312 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9313 expect(true).assertTrue(); 9314 done(); 9315 } 9316 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H265_0100 start') 9317 if (deviceInfo.deviceInfo === 'default') { 9318 avConfigH265Aac.videoCodec = media.CodecMimeType.VIDEO_AVC 9319 } 9320 let fileName = avVideoRecorderTestBase.resourceName() 9321 fdObject = await mediaTestBase.getFd(fileName); 9322 fdPath = "fd://" + fdObject.fdNumber; 9323 avConfigH265Aac.url = fdPath; 9324 let mySteps = new Array( 9325 // init avRecorder 9326 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, PREPARE_PROMISE_EVENT, 9327 // init camera 9328 GETINPUTSURFACE_PROMISE_EVENT, INITCAMERA_EVENT, 9329 // start recorder 9330 STARTCAMERA_EVENT, STARTRECORDER_PROMISE_EVENT, 9331 // pause recorder 9332 PAUSERECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 9333 // resume recorder 9334 STARTCAMERA_EVENT, RESUMERECORDER_PROMISE_EVENT, 9335 // stop recorder 9336 STOPRECORDER_PROMISE_EVENT, STOPCAMERA_EVENT, 9337 // release avRecorder and camera 9338 RELEASECORDER_PROMISE_EVENT, RELEASECAMERA_EVENT, 9339 // end 9340 END_EVENT 9341 ); 9342 eventEmitter.emit(mySteps[0], avRecorder, avConfigH265Aac, recorderTime, mySteps, done); 9343 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_PROMISE_H265_0100 end') 9344 }) 9345 9346 /* * 9347 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0100 9348 * @tc.name : 01.AVRecorder Record H265+AAC 9349 * @tc.desc : Recorder video 9350 * @tc.size : MediumTest 9351 * @tc.type : Function test 9352 * @tc.level : Level2 9353 */ 9354 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0100', 0, async function (done) { 9355 if (!isSupportCameraVideoProfiles) { 9356 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9357 expect(true).assertTrue(); 9358 done(); 9359 } 9360 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0100 start') 9361 if (deviceInfo.deviceInfo === 'default') { 9362 avConfigH265Aac.videoCodec = media.CodecMimeType.VIDEO_AVC 9363 } 9364 let fileName = avVideoRecorderTestBase.resourceName() 9365 fdObject = await mediaTestBase.getFd(fileName); 9366 fdPath = "fd://" + fdObject.fdNumber; 9367 avConfigH265Aac.url = fdPath; 9368 9369 let mySteps = new Array( 9370 // init avRecorder 9371 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9372 // init camera 9373 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9374 // start recorder 9375 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9376 // pause recorder 9377 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9378 // resume recorder 9379 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9380 // stop recorder 9381 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9382 // release avRecorder and camera 9383 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9384 // end 9385 END_EVENT 9386 ); 9387 9388 eventEmitter.emit(mySteps[0], avRecorder, avConfigH265Aac, recorderTime, mySteps, done); 9389 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0100 end') 9390 }) 9391 9392 /* * 9393 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0200 9394 * @tc.name : 02.AVRecorder Record isHdr 9395 * @tc.desc : Recorder video 9396 * @tc.size : MediumTest 9397 * @tc.type : Function test 9398 * @tc.level : Level2 9399 */ 9400 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0200', 0, async function (done) { 9401 if (!isSupportCameraVideoProfiles) { 9402 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9403 expect(true).assertTrue(); 9404 done(); 9405 } 9406 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0200 start') 9407 if (deviceInfo.deviceInfo === 'default') { 9408 avConfigH265Aac.videoCodec = media.CodecMimeType.VIDEO_AVC 9409 } 9410 let fileName = avVideoRecorderTestBase.resourceName() 9411 fdObject = await mediaTestBase.getFd(fileName); 9412 fdPath = "fd://" + fdObject.fdNumber; 9413 avConfigH265Aac.url = fdPath 9414 avConfigH265Aac.isHdr = false 9415 9416 let mySteps = new Array( 9417 // init avRecorder 9418 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9419 // init camera 9420 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9421 // start recorder 9422 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9423 // pause recorder 9424 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9425 // resume recorder 9426 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9427 // stop recorder 9428 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9429 // release avRecorder and camera 9430 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9431 // end 9432 END_EVENT 9433 ); 9434 9435 eventEmitter.emit(mySteps[0], avRecorder, avConfigH265Aac, recorderTime, mySteps, done); 9436 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_FUNCTION_CALLBACK_H265_0200 end') 9437 }) 9438 9439 /* * 9440 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_CALLBACK_0100 9441 * @tc.name : 13.AVRecorder getCurrentAudioCapturerInfo 9442 * @tc.desc : Recorder video 9443 * @tc.size : MediumTest 9444 * @tc.type : Function test 9445 * @tc.level : Level2 9446 */ 9447 it('SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_CALLBACK_0100', 0, async function (done) { 9448 if (!isSupportCameraVideoProfiles) { 9449 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9450 expect(true).assertTrue(); 9451 done(); 9452 } 9453 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_CALLBACK_0100 start') 9454 9455 let fileName = avVideoRecorderTestBase.resourceName() 9456 fdObject = await mediaTestBase.getFd(fileName); 9457 fdPath = "fd://" + fdObject.fdNumber; 9458 avConfigOnlyAac.url = fdPath 9459 9460 let mySteps = new Array( 9461 // init avRecorder 9462 CREATE_CALLBACK_EVENT, 9463 // prepare avRecorder 9464 PREPARE_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT, 9465 // start recorder 9466 STARTRECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT, 9467 // pause recorder 9468 PAUSERECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT, 9469 // resume recorder 9470 RESUMERECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_CALLBACK_EVENT, 9471 // stop recorder 9472 STOPRECORDER_CALLBACK_EVENT, 9473 // release avRecorder and camera 9474 RELEASECORDER_CALLBACK_EVENT, 9475 // end 9476 END_EVENT 9477 ); 9478 9479 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9480 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_CALLBACK_0100 end') 9481 }) 9482 9483 /* * 9484 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_CALLBACK_0100 9485 * @tc.name : 13.AVRecorder getAvailableEncoder 9486 * @tc.desc : Recorder video 9487 * @tc.size : MediumTest 9488 * @tc.type : Function test 9489 * @tc.level : Level2 9490 */ 9491 it('SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_CALLBACK_0100', 0, async function (done) { 9492 if (!isSupportCameraVideoProfiles) { 9493 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9494 expect(true).assertTrue(); 9495 done(); 9496 } 9497 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_CALLBACK_0100 start') 9498 9499 let fileName = avVideoRecorderTestBase.resourceName() 9500 fdObject = await mediaTestBase.getFd(fileName); 9501 fdPath = "fd://" + fdObject.fdNumber; 9502 avConfigOnlyAac.url = fdPath 9503 9504 let mySteps = new Array( 9505 // init avRecorder 9506 CREATE_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9507 // prepare avRecorder 9508 PREPARE_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9509 // start recorder 9510 STARTRECORDER_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9511 // pause recorder 9512 PAUSERECORDER_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9513 // resume recorder 9514 RESUMERECORDER_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9515 // stop recorder 9516 STOPRECORDER_CALLBACK_EVENT, ENCODER_INFO_CALLBACK_EVENT, 9517 // release avRecorder and camera 9518 RELEASECORDER_CALLBACK_EVENT, 9519 // end 9520 END_EVENT 9521 ); 9522 9523 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9524 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_CALLBACK_0100 end') 9525 }) 9526 9527 /* * 9528 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_CALLBACK_0100 9529 * @tc.name : 13.AVRecorder getMaxAmplitude 9530 * @tc.desc : Recorder video 9531 * @tc.size : MediumTest 9532 * @tc.type : Function test 9533 * @tc.level : Level2 9534 */ 9535 it('SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_CALLBACK_0100', 0, async function (done) { 9536 if (!isSupportCameraVideoProfiles) { 9537 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9538 expect(true).assertTrue(); 9539 done(); 9540 } 9541 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_CALLBACK_0100 start') 9542 9543 let fileName = avVideoRecorderTestBase.resourceName() 9544 fdObject = await mediaTestBase.getFd(fileName); 9545 fdPath = "fd://" + fdObject.fdNumber; 9546 avConfigOnlyAac.url = fdPath 9547 9548 let mySteps = new Array( 9549 // init avRecorder 9550 CREATE_CALLBACK_EVENT, 9551 // prepare avRecorder 9552 PREPARE_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, 9553 // start recorder 9554 STARTRECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, 9555 // pause recorder 9556 PAUSERECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, 9557 // resume recorder 9558 RESUMERECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, MAX_AMPLITUDE_CALLBACK_EVENT, 9559 // stop recorder 9560 STOPRECORDER_CALLBACK_EVENT, 9561 // release avRecorder and camera 9562 RELEASECORDER_CALLBACK_EVENT, 9563 // end 9564 END_EVENT 9565 ); 9566 9567 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9568 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_CALLBACK_0100 end') 9569 }) 9570 9571 /* * 9572 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_PROMISE_0100 9573 * @tc.name : 13.AVRecorder getCurrentAudioCapturerInfo 9574 * @tc.desc : Recorder video 9575 * @tc.size : MediumTest 9576 * @tc.type : Function test 9577 * @tc.level : Level2 9578 */ 9579 it('SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_PROMISE_0100', 0, async function (done) { 9580 if (!isSupportCameraVideoProfiles) { 9581 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9582 expect(true).assertTrue(); 9583 done(); 9584 } 9585 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_PROMISE_0100 start') 9586 9587 let fileName = avVideoRecorderTestBase.resourceName() 9588 fdObject = await mediaTestBase.getFd(fileName); 9589 fdPath = "fd://" + fdObject.fdNumber; 9590 avConfigOnlyAac.url = fdPath 9591 9592 let mySteps = new Array( 9593 // init avRecorder 9594 CREATE_CALLBACK_EVENT, 9595 // prepare avRecorder 9596 PREPARE_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT, 9597 // start recorder 9598 STARTRECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT, 9599 // pause recorder 9600 PAUSERECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT, 9601 // resume recorder 9602 RESUMERECORDER_CALLBACK_EVENT, CURRENT_AUDIOCAPTURER_INFO_PROMISE_EVENT, 9603 // stop recorder 9604 STOPRECORDER_CALLBACK_EVENT, 9605 // release avRecorder and camera 9606 RELEASECORDER_CALLBACK_EVENT, 9607 // end 9608 END_EVENT 9609 ); 9610 9611 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9612 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_CURRENT_CAPTURER_INFO_PROMISE_0100 end') 9613 }) 9614 9615 /* * 9616 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_PROMISE_0100 9617 * @tc.name : 13.AVRecorder getAvailableEncoder 9618 * @tc.desc : Recorder video 9619 * @tc.size : MediumTest 9620 * @tc.type : Function test 9621 * @tc.level : Level2 9622 */ 9623 it('SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_PROMISE_0100', 0, async function (done) { 9624 if (!isSupportCameraVideoProfiles) { 9625 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9626 expect(true).assertTrue(); 9627 done(); 9628 } 9629 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_PROMISE_0100 start') 9630 9631 let fileName = avVideoRecorderTestBase.resourceName() 9632 fdObject = await mediaTestBase.getFd(fileName); 9633 fdPath = "fd://" + fdObject.fdNumber; 9634 avConfigOnlyAac.url = fdPath 9635 9636 let mySteps = new Array( 9637 // init avRecorder 9638 CREATE_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9639 // prepare avRecorder 9640 PREPARE_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9641 // start recorder 9642 STARTRECORDER_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9643 // pause recorder 9644 PAUSERECORDER_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9645 // resume recorder 9646 RESUMERECORDER_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9647 // stop recorder 9648 STOPRECORDER_CALLBACK_EVENT, ENCODER_INFO_PROMISE_EVENT, 9649 // release avRecorder and camera 9650 RELEASECORDER_CALLBACK_EVENT, 9651 // end 9652 END_EVENT 9653 ); 9654 9655 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9656 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_AVAILABLE_ENCODER_PROMISE_0100 end') 9657 }) 9658 9659 /* * 9660 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_PROMISE_0100 9661 * @tc.name : 13.AVRecorder getMaxAmplitude 9662 * @tc.desc : Recorder video 9663 * @tc.size : MediumTest 9664 * @tc.type : Function test 9665 * @tc.level : Level2 9666 */ 9667 it('SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_PROMISE_0100', 0, async function (done) { 9668 if (!isSupportCameraVideoProfiles) { 9669 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9670 expect(true).assertTrue(); 9671 done(); 9672 } 9673 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_PROMISE_0100 start') 9674 9675 let fileName = avVideoRecorderTestBase.resourceName() 9676 fdObject = await mediaTestBase.getFd(fileName); 9677 fdPath = "fd://" + fdObject.fdNumber; 9678 avConfigOnlyAac.url = fdPath 9679 9680 let mySteps = new Array( 9681 // init avRecorder 9682 CREATE_CALLBACK_EVENT, 9683 // prepare avRecorder 9684 PREPARE_CALLBACK_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, 9685 // start recorder 9686 STARTRECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, 9687 // pause recorder 9688 PAUSERECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, 9689 // resume recorder 9690 RESUMERECORDER_CALLBACK_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, MAX_AMPLITUDE_PROMISE_EVENT, 9691 // stop recorder 9692 STOPRECORDER_CALLBACK_EVENT, 9693 // release avRecorder and camera 9694 RELEASECORDER_CALLBACK_EVENT, 9695 // end 9696 END_EVENT 9697 ); 9698 9699 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9700 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_GET_MAX_AMPLITUDE_PROMISE_0100 end') 9701 }) 9702 9703 /* * 9704 * @tc.number : SUM_MULTIMEDIA_MEDIA_ERRORCODE_ENUM_0100 9705 * @tc.name : ErrorCode 9706 * @tc.desc : Test Enumerate ErrorCode 9707 * @tc.size : MediumTest 9708 * @tc.type : Function test 9709 * @tc.level : Level2 9710 */ 9711 it('SUM_MULTIMEDIA_MEDIA_ERRORCODE_ENUM_0100', 0, async function (done) { 9712 if (!isSupportCameraVideoProfiles) { 9713 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9714 expect(true).assertTrue(); 9715 done(); 9716 } 9717 let newErrorCode = media.AVErrorCode.AVERR_AUDIO_INTERRUPTED; 9718 console.info('AVERR_AUDIO_INTERRUPTED:' + newErrorCode); 9719 done(); 9720 }) 9721 9722 /* * 9723 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_SET_UPDATE_ROTATION_0100 9724 * @tc.name : AVRecorder updateRotation 9725 * @tc.desc : Recorder video 9726 * @tc.size : MediumTest 9727 * @tc.type : Function test 9728 * @tc.level : Level3 9729 */ 9730 it('SUM_MULTIMEDIA_AVRECORDER_UPDATE_ROTATION_0100', 0, async function (done) { 9731 if (!isSupportCameraVideoProfiles) { 9732 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9733 expect(true).assertTrue(); 9734 done(); 9735 } 9736 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_UPDATE_ROTATION__0100 start') 9737 9738 let fileName = avVideoRecorderTestBase.resourceName() 9739 fdObject = await mediaTestBase.getFd(fileName); 9740 fdPath = "fd://" + fdObject.fdNumber; 9741 avConfigOnlyAac.url = fdPath 9742 9743 let mySteps = new Array( 9744 // init avRecorder 9745 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, 9746 //prepare avRecorder 9747 PREPARE_CALLBACK_EVENT, 9748 //update rotation 9749 UPDATE_ROTATION_EVENT, 9750 // release avRecorder and camera 9751 RELEASECORDER_CALLBACK_EVENT, 9752 // end 9753 END_EVENT 9754 ); 9755 9756 eventEmitter.emit(mySteps[0], avRecorder, avConfigOnlyAac, recorderTime, mySteps, done); 9757 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_UPDATE_ROTATION__0100 end') 9758 }) 9759 9760 /* * 9761 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_CREATE_0100 9762 * @tc.name : AVVideoRecorder 9763 * @tc.desc : Recorder video 9764 * @tc.size : MediumTest 9765 * @tc.type : Function test 9766 * @tc.level : Level3 9767 */ 9768 it('SUM_MULTIMEDIA_AVRECORDER_CREATE_0100', 0, async function (done) { 9769 if (!isSupportCameraVideoProfiles) { 9770 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9771 expect(true).assertTrue(); 9772 done(); 9773 } 9774 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_CREATE_0100 start') 9775 media.createVideoRecorder((videoRecorder) => { 9776 9777 }) 9778 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_CREATE_0100 end') 9779 done(); 9780 }) 9781 9782 /* * 9783 * @tc.number : SUM_MULTIMEDIA_AVRECORDER_CREATE_0200 9784 * @tc.name : AVVideoRecorder 9785 * @tc.desc : Recorder video 9786 * @tc.size : MediumTest 9787 * @tc.type : Function test 9788 * @tc.level : Level3 9789 */ 9790 it('SUM_MULTIMEDIA_AVRECORDER_CREATE_0200', 0, async function (done) { 9791 if (!isSupportCameraVideoProfiles) { 9792 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9793 expect(true).assertTrue(); 9794 done(); 9795 } 9796 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_CREATE_0200 start') 9797 try { 9798 media.createVideoRecorder(); 9799 } catch(error) { 9800 9801 } 9802 9803 console.info(TAG + 'SUM_MULTIMEDIA_AVRECORDER_CREATE_0200 end') 9804 done(); 9805 }) 9806 9807 /* * 9808 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0100 9809 * @tc.name : 09.metadata 9810 * @tc.desc : recorder (metadata) 9811 * @tc.size : MediumTest 9812 * @tc.type : Function 9813 * @tc.level : Level 2 9814 */ 9815 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0100', 0, async function (done) { 9816 if (!isSupportCameraVideoProfiles) { 9817 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9818 expect(true).assertTrue(); 9819 done(); 9820 } 9821 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0100 start') 9822 let fileName = avVideoRecorderTestBase.resourceName() 9823 fdObject = await mediaTestBase.getFd(fileName); 9824 fdPath = "fd://" + fdObject.fdNumber; 9825 avmetaConfig.url = fdPath; 9826 checkDevice(avmetaConfig) 9827 let mySteps = new Array( 9828 // init avRecorder 9829 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 9830 // init camera 9831 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 9832 // start recorder 9833 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 9834 // pause recorder 9835 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9836 // resume recorder 9837 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 9838 // stop recorder 9839 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 9840 // release avRecorder and camera 9841 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 9842 // end 9843 END_EVENT 9844 ); 9845 eventEmitter.emit(mySteps[0], avRecorder, avmetaConfig, recorderTime, mySteps, done); 9846 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AVMETADATA_0100 end') 9847 }) 9848 9849 /* * 9850 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 9851 * @tc.name : 09.metadata customInfo(number) 9852 * @tc.desc : recorder (metadata) 9853 * @tc.size : MediumTest 9854 * @tc.type : Function 9855 * @tc.level : Level 2 9856 */ 9857 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200', 0, async function (done) { 9858 if (!isSupportCameraVideoProfiles) { 9859 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9860 expect(true).assertTrue(); 9861 done(); 9862 } 9863 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 start') 9864 let customInfo = { 9865 "test02": 1000, 9866 } 9867 avmetaConfig.metadata.customInfo = customInfo; 9868 let fileName = avVideoRecorderTestBase.resourceName() 9869 fdObject = await mediaTestBase.getFd(fileName); 9870 fdPath = "fd://" + fdObject.fdNumber; 9871 avmetaConfig.url = fdPath; 9872 checkDevice(avmetaConfig) 9873 let mySteps = new Array( 9874 // setAvRecorderCallback 9875 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 9876 // prepareErrPromise 9877 PREPARE_PROMISE_EVENT, 9878 // AVRecorderTestBase.releasePromise 9879 RELEASECORDER_PROMISE_EVENT, 9880 // end 9881 END_EVENT 9882 ); 9883 eventEmitter.emit(mySteps[0], avRecorder, avmetaConfig, recorderTime, mySteps, done); 9884 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 end') 9885 }) 9886 9887 /* * 9888 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 9889 * @tc.name : 09.metadata videoOrientation(99) 9890 * @tc.desc : recorder (metadata) 9891 * @tc.size : MediumTest 9892 * @tc.type : Function 9893 * @tc.level : Level 2 9894 */ 9895 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200', 0, async function (done) { 9896 if (!isSupportCameraVideoProfiles) { 9897 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9898 expect(true).assertTrue(); 9899 done(); 9900 } 9901 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 start') 9902 9903 avmetaConfig.metadata.videoOrientation = "99"; 9904 let fileName = avVideoRecorderTestBase.resourceName() 9905 fdObject = await mediaTestBase.getFd(fileName); 9906 fdPath = "fd://" + fdObject.fdNumber; 9907 avmetaConfig.url = fdPath; 9908 checkDevice(avmetaConfig) 9909 let mySteps = new Array( 9910 // setAvRecorderCallback 9911 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 9912 // prepareErrPromise 9913 PREPARE_PROMISE_EVENT, 9914 // AVRecorderTestBase.releasePromise 9915 RELEASECORDER_PROMISE_EVENT, 9916 // end 9917 END_EVENT 9918 ); 9919 eventEmitter.emit(mySteps[0], avRecorder, avmetaConfig, recorderTime, mySteps, done); 9920 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_METADATA_0200 end') 9921 }) 9922 9923 /* * 9924 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0100 9925 * @tc.name : 01.AVRecorder set AudioSourceType 9926 * @tc.desc : AudioSourceType set AUDIO_SOURCE_TYPE_VOICE_RECOGNITION 9927 * @tc.size : MediumTest 9928 * @tc.type : Function 9929 * @tc.level : Level 2 9930 */ 9931 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0100', 0, async function (done) { 9932 if (!isSupportCameraVideoProfiles) { 9933 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9934 expect(true).assertTrue(); 9935 done(); 9936 } 9937 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0100 start') 9938 let avNewConfig = { 9939 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_VOICE_RECOGNITION, 9940 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 9941 profile : avProfile, 9942 url : 'fd://35', 9943 rotation : 0, 9944 location : { latitude : 30, longitude : 130 } 9945 } 9946 let fileName = avVideoRecorderTestBase.resourceName() 9947 fdObject = await mediaTestBase.getFd(fileName); 9948 fdPath = "fd://" + fdObject.fdNumber; 9949 avNewConfig.url = fdPath; 9950 checkDevice(avNewConfig) 9951 let mySteps = new Array( 9952 // setAvRecorderCallback 9953 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 9954 // prepareErrPromise 9955 PREPARE_PROMISE_EVENT, 9956 // AVRecorderTestBase.releasePromise 9957 RELEASECORDER_PROMISE_EVENT, 9958 // end 9959 END_EVENT 9960 ); 9961 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 9962 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0100 end') 9963 }) 9964 9965 /* * 9966 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0200 9967 * @tc.name : 02.AVRecorder set AudioSourceType 9968 * @tc.desc : AudioSourceType set AUDIO_SOURCE_TYPE_VOICE_COMMUNICATION 9969 * @tc.size : MediumTest 9970 * @tc.type : Function 9971 * @tc.level : Level 2 9972 */ 9973 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0200', 0, async function (done) { 9974 if (!isSupportCameraVideoProfiles) { 9975 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 9976 expect(true).assertTrue(); 9977 done(); 9978 } 9979 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0200 start') 9980 let avNewConfig = { 9981 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_VOICE_COMMUNICATION, 9982 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 9983 profile : avProfile, 9984 url : 'fd://35', 9985 rotation : 0, 9986 location : { latitude : 30, longitude : 130 } 9987 } 9988 let fileName = avVideoRecorderTestBase.resourceName() 9989 fdObject = await mediaTestBase.getFd(fileName); 9990 fdPath = "fd://" + fdObject.fdNumber; 9991 avNewConfig.url = fdPath; 9992 checkDevice(avNewConfig) 9993 let mySteps = new Array( 9994 // setAvRecorderCallback 9995 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 9996 // prepareErrPromise 9997 PREPARE_PROMISE_EVENT, 9998 // AVRecorderTestBase.releasePromise 9999 RELEASECORDER_PROMISE_EVENT, 10000 // end 10001 END_EVENT 10002 ); 10003 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 10004 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0200 end') 10005 }) 10006 10007 /* * 10008 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0300 10009 * @tc.name : 03.AVRecorder set AudioSourceType 10010 * @tc.desc : AudioSourceType set AUDIO_SOURCE_TYPE_VOICE_MESSAGE 10011 * @tc.size : MediumTest 10012 * @tc.type : Function 10013 * @tc.level : Level 2 10014 */ 10015 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0300', 0, async function (done) { 10016 if (!isSupportCameraVideoProfiles) { 10017 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 10018 expect(true).assertTrue(); 10019 done(); 10020 } 10021 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0300 start') 10022 let avNewConfig = { 10023 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_VOICE_MESSAGE, 10024 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 10025 profile : avProfile, 10026 url : 'fd://35', 10027 rotation : 0, 10028 location : { latitude : 30, longitude : 130 } 10029 } 10030 let fileName = avVideoRecorderTestBase.resourceName() 10031 fdObject = await mediaTestBase.getFd(fileName); 10032 fdPath = "fd://" + fdObject.fdNumber; 10033 avNewConfig.url = fdPath; 10034 checkDevice(avNewConfig) 10035 let mySteps = new Array( 10036 // setAvRecorderCallback 10037 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 10038 // prepareErrPromise 10039 PREPARE_PROMISE_EVENT, 10040 // AVRecorderTestBase.releasePromise 10041 RELEASECORDER_PROMISE_EVENT, 10042 // end 10043 END_EVENT 10044 ); 10045 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 10046 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0300 end') 10047 }) 10048 10049 /* * 10050 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0400 10051 * @tc.name : 04.AVRecorder set AudioSourceType 10052 * @tc.desc : AudioSourceType set AUDIO_SOURCE_TYPE_CAMCORDER 10053 * @tc.size : MediumTest 10054 * @tc.type : Function 10055 * @tc.level : Level 2 10056 */ 10057 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0400', 0, async function (done) { 10058 if (!isSupportCameraVideoProfiles) { 10059 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 10060 expect(true).assertTrue(); 10061 done(); 10062 } 10063 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0400 start') 10064 let avNewConfig = { 10065 audioSourceType : media.AudioSourceType.AUDIO_SOURCE_TYPE_CAMCORDER, 10066 videoSourceType : media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_ES, 10067 profile : avProfile, 10068 url : 'fd://35', 10069 rotation : 0, 10070 location : { latitude : 30, longitude : 130 } 10071 } 10072 let fileName = avVideoRecorderTestBase.resourceName() 10073 fdObject = await mediaTestBase.getFd(fileName); 10074 fdPath = "fd://" + fdObject.fdNumber; 10075 avNewConfig.url = fdPath; 10076 checkDevice(avNewConfig) 10077 let mySteps = new Array( 10078 // setAvRecorderCallback 10079 CREATE_PROMISE_EVENT, SETONCALLBACK_EVENT, 10080 // prepareErrPromise 10081 PREPARE_PROMISE_EVENT, 10082 // AVRecorderTestBase.releasePromise 10083 RELEASECORDER_PROMISE_EVENT, 10084 // end 10085 END_EVENT 10086 ); 10087 eventEmitter.emit(mySteps[0], avRecorder, avConfig, recorderTime, mySteps, done); 10088 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUDIO_SOURCE_TYPE_0400 end') 10089 }) 10090 10091 /* * 10092 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0100 10093 * @tc.name : 09.FileGenerationMode 1 + url '' 10094 * @tc.desc : recorder 10095 * @tc.size : MediumTest 10096 * @tc.type : Function 10097 * @tc.level : Level 2 10098 */ 10099 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0100', 0, async function (done) { 10100 if (!isSupportCameraVideoProfiles) { 10101 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 10102 expect(true).assertTrue(); 10103 done(); 10104 } 10105 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0100 start') 10106 AutoCreateConfig.fileGenerationMode = media.FileGenerationMode.AUTO_CREATE_CAMERA_SCENE; 10107 10108 checkDevice(AutoCreateConfig) 10109 let mySteps = new Array( 10110 // init avRecorder 10111 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, SETPHOTOASSETCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 10112 // init camera 10113 GETINPUTSURFACE_CALLBACK_EVENT, INITCAMERA_EVENT, 10114 // start recorder 10115 STARTCAMERA_EVENT, STARTRECORDER_CALLBACK_EVENT, 10116 // pause recorder 10117 PAUSERECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 10118 // resume recorder 10119 STARTCAMERA_EVENT, RESUMERECORDER_CALLBACK_EVENT, 10120 // stop recorder 10121 STOPRECORDER_CALLBACK_EVENT, STOPCAMERA_EVENT, 10122 // release avRecorder and camera 10123 RELEASECORDER_CALLBACK_EVENT, RELEASECAMERA_EVENT, 10124 // end 10125 END_EVENT 10126 ); 10127 eventEmitter.emit(mySteps[0], avRecorder, AutoCreateConfig, recorderTime, mySteps, done); 10128 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0100 end') 10129 }) 10130 10131 /* * 10132 * @tc.number : SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0200 10133 * @tc.name : 09.FileGenerationMode 0 + url '' 10134 * @tc.desc : recorder 10135 * @tc.size : MediumTest 10136 * @tc.type : Function 10137 * @tc.level : Level 2 10138 */ 10139 it('SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0200', 0, async function (done) { 10140 if (!isSupportCameraVideoProfiles) { 10141 console.info('Failed to obtain the default videoProfiles object.Not support usb camera'); 10142 expect(true).assertTrue(); 10143 done(); 10144 } 10145 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0200 start') 10146 AutoCreateConfig.fileGenerationMode = media.FileGenerationMode.APP_CREATE; 10147 10148 checkDevice(AutoCreateConfig) 10149 let mySteps = new Array( 10150 // init avRecorder 10151 CREATE_CALLBACK_EVENT, SETONCALLBACK_EVENT, SETPHOTOASSETCALLBACK_EVENT, PREPARE_CALLBACK_EVENT, 10152 // release avRecorde 10153 RELEASECORDER_CALLBACK_EVENT, 10154 // end 10155 END_EVENT 10156 ); 10157 eventEmitter.emit(mySteps[0], avRecorder, AutoCreateConfig, recorderTime, mySteps, done); 10158 console.info(TAG + 'SUB_MULTIMEDIA_AVRECORDER_VIDEO_AUTO_CREATE_FILE_0200 end') 10159 }) 10160 }) 10161} 10162