diff --git a/multimedia/camera/camera_js_standard/entry/src/main/ets/test/Camera.test.ets b/multimedia/camera/camera_js_standard/entry/src/main/ets/test/Camera.test.ets index 5c4db823b538aa111d556c7be39511f735185417..1c8f2c96daebca591334adbd3a11c1ff169153aa 100644 --- a/multimedia/camera/camera_js_standard/entry/src/main/ets/test/Camera.test.ets +++ b/multimedia/camera/camera_js_standard/entry/src/main/ets/test/Camera.test.ets @@ -22,9 +22,11 @@ import cameraSessionZoomRatioTest from './CameraSessionZoomRatioTest.test.ets' import cameraSessionVideoStabilizationTest from './CameraSessionVideoStabilizationTest.test.ets' import cameraSessionBaseTest from './CameraSessionBaseTest.test.ets' import cameraInputTest from './CameraInputTest.test.ets' +import CameraErrorCodeUsecaseTest from './CameraErrorCodeUsecaseTest.test.ets' import cameraManagerTest from './CameraManagerTest.test.ets' import cameraEnumTest from './CameraEnumTest.test.ets' + let TAG = 'CameraModuleTest: ' export default function cameraKit() { @@ -37,6 +39,7 @@ export default function cameraKit() { cameraSessionZoomRatioTest() cameraSessionVideoStabilizationTest() cameraSessionBaseTest() + CameraErrorCodeUsecaseTest() cameraManagerTest() cameraEnumTest() } \ No newline at end of file diff --git a/multimedia/camera/camera_js_standard/entry/src/main/ets/test/CameraErrorCodeUsecaseTest.test.ets b/multimedia/camera/camera_js_standard/entry/src/main/ets/test/CameraErrorCodeUsecaseTest.test.ets new file mode 100644 index 0000000000000000000000000000000000000000..c2d25834a9bc9a770f3df3927071d99efcdcf058 --- /dev/null +++ b/multimedia/camera/camera_js_standard/entry/src/main/ets/test/CameraErrorCodeUsecaseTest.test.ets @@ -0,0 +1,2342 @@ +/* + * Copyright (C) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import cameraObj from '@ohos.multimedia.camera'; +import image from '@ohos.multimedia.image'; +import media from '@ohos.multimedia.media'; +import mediaLibrary from '@ohos.multimedia.mediaLibrary'; +import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from '@ohos/hypium'; + +// 创建视频录制的参数 +let videoProfile = { + audioBitrate: 48000, + audioChannels: 2, + audioCodec: 'audio/mp4a-latm', + audioSampleRate: 48000, + fileFormat: 'mp4', + videoBitrate: 48000, + videoCodec: 'video/mp4v-es', + videoFrameWidth: 640, + videoFrameHeight: 480, + videoFrameRate: 30 + } + +let videoConfig = { + audioSourceType: 1, + videoSourceType: 0, + profile: videoProfile, + url: 'file:///data/media/CameraOutput.mp4', + orientationHint: 0, + location: { latitude: 30, longitude: 130 }, + maxSize: 100, + maxDuration: 500 + } + + let captureLocation = { + latitude: 0, + longitude: 0, + altitude: 0, + } + + let captureSetting = { + quality: cameraObj.QualityLevel.QUALITY_LEVEL_LOW, + rotation: cameraObj.ImageRotation.ROTATION_0, + location: captureLocation, + mirror: false + } + +const TAG = "CameraErrorCodeUsecaseTest: "; +let mCameraManager; +let cameraOutputCap; +let mCameraDevicesArray; +let mCameraSession; +let mCameraNum; +let mCameraInput; +let mPreviewOutput; +let mPhotoSurface; +let mPhotoOutput; +let videoOutput; +let videoRecorder; +let videoSurfaceId; +let fdPath; +let fileAsset; +let fdNumber; +let metadataOutput; +let mMetadataObjectTypeArray; + +export default function CameraErrorCodeUsecaseTest() { + function sleep(ms) { + console.info(TAG + "Entering sleep -> Promise constructor"); + return new Promise(resolve => setTimeout(resolve, ms)); + } + + function isEmpty(data) { + if (data == null || data == undefined) { + return true; + } + return false; + } + + function getCameraManagerInstance() { + console.info(TAG + 'Enter getCameraManagerInstance'); + mCameraManager = cameraObj.getCameraManager(null); + if (isEmpty(mCameraManager)) { + console.info(TAG + "getCameraManager FAILED"); + return false; + } + console.info(TAG + 'Exit getCameraManagerInstance'); + return true; + } + + function getCameraSupportDevicesArray() { + console.info(TAG + 'Enter getCameraSupportDevicesArray'); + mCameraDevicesArray = mCameraManager.getSupportedCameras(); + if (isEmpty(mCameraDevicesArray)) { + console.info(TAG + "getSupportedCameras FAILED"); + return false; + } + mCameraNum = mCameraDevicesArray.length; + console.info(TAG + "getCameraSupportDevicesArray is: " + mCameraNum); + console.info(TAG + 'Exit getCameraSupportDevicesArray'); + return true; + } + + async function createInput(idx:any) { + console.info(TAG + 'Enter createInput'); + if (isEmpty(mCameraDevicesArray)) { + console.info(TAG + "Entering createInputs FAILED with NoCamera"); + return false; + } + mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[idx]); + if (isEmpty(mCameraInput)) { + console.info(TAG + "createCameraInput FAILED"); + return false; + } + await mCameraInput.open(); + sleep(100); + console.info(idx + 'th CameraInput is: ' + mCameraInput); + console.info(TAG + 'Exit createInput'); + return true; + } + + function releaseInput() { + console.info(TAG + 'Enter releaseInput'); + + if (!isEmpty(mCameraInput)) { + mCameraInput.close(); + } + + console.info(TAG + 'Exit releaseInput'); + + return true; + } + + function beginCameraSessionConfig() { + console.info(TAG + 'Enter beginCameraSessionConfig'); + mCameraSession.beginConfig(); + console.info(TAG + 'Exit beginCameraSessionConfig'); + return true; + } + + async function commitCameraSessionConfig() { + console.info(TAG + 'Enter commitCameraSessionConfig'); + await mCameraSession.commitConfig(); + sleep(500); + console.info(TAG + 'Exit commitCameraSessionConfig'); + return true; + } + + function createCameraSessionInstance() { + console.info(TAG + 'Enter createCameraSessionInstance'); + try { + mCameraSession = mCameraManager.createCaptureSession(); + } + catch { + console.info(TAG + 'createCaptureSession FAILED'); + } + if (isEmpty(mCameraSession)) { + console.info(TAG + "createCaptureSession FAILED"); + return false; + } + beginCameraSessionConfig(); + console.info(TAG + 'Exit createCameraSessionInstance'); + return true; + } + + function releaseCameraSessionInstance() { + mCameraSession.release(); + } + + async function getPhotoReceiverSurface() { + console.log(TAG + 'Entering getPhotoReceiverSurface') + let receiver = image.createImageReceiver(640, 480, 4, 8) + console.log(TAG + 'before receiver check') + if (receiver !== undefined) { + console.log(TAG + 'Photo receiver is created successfully') + mPhotoSurface = await receiver.getReceivingSurfaceId() + console.log(TAG + 'Photo received id: ' + JSON.stringify(mPhotoSurface)) + } else { + console.log(TAG + 'Photo receiver is created failed') + } + console.log(TAG + 'Exit getPhotoReceiverSurface') + } + + async function getFd(pathName) { + let displayName = pathName; + const mediaTest = mediaLibrary.getMediaLibrary(); + let fileKeyObj = mediaLibrary.FileKey; + let mediaType = mediaLibrary.MediaType.VIDEO; + let publicPath = await mediaTest.getPublicDirectory(mediaLibrary.DirectoryType.DIR_VIDEO); + let dataUri = await mediaTest.createAsset(mediaType, displayName, publicPath); + if (dataUri != undefined) { + let args = dataUri.id.toString(); + let fetchOp = { + selections: fileKeyObj.ID + "=?", + selectionArgs: [args], + } + let fetchFileResult = await mediaTest.getFileAssets(fetchOp); + fileAsset = await fetchFileResult.getAllObject(); + fdNumber = await fileAsset[0].open('Rw'); + fdPath = "fd://" + fdNumber.toString(); + } + } + + async function closeFd() { + if (fileAsset != null) { + await fileAsset[0].close(fdNumber).then(() => { + console.info('[mediaLibrary] case close fd success'); + }).catch((err) => { + console.info('[mediaLibrary] case close fd failed'); + }); + } else { + console.info('[mediaLibrary] case fileAsset is null'); + } + } + + async function getvideosurface() { + await getFd('ErrorCodeCameraOutput.mp4'); + videoConfig.url = fdPath; + media.createVideoRecorder((err, recorder) => { + if (!err) { + console.info(TAG + 'createVideoRecorder called') + videoRecorder = recorder + console.info(TAG + 'videoRecorder is :' + JSON.stringify(videoRecorder)) + console.info(TAG + 'videoRecorder.prepare called.') + videoRecorder.prepare(videoConfig, (err) => { + if (!err) { + console.info(TAG + 'videoRecorder.prepare success.') + videoRecorder.getInputSurface((err, id) => { + console.info(TAG + 'getInputSurface called') + if (!err) { + videoSurfaceId = id + console.info(TAG + 'getInputSurface surfaceId: ' + JSON.stringify(videoSurfaceId)) + } else { + console.info(TAG + 'getInputSurface FAILED') + } + }) + } else { + console.info(TAG + 'prepare FAILED') + } + }) + } + else { + console.info(TAG + 'createVideoRecorder FAILED') + } + }) + } + + async function releaseVideoReceiveSurface() { + console.log(TAG + 'Entering releaseVideoReceiveSurface') + videoRecorder.release((err) => { + console.info(TAG + 'Entering release video receiver') + }) + await closeFd(); + console.log(TAG + 'Exit releaseVideoReceiveSurface') + } + + function createOutput(idx:any) { + console.info(TAG + 'Enter createOutput'); + cameraOutputCap = mCameraManager.getSupportedOutputCapability(mCameraDevicesArray[idx]); + if (!isEmpty(cameraOutputCap)) { + if (!isEmpty(cameraOutputCap.previewProfiles)) { + console.info(TAG + "cameraOutputCap.previewProfiles.length: " + cameraOutputCap.previewProfiles.length); + for (let i = 0; i < cameraOutputCap.previewProfiles.length; i++) { + mPreviewOutput = mCameraManager.createPreviewOutput(cameraOutputCap.previewProfiles[i], globalThis.surfaceId); + if (!isEmpty(mPreviewOutput)) { + break; + } + } + if (isEmpty(mPreviewOutput)) { + console.info(TAG + "createPreviewOutput FAILED"); + } + console.info(TAG + "createPreviewOutput: " + mPreviewOutput); + } + } + if (!isEmpty(cameraOutputCap.photoProfiles)) { + console.info(TAG + "cameraOutputCap.photoProfiles.length: " + cameraOutputCap.photoProfiles.length); + + for (let i = 0; i < cameraOutputCap.photoProfiles.length; i++) { + mPhotoOutput = mCameraManager.createPhotoOutput(cameraOutputCap.photoProfiles[i], mPhotoSurface); + if (!isEmpty(mPhotoOutput)) { + break; + } + } + if (isEmpty(mPhotoOutput)) { + console.info(TAG + "createPhotoOutput FAILED"); + } + console.info(TAG + "createPhotoOutput: " + mPhotoOutput); + } + if (!isEmpty(cameraOutputCap.supportedMetadataObjectTypes)) { + mMetadataObjectTypeArray = cameraOutputCap.supportedMetadataObjectTypes; + if (isEmpty(mMetadataObjectTypeArray)) { + console.info(TAG + "mMetadataObjectTypeArray is null"); + } else { + console.info(TAG + "createMetadataOutput") + metadataOutput = mCameraManager.createMetadataOutput(mMetadataObjectTypeArray); + } + } + console.info(TAG + 'Exit createOutputs'); + return true; + } + + describe('CameraErrorCodeUsecaseTest', function () { + console.info(TAG + '----------CameraErrorCodeUsecaseTest--------------'); + beforeAll(async function () { + await getPhotoReceiverSurface(); + await getvideosurface(); + getCameraManagerInstance(); + getCameraSupportDevicesArray(); + console.info(TAG + 'beforeAll case'); + }) + + beforeEach(function () { + sleep(1000); + console.info('beforeEach case'); + }) + + afterEach(async function () { + console.info('afterEach case'); + }) + + afterAll(function () { + releaseVideoReceiveSurface(); + sleep(1000); + console.info('afterAll case'); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100 + * @tc.name : createCameraInput api + * @tc.desc : createCameraInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let camerainput = mCameraManager.createCameraInput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200 + * @tc.name : createCameraInput api + * @tc.desc : createCameraInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let camerainput = mCameraManager.createCameraInput("cameraInput"); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300 + * @tc.name : createCameraInput api + * @tc.desc : createCameraInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let camerainput = mCameraManager.createCameraInput(null,"cameraInput"); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0300 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400 + * @tc.name : createCameraInput api + * @tc.desc : createCameraInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let camerainput = mCameraManager.createCameraInput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_CAMERA_INPUT_0400 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100 + * @tc.name : createPreviewOutput api + * @tc.desc : createPreviewOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let previewoutput = mCameraManager.createPreviewOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200 + * @tc.name : createPreviewOutput api + * @tc.desc : createPreviewOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let previewoutput = mCameraManager.createPreviewOutput(null,"createoutput"); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PREVIEW_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100 + * @tc.name : createPhotoOutput api + * @tc.desc : createPhotoOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let photooutput = mCameraManager.createPhotoOutput(null,"createoutput"); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200 + * @tc.name : createPhotoOutput api + * @tc.desc : createPhotoOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let photooutput = mCameraManager.createPhotoOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_PHOTO_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100 + * @tc.name : createVideoOutput api + * @tc.desc : createVideoOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let videooutput = mCameraManager.createVideoOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200 + * @tc.name : createVideoOutput api + * @tc.desc : createVideoOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let videooutput = mCameraManager.createVideoOutput(null,"createoutput"); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_VIDEO_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100 + * @tc.name : createMetadataOutput api + * @tc.desc : createMetadataOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let videooutput = mCameraManager.createMetadataOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200 + * @tc.name : createMetadataOutput api + * @tc.desc : createMetadataOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200--------------"); + if (isEmpty(mCameraManager)) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200 cameraManager == null || undefined") + expect().assertFail(); + done(); + } else { + try { + let metadataoutput = mCameraManager.createMetadataOutput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CREATE_METADATA_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + done(); + } + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100 + * @tc.name : addInput api + * @tc.desc : addInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100--------------"); + createCameraSessionInstance(); + try { + mCameraSession.addInput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200 + * @tc.name : addInput api + * @tc.desc : addInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200--------------"); + createCameraSessionInstance(); + try { + mCameraSession.addInput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100 + * @tc.name : removeInput api + * @tc.desc : removeInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100--------------"); + createCameraSessionInstance(); + try { + mCameraSession.removeInput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200 + * @tc.name : removeInput api + * @tc.desc : removeInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200--------------"); + createCameraSessionInstance(); + try { + mCameraSession.removeInput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100 + * @tc.name : addOutput api + * @tc.desc : addOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100--------------"); + createCameraSessionInstance(); + try { + mCameraSession.addOutput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200 + * @tc.name : addOutput api + * @tc.desc : addOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200--------------"); + createCameraSessionInstance(); + try { + mCameraSession.addOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100 + * @tc.name : removeOutput api + * @tc.desc : removeOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100--------------"); + createCameraSessionInstance(); + try { + mCameraSession.removeOutput(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200 + * @tc.name : removeOutput api + * @tc.desc : removeOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200--------------"); + createCameraSessionInstance(); + try { + mCameraSession.removeOutput(null); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + await mCameraSession.start(); + mPhotoOutput.capture({},async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + } + }) + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + await mCameraSession.start(); + await mPhotoOutput.capture({}).then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0400 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.INVALID_ARGUMENT).assertTrue(); + expect(true).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100 + * @tc.name : commitConfig api + * @tc.desc : commitConfig api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + mCameraSession.commitConfig(async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + } + }) + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200 + * @tc.name : commitConfig api + * @tc.desc : commitConfig api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + await mCameraSession.commitConfig().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_COMMITCONFIG_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300 + * @tc.name : addInput api + * @tc.desc : addInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + try { + mCameraSession.addInput(mCameraInput); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_INPUT_0300 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300 + * @tc.name : removeInput api + * @tc.desc : removeInput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + try { + mCameraSession.removeInput(mCameraInput); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_INPUT_0300 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300 + * @tc.name : addOutput api + * @tc.desc : addOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + createOutput(0); + try { + mCameraSession.addOutput(mPreviewOutput); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_ADD_OUTPUT_0300 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300 + * @tc.name : removeOutput api + * @tc.desc : removeOutput api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + createOutput(0); + try { + mCameraSession.removeOutput(mPreviewOutput); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_REMOVE_OUTPUT_0300 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.OPERATION_NOT_ALLOWED).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100 + * @tc.name : capturesession start api + * @tc.desc : capturesession start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + mCameraSession.start().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200 + * @tc.name : capturesession start api + * @tc.desc : capturesession start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + mCameraSession.start(async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_START_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + } + }) + sleep(1000); + releaseInput(); + sleep(1000); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100 + * @tc.name : capturesession hasFlash api + * @tc.desc : capturesession hasFlash api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let isFlash = mCameraSession.hasFlash(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_HASFLASH_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + console.info(TAG + "cameraObj.CameraErrorCode.SESSION_NOT_CONFIG: " + cameraObj.CameraErrorCode.SESSION_NOT_CONFIG); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + }; + sleep(1000); + releaseInput(); + sleep(1000); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100 + * @tc.name : capturesession isFlashModeSupported api + * @tc.desc : capturesession isFlashModeSupported api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let isFlashmodesupported = mCameraSession.isFlashModeSupported(cameraObj.FlashMode.FLASH_MODE_AUTO); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFLASHMODESUPPORTED_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100 + * @tc.name : capturesession getFlashMode api + * @tc.desc : capturesession getFlashMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let flashmode = mCameraSession.getFlashMode(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFLASHMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100 + * @tc.name : capturesession setFlashMode api + * @tc.desc : capturesession setFlashMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setFlashMode(cameraObj.FlashMode.FLASH_MODE_AUTO); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFLASHMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100 + * @tc.name : capturesession isExposureModeSupported api + * @tc.desc : capturesession isExposureModeSupported api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let issupported = mCameraSession.isExposureModeSupported(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISEXPOSUREMODESUPPORTED_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100 + * @tc.name : capturesession getExposureMode api + * @tc.desc : capturesession getExposureMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let exposure = mCameraSession.getExposureMode(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100 + * @tc.name : capturesession setExposureMode api + * @tc.desc : capturesession setExposureMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setExposureMode(cameraObj.ExposureMode.EXPOSURE_MODE_AUTO); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + }; + sleep(1000); + releaseInput(); + sleep(1000); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100 + * @tc.name : capturesession getMeteringPoint api + * @tc.desc : capturesession getMeteringPoint api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let point = mCameraSession.getMeteringPoint(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETMETERINGPOINT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100 + * @tc.name : capturesession setMeteringPoint api + * @tc.desc : capturesession setMeteringPoint api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setMeteringPoint({x:1,y:1}); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETMETERINGPOINT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100 + * @tc.name : capturesession getExposureBiasRange api + * @tc.desc : capturesession getExposureBiasRange api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let range = mCameraSession.getExposureBiasRange(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREBIASRANGE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100 + * @tc.name : capturesession setExposureBias api + * @tc.desc : capturesession setExposureBias api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let range = mCameraSession.getExposureBiasRange(); + mCameraSession.setExposureBias(range[0]); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETEXPOSUREBIAS_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100 + * @tc.name : capturesession getExposureValue api + * @tc.desc : capturesession getExposureValue api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let value = mCameraSession.getExposureValue(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETEXPOSUREVALUE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100 + * @tc.name : capturesession isFocusModeSupported api + * @tc.desc : capturesession isFocusModeSupported api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let issupported = mCameraSession.isFocusModeSupported(cameraObj.FocusMode.FOCUS_MODE_AUTO); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISFOCUSMODESUPPORTED_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100 + * @tc.name : capturesession getFocusMode api + * @tc.desc : capturesession getFocusMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let focusmode = mCameraSession.getFocusMode(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100 + * @tc.name : capturesession setFocusMode api + * @tc.desc : capturesession setFocusMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setFocusMode(cameraObj.FocusMode.FOCUS_MODE_MANUAL); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + }; + sleep(1000); + releaseInput(); + sleep(1000); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100 + * @tc.name : capturesession setFocusPoint api + * @tc.desc : capturesession setFocusPoint api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setFocusPoint({x:1,y:1}); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETFOCUSPOINT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100 + * @tc.name : capturesession getFocusPoint api + * @tc.desc : capturesession getFocusPoint api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let point = mCameraSession.getFocusPoint(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSPOINT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100 + * @tc.name : capturesession getFocalLength api + * @tc.desc : capturesession getFocalLength api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let length = mCameraSession.getFocalLength(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETFOCUSLENGTH_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100 + * @tc.name : capturesession getZoomRatioRange api + * @tc.desc : capturesession getZoomRatioRange api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let zoomratiorange = mCameraSession.getZoomRatioRange(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIORANG_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100 + * @tc.name : capturesession getZoomRatio api + * @tc.desc : capturesession getZoomRatio api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let zoomratio = mCameraSession.getZoomRatio(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_GETZOOMRATIO_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100 + * @tc.name : capturesession setZoomRatio api + * @tc.desc : capturesession setZoomRatio api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let zoomratiorange = mCameraSession.getZoomRatioRange(); + mCameraSession.setZoomRatio(zoomratiorange[0]); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETZOOMRATIO_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100 + * @tc.name : capturesession isVideoStabilizationModeSupported api + * @tc.desc : capturesession isVideoStabilizationModeSupported api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let isVSMS = mCameraSession.isVideoStabilizationModeSupported(cameraObj.VideoStabilizationMode.LOW); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_ISVSMS_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100 + * @tc.name : capturesession getActiveVideoStabilizationMode api + * @tc.desc : capturesession getActiveVideoStabilizationMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + let avstmode = mCameraSession.getActiveVideoStabilizationMode(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_AVSTMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100 + * @tc.name : capturesession setVideoStabilizationMode api + * @tc.desc : capturesession setVideoStabilizationMode api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + try{ + mCameraSession.setVideoStabilizationMode(cameraObj.VideoStabilizationMode.LOW); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAPTURESESSION_SETVSTMODE_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }; + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100 + * @tc.name : PreviewOutput start api + * @tc.desc : PreviewOutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + mPreviewOutput.start(async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + } + }) + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200 + * @tc.name : PreviewOutput start api + * @tc.desc : PreviewOutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + + await mPreviewOutput.start().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PREVIEW_START_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100 + * @tc.name : videooutput start api + * @tc.desc : videooutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + if (!isEmpty(cameraOutputCap.videoProfiles)) { + for (let i = 0; i < cameraOutputCap.videoProfiles.length; i++) { + videoOutput = mCameraManager.createVideoOutput(cameraOutputCap.videoProfiles[i], videoSurfaceId); + if (!isEmpty(videoOutput)) { + break; + } + } + } + mCameraSession.addOutput(mPreviewOutput); + if (!isEmpty(videoOutput)) { + mCameraSession.addOutput(videoOutput); + videoOutput.start(async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + } + }) + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200 + * @tc.name : videooutput start api + * @tc.desc : videooutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + if (!isEmpty(videoOutput)) { + mCameraSession.addOutput(videoOutput); + await videoOutput.start().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_VIDEO_START_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + }); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 + * @tc.name : MetadataOutput start api + * @tc.desc : MetadataOutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + if (isEmpty(metadataOutput)) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 metadataOutput IS NULL"); + } else { + mCameraSession.addOutput(metadataOutput); + metadataOutput.start(async (err) => { + if (!err) { + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + } + }) + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 + * @tc.name : metadataOutput start api + * @tc.desc : metadataOutput start api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + if (isEmpty(metadataOutput)) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 metadataOutput IS NULL"); + } else { + mCameraSession.addOutput(metadataOutput); + await metadataOutput.start().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_METADATAOUTPUT_START_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_CONFIG).assertTrue(); + expect(true).assertTrue(); + }); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + await mPhotoOutput.capture().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0500 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue(); + expect(true).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + mPhotoOutput.capture(async (err) => { + if (!err) { + expect(true).assertTrue(); + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0600 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue(); + expect(true).assertTrue(); + } + }) + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + mPhotoOutput.capture(captureSetting,async (err) => { + if (!err) { + expect(true).assertTrue(); + console.info(TAG + "Entering SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700 success"); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0700 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue(); + expect(true).assertTrue(); + } + }) + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800 + * @tc.name : photoOutput capture api + * @tc.desc : photoOutput capture api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800--------------"); + await createInput(0); + createCameraSessionInstance(); + mCameraSession.addInput(mCameraInput); + createOutput(0); + mCameraSession.addOutput(mPreviewOutput); + mCameraSession.addOutput(mPhotoOutput); + await commitCameraSessionConfig(); + await mPhotoOutput.capture(captureSetting).then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_PHOTOOUTPUT_CAPTURE_0800 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.SESSION_NOT_RUNNING).assertTrue(); + expect(true).assertTrue(); + }); + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100 + * @tc.name : capturesession beginConfig api + * @tc.desc : capturesession beginConfig api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100--------------"); + await createInput(0); + mCameraSession = mCameraManager.createCaptureSession(); + mCameraSession.beginConfig(); + try { + mCameraSession.beginConfig(); + } catch (error) { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_BEGINCONFIG_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + error.code); + expect(error.code == cameraObj.CameraErrorCode.SESSION_CONFIG_LOCKED).assertTrue(); + expect(true).assertTrue(); + } + sleep(100); + releaseInput(); + sleep(100); + releaseCameraSessionInstance(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100 + * @tc.name : CameraInput open api + * @tc.desc : CameraInput open api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100--------------"); + mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[0]); + if (!isEmpty(mCameraInput)) { + mCameraInput.open(async (err) => { + console.info(TAG + "Entering mCameraInput open callback"); + if (!err) { + console.info(TAG + "Entering mCameraInput open PASSED "); + } else { + console.info(TAG + "Entering mCameraInput open FAILED : " + err.message); + } + }) + mCameraInput.open(async (err) => { + console.info(TAG + "Entering mCameraInput open callback"); + if (!err) { + console.info(TAG + "Entering mCameraInput open PASSED "); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.CONFILICT_CAMERA).assertTrue(); + expect(true).assertTrue(); + } + }) + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0100 createCameraInput FAILED"); + } + sleep(100); + releaseInput(); + done(); + }) + + /** + * @tc.number : SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 + * @tc.name : CameraInput open api + * @tc.desc : CameraInput open api + * @tc.size : MEDIUM + * @tc.type : Function + * @tc.level : Level 0 + */ + it('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200', 0, async function (done) { + console.info("--------------SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200--------------"); + mCameraInput = mCameraManager.createCameraInput(mCameraDevicesArray[0]); + if (!isEmpty(mCameraInput)) { + await mCameraInput.open().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + }); + await mCameraInput.open().then((result) => { + console.info('SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 success :' + result); + }).catch((err) => { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 FAILED"); + console.info(TAG + "ERRORCODE: " + err.code); + expect(err.code == cameraObj.CameraErrorCode.CONFILICT_CAMERA).assertTrue(); + expect(true).assertTrue(); + }); + } else { + console.info(TAG + "SUB_MULTIMEDIA_CAMERA_ERROR_CODE_USECASE_CAMERAINPUT_OPEN_CONFLICT_0200 createCameraInput FAILED"); + } + sleep(100); + releaseInput(); + done(); + }) + }) +} \ No newline at end of file