/*
* Copyright (c) 2024 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 { photoAccessHelper } from '@kit.MediaLibraryKit';
import { camera } from '@kit.CameraKit';
import { media } from '@kit.MediaKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { JSON } from '@kit.ArkTS';
import { fileIo } from '@kit.CoreFileKit';
import { GlobalContext } from '../common/utils/GlobalContext';
import Logger from '../common/utils/Logger';
import { Constants } from '../common/Constants';
const TAG: string = 'CameraService';
const uiContext: UIContext | undefined = AppStorage.get('uiContext');
export class SliderValue {
min: number = 1;
max: number = 6;
step: number = 0.1;
}
class CameraService {
private cameraManager: camera.CameraManager | undefined = undefined;
private cameras: Array<camera.CameraDevice> | Array<camera.CameraDevice> = [];
private cameraInput: camera.CameraInput | undefined = undefined;
private previewOutput: camera.PreviewOutput | undefined = undefined;
private photoOutput: camera.PhotoOutput | undefined = undefined;
private videoOutput: camera.VideoOutput | undefined = undefined;
private avRecorder: media.AVRecorder | undefined = undefined;
private session: camera.PhotoSession | camera.VideoSession | undefined = undefined;
private handlePhotoAssetCb: (photoAsset: photoAccessHelper.PhotoAsset) => void = () => {
};
private curCameraDevice: camera.CameraDevice | undefined = undefined;
private isRecording: boolean = false;
// One of the recommended camera resolutions.
private photoProfileObj: camera.Profile = {
format: 2000,
size: {
width: 1920,
height: 1080
}
};
// One of the recommended preview resolutions.
private previewProfileObj: camera.Profile = {
format: 1003,
size: {
width: 1920,
height: 1080
}
};
// One of the recommended video resolutions.
private videoProfileObj: camera.VideoProfile = {
format: 1003,
size: {
width: 1920,
height: 1080
},
frameRateRange: {
min: 30,
max: 60
}
};
private curSceneMode: camera.SceneMode = camera.SceneMode.NORMAL_PHOTO;
constructor() {
}
setSavePictureCallback(callback: (photoAsset: photoAccessHelper.PhotoAsset) => void): void {
this.handlePhotoAssetCb = callback;
}
setSceneMode(sceneMode: camera.SceneMode): void {
this.curSceneMode = sceneMode;
}
getSceneMode(): camera.SceneMode {
return this.curSceneMode;
}
getPreviewProfile(cameraOutputCapability: camera.CameraOutputCapability): camera.Profile | undefined {
let previewProfiles = cameraOutputCapability.previewProfiles;
if (previewProfiles.length < 1) {
return undefined;
}
let index = previewProfiles.findIndex((previewProfile: camera.Profile) => {
return previewProfile.size.width === this.previewProfileObj.size.width &&
previewProfile.size.height === this.previewProfileObj.size.height &&
previewProfile.format === this.previewProfileObj.format;
});
if (index === -1) {
return undefined;
}
return previewProfiles[index];
}
getPhotoProfile(cameraOutputCapability: camera.CameraOutputCapability): camera.Profile | undefined {
let photoProfiles = cameraOutputCapability.photoProfiles;
if (photoProfiles.length < 1) {
return undefined;
}
let index = photoProfiles.findIndex((photoProfile: camera.Profile) => {
return photoProfile.size.width === this.photoProfileObj.size.width &&
photoProfile.size.height === this.photoProfileObj.size.height &&
photoProfile.format === this.photoProfileObj.format;
});
if (index === -1) {
return undefined;
}
return photoProfiles[index];
}
getVideoProfile(cameraOutputCapability: camera.CameraOutputCapability): camera.VideoProfile | undefined {
let videoProfiles = cameraOutputCapability.videoProfiles;
if (videoProfiles.length < 1) {
return undefined;
}
for (let i = 0; i < videoProfiles.length; i++) {
Logger.info(TAG, `getVideoProfile: ${JSON.stringify(videoProfiles[i])}`);
}
let index = videoProfiles.findIndex((videoProfile: camera.VideoProfile) => {
return videoProfile.size.width === this.videoProfileObj.size.width &&
videoProfile.size.height === this.videoProfileObj.size.height &&
videoProfile.format === this.videoProfileObj.format &&
videoProfile.frameRateRange.min <= Constants.MAX_VIDEO_FRAME &&
videoProfile.frameRateRange.max <= Constants.MAX_VIDEO_FRAME;
});
if (index === -1) {
return undefined;
}
return videoProfiles[index];
}
isSupportedSceneMode(cameraManager: camera.CameraManager, cameraDevice: camera.CameraDevice): boolean {
let sceneModes = cameraManager.getSupportedSceneModes(cameraDevice);
if (sceneModes === undefined) {
return false;
}
let index = sceneModes.findIndex((sceneMode: camera.SceneMode) => {
return sceneMode === this.curSceneMode;
});
if (index === -1) {
return false;
}
return true;
}
/**
* Initialize camera function
* @param surfaceId - Surface ID
* @param cameraDeviceIndex - Camera device index
* @returns No return value
*/
async initCamera(surfaceId: string, cameraDeviceIndex: number): Promise<void> {
Logger.debug(TAG, `initCamera cameraDeviceIndex: ${cameraDeviceIndex}`);
try {
await this.releaseCamera();
// Get Camera Manager instance.
this.cameraManager = this.getCameraManagerFn();
if (this.cameraManager === undefined) {
Logger.error(TAG, 'cameraManager is undefined');
return;
}
// Get support for specified camera device objects.
this.cameras = this.getSupportedCamerasFn(this.cameraManager);
if (this.cameras.length < 1 || this.cameras.length < cameraDeviceIndex + 1) {
return;
}
this.curCameraDevice = this.cameras[cameraDeviceIndex];
let isSupported = this.isSupportedSceneMode(this.cameraManager, this.curCameraDevice);
if (!isSupported) {
Logger.error(TAG, 'The current scene mode is not supported.');
return;
}
let cameraOutputCapability =
this.cameraManager.getSupportedOutputCapability(this.curCameraDevice, this.curSceneMode);
let previewProfile = this.getPreviewProfile(cameraOutputCapability);
if (previewProfile === undefined) {
Logger.error(TAG, 'The resolution of the current preview stream is not supported.');
return;
}
this.previewProfileObj = previewProfile;
// Create previewOutput output object.
this.previewOutput = this.createPreviewOutputFn(this.cameraManager, this.previewProfileObj, surfaceId);
if (this.previewOutput === undefined) {
Logger.error(TAG, 'Failed to create the preview stream.');
return;
}
// Monitor preview events.
this.previewOutputCallBack(this.previewOutput);
if (this.curSceneMode === camera.SceneMode.NORMAL_PHOTO) {
let photoProfile = this.getPhotoProfile(cameraOutputCapability);
if (photoProfile === undefined) {
Logger.error(TAG, 'The resolution of the current photo stream is not supported.');
return;
}
this.photoProfileObj = photoProfile;
// Create photoOutput output object.
this.photoOutput = this.createPhotoOutputFn(this.cameraManager, this.photoProfileObj);
if (this.photoOutput === undefined) {
Logger.error(TAG, 'Failed to create the photo stream.');
return;
}
} else if (this.curSceneMode === camera.SceneMode.NORMAL_VIDEO) {
let videoProfile = this.getVideoProfile(cameraOutputCapability);
if (videoProfile === undefined) {
Logger.error(TAG, 'The resolution of the current video stream is not supported.');
return;
}
this.videoProfileObj = videoProfile;
this.avRecorder = await this.createAVRecorder();
if (this.avRecorder === undefined) {
Logger.error(TAG, 'Failed to create the avRecorder.');
return;
}
await this.prepareAVRecorder();
let videoSurfaceId = await this.avRecorder.getInputSurface();
// Create videoOutput output object.
this.videoOutput = this.createVideoOutputFn(this.cameraManager, this.videoProfileObj, videoSurfaceId);
if (this.videoOutput === undefined) {
Logger.error(TAG, 'Failed to create the video stream.');
return;
}
}
// Create cameraInput output object.
this.cameraInput = this.createCameraInputFn(this.cameraManager, this.curCameraDevice);
if (this.cameraInput === undefined) {
Logger.error(TAG, 'Failed to create the camera input.');
return;
}
// Open the camera.
let isOpenSuccess = await this.cameraInputOpenFn(this.cameraInput);
if (!isOpenSuccess) {
Logger.error(TAG, 'Failed to open the camera.');
return;
}
// Camera status callback.
this.onCameraStatusChange(this.cameraManager);
// Monitor error events from CameraInput.
this.onCameraInputChange(this.cameraInput, this.curCameraDevice);
// Conversation process.
await this.sessionFlowFn(this.cameraManager, this.cameraInput, this.previewOutput, this.photoOutput,
this.videoOutput);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `initCamera fail: code=${err.code}, message=${err.message}`);
}
}
/**
* Obtain variable focal length range.
*/
getZoomRatioRange(): Array<number> {
let zoomRatioRange: Array<number> = [];
if (this.session !== undefined) {
try {
zoomRatioRange = this.session.getZoomRatioRange();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `getZoomRatioRange fail: code=${err.code}, message=${err.message}`);
}
}
return zoomRatioRange;
}
/**
* Zoom
*/
setZoomRatioFn(zoomRatio: number): void {
Logger.info(TAG, `setZoomRatioFn value ${zoomRatio}`);
// Obtain supported zoom range.
try {
let zoomRatioRange = this.getZoomRatioRange();
Logger.info(TAG, `getZoomRatioRange success: ${JSON.stringify(zoomRatioRange)}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `getZoomRatioRange fail: code=${err.code}, message=${err.message}}`);
}
try {
this.session?.setZoomRatio(zoomRatio);
Logger.info(TAG, 'setZoomRatioFn success');
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `setZoomRatioFn fail: code=${err.code}, message=${err.message}`);
}
}
/**
* Trigger a photo with specified parameters.
*/
async takePicture(): Promise<void> {
try {
Logger.info(TAG, 'takePicture start');
let cameraDeviceIndex = GlobalContext.get().getT<number>('cameraDeviceIndex');
let photoSettings: camera.PhotoCaptureSetting = {
quality: camera.QualityLevel.QUALITY_LEVEL_HIGH,
mirror: cameraDeviceIndex ? true : false
};
await this.photoOutput?.capture(photoSettings);
Logger.info(TAG, 'takePicture end');
} catch (error) {
let err = error as BusinessError;
Logger.error(`apply takePicture failed with error: ${err.code}, ${err.message}`);
}
}
async saveCameraPhoto(asset: photoAccessHelper.PhotoAsset) {
Logger.info('saveCameraPhoto');
try {
let context = uiContext?.getHostContext();
let phAccessHelper = photoAccessHelper.getPhotoAccessHelper(context);
let assetChangeRequest: photoAccessHelper.MediaAssetChangeRequest =
new photoAccessHelper.MediaAssetChangeRequest(asset);
assetChangeRequest.saveCameraPhoto();
await phAccessHelper.applyChanges(assetChangeRequest);
Logger.info('apply saveCameraPhoto successfully');
} catch (error) {
let err = error as BusinessError;
Logger.error(`apply saveCameraPhoto failed with error: ${err.code}, ${err.message}`);
}
}
/**
* Release the session and its related parameters.
*/
async releaseCamera(): Promise<void> {
Logger.info(TAG, 'releaseCamera is called');
try {
await this.previewOutput?.release();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `previewOutput release fail: code=${err.code}, message=${err.message}`);
} finally {
this.previewOutput = undefined;
}
try {
await this.photoOutput?.release();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `photoOutput release fail: code=${err.code}, message=${err.message}`);
} finally {
this.photoOutput = undefined;
}
try {
await this.avRecorder?.release();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `avRecorder release fail: code=${err.code}, message=${err.message}`);
} finally {
this.avRecorder = undefined;
}
try {
await this.videoOutput?.release();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `videoOutput release fail: code=${err.code}, message=${err.message}`);
} finally {
this.videoOutput = undefined;
}
try {
await this.session?.release();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `captureSession release fail: code=${err.code}, message=${err.message}`);
} finally {
this.session = undefined;
}
try {
await this.cameraInput?.close();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `cameraInput close fail: code=${err.code}, message=${err.message}`);
} finally {
this.cameraInput = undefined;
}
this.offCameraStatusChange();
Logger.info(TAG, 'releaseCamera success');
}
/**
* Get Camera Manager instance.
*/
getCameraManagerFn(): camera.CameraManager | undefined {
if (this.cameraManager) {
return this.cameraManager;
}
let cameraManager: camera.CameraManager | undefined = undefined;
try {
cameraManager = camera.getCameraManager(GlobalContext.get().getCameraSettingContext());
Logger.info(TAG, `getCameraManager success: ${cameraManager}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `getCameraManager failed: code=${err.code}, message=${err.message}`);
}
return cameraManager;
}
/**
* Get support for specified camera device objects.
*/
getSupportedCamerasFn(cameraManager: camera.CameraManager): Array<camera.CameraDevice> {
let supportedCameras: Array<camera.CameraDevice> = [];
try {
supportedCameras = cameraManager.getSupportedCameras();
Logger.info(TAG, `getSupportedCameras success: ${this.cameras}, length: ${this.cameras?.length}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `getSupportedCameras failed: code=${err.code}, message=${err.message}`);
}
return supportedCameras;
}
/**
* Create previewOutput output object.
*/
createPreviewOutputFn(cameraManager: camera.CameraManager, previewProfileObj: camera.Profile,
surfaceId: string): camera.PreviewOutput | undefined {
let previewOutput: camera.PreviewOutput | undefined = undefined;
try {
previewOutput = cameraManager.createPreviewOutput(previewProfileObj, surfaceId);
Logger.info(TAG, `createPreviewOutput success: ${previewOutput}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createPreviewOutput failed: code=${err.code}, message=${err.message}`);
}
return previewOutput;
}
/**
* Create photoOutPut output object.
*/
createPhotoOutputFn(cameraManager: camera.CameraManager,
photoProfileObj: camera.Profile): camera.PhotoOutput | undefined {
let photoOutput: camera.PhotoOutput | undefined = undefined;
try {
photoOutput = cameraManager.createPhotoOutput(photoProfileObj);
Logger.info(TAG, `createPhotoOutputFn success: ${photoOutput}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createPhotoOutputFn failed: code=${err.code}, message=${err.message}`);
}
return photoOutput;
}
/**
* Create videoOutPut output object.
*/
createVideoOutputFn(cameraManager: camera.CameraManager, videoProfileObj: camera.VideoProfile,
surfaceId: string): camera.VideoOutput | undefined {
let videoOutput: camera.VideoOutput | undefined = undefined;
try {
videoOutput = cameraManager.createVideoOutput(videoProfileObj, surfaceId);
Logger.info(TAG, `createVideoOutputFn success: ${videoOutput}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createVideoOutputFn failed: code=${err.code}, message=${err.message}`);
}
return videoOutput;
}
/**
* Create cameraInput output object.
*/
createCameraInputFn(cameraManager: camera.CameraManager,
cameraDevice: camera.CameraDevice): camera.CameraInput | undefined {
Logger.info(TAG, 'createCameraInputFn is called.');
let cameraInput: camera.CameraInput | undefined = undefined;
try {
cameraInput = cameraManager.createCameraInput(cameraDevice);
Logger.info(TAG, 'createCameraInputFn success');
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createCameraInputFn failed: code=${err.code}, message=${err.message}`);
}
return cameraInput;
}
/**
* Open the camera.
*/
async cameraInputOpenFn(cameraInput: camera.CameraInput): Promise<boolean> {
let isOpenSuccess = false;
try {
await cameraInput.open();
isOpenSuccess = true;
Logger.info(TAG, 'cameraInput open success');
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createCameraInput failed: code=${err.code}, message=${err.message}`);
}
return isOpenSuccess;
}
/**
* Conversation process.
*/
async sessionFlowFn(cameraManager: camera.CameraManager, cameraInput: camera.CameraInput,
previewOutput: camera.PreviewOutput, photoOutput: camera.PhotoOutput | undefined,
videoOutput: camera.VideoOutput | undefined): Promise<void> {
try {
if (this.curSceneMode === camera.SceneMode.NORMAL_PHOTO) {
this.session = cameraManager.createSession(this.curSceneMode) as camera.PhotoSession;
} else if (this.curSceneMode === camera.SceneMode.NORMAL_VIDEO) {
this.session = cameraManager.createSession(this.curSceneMode) as camera.VideoSession;
}
if (this.session === undefined) {
return;
}
this.onSessionErrorChange(this.session);
this.session.beginConfig();
this.session.addInput(cameraInput);
this.session.addOutput(previewOutput);
if (this.curSceneMode === camera.SceneMode.NORMAL_PHOTO) {
if (photoOutput === undefined) {
return;
}
this.photoOutputCallBack(photoOutput);
this.session.addOutput(photoOutput);
} else if (this.curSceneMode === camera.SceneMode.NORMAL_VIDEO) {
if (videoOutput === undefined) {
return;
}
this.session.addOutput(videoOutput);
}
await this.session.commitConfig();
if (this.curSceneMode === camera.SceneMode.NORMAL_VIDEO) {
this.setVideoStabilizationFn(this.session as camera.VideoSession, camera.VideoStabilizationMode.MIDDLE);
}
this.updateSliderValue();
this.setFocusMode(camera.FocusMode.FOCUS_MODE_AUTO);
await this.session.start();
Logger.info(TAG, 'sessionFlowFn success');
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `sessionFlowFn fail: code=${err.code}, message=${err.message}`);
}
}
setVideoStabilizationFn(session: camera.VideoSession, videoStabilizationMode: camera.VideoStabilizationMode): void {
try {
// Check if the specified video stabilization mode is supported.
let isVideoStabilizationModeSupported: boolean =
session.isVideoStabilizationModeSupported(videoStabilizationMode);
if (isVideoStabilizationModeSupported) {
session.setVideoStabilizationMode(videoStabilizationMode);
}
Logger.info(TAG, 'setVideoStabilizationFn success');
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `setVideoStabilizationFn fail: code=${err.code}, message=${err.message}`);
}
}
/**
* Update slider data.
*/
updateSliderValue(): void {
let zoomRatioRange = this.getZoomRatioRange();
if (zoomRatioRange.length !== 0) {
let zoomRatioMin = zoomRatioRange[0];
let zoomRatioMax = zoomRatioRange[1] > Constants.ZOOM_RADIO_MAX ? Constants.ZOOM_RADIO_MAX : zoomRatioRange[1];
let sliderStep =
zoomRatioRange[1] > Constants.ZOOM_RADIO_MAX ? Constants.ZOOM_RADIO_MAX_STEP : Constants.ZOOM_RADIO_MIN_STEP;
AppStorage.set<SliderValue>('sliderValue', {
min: zoomRatioMin,
max: zoomRatioMax,
step: sliderStep
});
}
}
/**
* Monitoring and photography events.
*/
photoOutputCallBack(photoOutput: camera.PhotoOutput): void {
try {
photoOutput.on('captureStartWithInfo', (err: BusinessError, captureStartInfo: camera.CaptureStartInfo): void => {
Logger.info(TAG, `photoOutputCallBack captureStartWithInfo success: ${JSON.stringify(captureStartInfo)}`);
});
photoOutput.on('frameShutter', (err: BusinessError, frameShutterInfo: camera.FrameShutterInfo): void => {
Logger.info(TAG, `photoOutputCallBack frameShutter captureId:
${frameShutterInfo.captureId}, timestamp: ${frameShutterInfo.timestamp}`);
});
photoOutput.on('captureEnd', (err: BusinessError, captureEndInfo: camera.CaptureEndInfo): void => {
Logger.info(TAG, `photoOutputCallBack captureEnd captureId:
${captureEndInfo.captureId}, frameCount: ${captureEndInfo.frameCount}`);
});
photoOutput.on('error', (data: BusinessError): void => {
Logger.error(TAG, `photoOutPut data: ${JSON.stringify(data)}`);
});
photoOutput.on('photoAssetAvailable', (err: BusinessError, photoAsset: photoAccessHelper.PhotoAsset) => {
Logger.info(TAG, 'photoAssetAvailable begin');
if (photoAsset === undefined) {
Logger.error(TAG, 'photoAsset is undefined');
return;
}
this.handlePhotoAssetCb(photoAsset);
});
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `photoOutputCallBack error code=${err.code}, message=${err.message}`);
}
}
/**
* Monitor preview events.
*/
previewOutputCallBack(previewOutput: camera.PreviewOutput): void {
Logger.info(TAG, 'previewOutputCallBack is called');
try {
previewOutput.on('frameStart', (): void => {
Logger.debug(TAG, 'Preview frame started');
});
previewOutput.on('frameEnd', (): void => {
Logger.debug(TAG, 'Preview frame ended');
});
previewOutput.on('error', (previewOutputError: BusinessError): void => {
Logger.info(TAG, `Preview output previewOutputError: ${JSON.stringify(previewOutputError)}`);
});
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `previewOutputCallBack error code=${err.code}, message=${err.message}`);
}
}
/**
* Callback function for registering camera status changes.
* @param err
* @param cameraStatusInfo
* @returns
*/
registerCameraStatusChange(err: BusinessError, cameraStatusInfo: camera.CameraStatusInfo): void {
Logger.info(TAG, `cameraId: ${cameraStatusInfo.camera.cameraId},status: ${cameraStatusInfo.status}`);
}
/**
* Monitor camera status changes.
* @param cameraManager
* @returns
*/
onCameraStatusChange(cameraManager: camera.CameraManager): void {
Logger.info(TAG, 'onCameraStatusChange is called');
try {
cameraManager.on('cameraStatus', this.registerCameraStatusChange);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `onCameraStatusChange error code=${err.code}, message=${err.message}`);
}
}
/**
* Stop monitoring camera status changes.
* @returns
*/
offCameraStatusChange(): void {
Logger.info(TAG, 'offCameraStatusChange is called');
this.cameraManager?.off('cameraStatus', this.registerCameraStatusChange);
}
/**
* Monitor camera input changes.
* @param cameraInput
* @param cameraDevice
* @returns
*/
onCameraInputChange(cameraInput: camera.CameraInput, cameraDevice: camera.CameraDevice): void {
Logger.info(TAG, `onCameraInputChange is called`);
try {
cameraInput.on('error', cameraDevice, (cameraInputError: BusinessError): void => {
Logger.info(TAG, `onCameraInputChange cameraInput error code: ${cameraInputError.code}`);
});
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `onCameraInputChange error code=${err.code}, message=${err.message}`);
}
}
/**
* @param session
* @returns
*/
onSessionErrorChange(session: camera.PhotoSession | camera.VideoSession): void {
try {
session.on('error', (captureSessionError: BusinessError): void => {
Logger.info(TAG,
'onCaptureSessionErrorChange captureSession fail: ' + JSON.stringify(captureSessionError.code));
});
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `onCaptureSessionErrorChange error code=${err.code}, message=${err.message}`);
}
}
async createAVRecorder(): Promise<media.AVRecorder | undefined> {
let avRecorder: media.AVRecorder | undefined = undefined;
try {
avRecorder = await media.createAVRecorder();
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `createAVRecorder error code=${err.code}, message=${err.message}`);
}
return avRecorder;
}
initFd(): number {
Logger.info(TAG, 'initFd is called');
let filesDir = uiContext?.getHostContext()!.filesDir;
let filePath = filesDir + `/${Date.now()}.mp4`;
AppStorage.setOrCreate<string>('filePath', filePath);
try {
let file: fileIo.File = fileIo.openSync(filePath, fileIo.OpenMode.READ_WRITE | fileIo.OpenMode.CREATE);
return file.fd;
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `Failed in openSync, error code=${err.code}, message=${err.message}`);
return 0;
}
}
async prepareAVRecorder(): Promise<void> {
Logger.info(TAG, 'prepareAVRecorder is called');
let fd = this.initFd();
let videoConfig: media.AVRecorderConfig = {
audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC,
videoSourceType: media.VideoSourceType.VIDEO_SOURCE_TYPE_SURFACE_YUV,
profile: {
audioBitrate: Constants.AUDIO_BITRATE,
audioChannels: Constants.AUDIO_CHANNELS,
audioCodec: media.CodecMimeType.AUDIO_AAC,
audioSampleRate: Constants.AUDIO_SAMPLE_RATE,
fileFormat: media.ContainerFormatType.CFT_MPEG_4,
videoBitrate: Constants.VIDEO_BITRATE,
videoCodec: media.CodecMimeType.VIDEO_AVC,
videoFrameWidth: this.videoProfileObj.size.width,
videoFrameHeight: this.videoProfileObj.size.height,
videoFrameRate: this.videoProfileObj.frameRateRange.max
},
url: `fd://${fd.toString()}`,
rotation: this.curCameraDevice?.cameraOrientation
};
Logger.info(TAG, `prepareAVRecorder videoConfig: ${JSON.stringify(videoConfig)}`);
await this.avRecorder?.prepare(videoConfig).catch((err: BusinessError): void => {
Logger.error(TAG, `prepareAVRecorder prepare error code=${err.code}, message=${err.message}`);
});
}
async startVideo(): Promise<void> {
Logger.info(TAG, 'startVideo is called');
try {
await this.videoOutput?.start();
await this.avRecorder?.start();
this.isRecording = true;
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `startVideo error code=${err.code}, message=${err.message}`);
}
Logger.info(TAG, 'startVideo End of call');
}
async stopVideo(): Promise<void> {
Logger.info(TAG, 'stopVideo is called');
if (!this.isRecording) {
Logger.info(TAG, 'not in recording');
return;
}
try {
if (this.avRecorder) {
await this.avRecorder.stop();
}
if (this.videoOutput) {
await this.videoOutput.stop();
}
this.isRecording = false;
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `stopVideo error code=${err.code}, message=${err.message}`);
}
Logger.info(TAG, 'stopVideo End of call');
}
/**
* Flashing lights
*/
hasFlashFn(flashMode: camera.FlashMode): void {
try {
let hasFlash = this.session?.hasFlash();
Logger.debug(TAG, `hasFlash success, hasFlash: ${hasFlash}`);
let isFlashModeSupported = this.session?.isFlashModeSupported(flashMode);
Logger.debug(TAG, `isFlashModeSupported success, isFlashModeSupported: ${isFlashModeSupported}`);
this.session?.setFlashMode(flashMode);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `hasFlashFn failed, error code=${err.code}, message=${err.message}`);
}
}
/**
* Set the current focus
*/
setFocusPoint(point: camera.Point): void {
try {
this.session?.setFocusPoint(point);
Logger.info(TAG, `setFocusPoint success point: ${JSON.stringify(point)}`);
// Get the current focus
let nowPoint: camera.Point | undefined = undefined;
nowPoint = this.session?.getFocusPoint();
Logger.info(TAG, `getFocusPoint success, nowPoint: ${JSON.stringify(nowPoint)}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `setFocusPoint failed, error code=${err.code}, message=${err.message}`);
}
}
/**
* Exposure area
*/
isMeteringPoint(point: camera.Point): void {
try {
let exposureMode: camera.ExposureMode | undefined = undefined;
exposureMode = this.session?.getExposureMode();
Logger.info(TAG, `getExposureMode success, exposureMode: ${exposureMode}`);
this.session?.setMeteringPoint(point);
let exposurePoint: camera.Point | undefined = undefined;
exposurePoint = this.session?.getMeteringPoint();
Logger.info(TAG, `getMeteringPoint exposurePoint: ${JSON.stringify(exposurePoint)}`);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `isMeteringPoint failed, error code=${err.code}, message=${err.message}`);
}
}
/**
* Exposure compensation
*/
isExposureBiasRange(exposureBias: number): void {
try {
Logger.debug(TAG, `setExposureBias value ${exposureBias}`);
let biasRangeArray: Array<number> | undefined = [];
biasRangeArray = this.session?.getExposureBiasRange();
Logger.debug(TAG, `getExposureBiasRange success, biasRangeArray: ${JSON.stringify(biasRangeArray)}`);
this.session?.setExposureBias(exposureBias);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `isExposureBiasRange failed, error code=${err.code}, message=${err.message}`);
}
}
setFocusMode(focusMode: camera.FocusMode): void {
try {
Logger.info(TAG, `setFocusMode is called`);
let isSupported = false;
isSupported = this.session!.isFocusModeSupported(focusMode);
Logger.info(TAG, `setFocusMode isSupported: ${isSupported}`);
if (!isSupported) {
return;
}
this.session?.setFocusMode(focusMode);
} catch (error) {
let err = error as BusinessError;
Logger.error(TAG, `setFocusMode failed, error code=${err.code}, message=${err.message}`);
}
}
}
export default new CameraService();
