OpenHarmony-v4.0-Release/s

// @ts-nocheck

import camera from '@ohos.multimedia.camera'
import deviceInfo from '@ohos.deviceInfo'
import fileio from '@ohos.fileio'
import image from '@ohos.multimedia.image'
import media from '@ohos.multimedia.media'
import mediaLibrary from '@ohos.multimedia.mediaLibrary'
import Logger from '../model/Logger'
import MediaUtils from '../model/MediaUtils'
import prompt from '@ohos.prompt';
import fs from '@ohos.file.fs';
import screen from '@ohos.screen';

const CameraSize = {
  WIDTH: 1280,
  HEIGHT: 720
}

class CameraService {
  private tag: string = 'qlw CameraService'
  private static instance: CameraService = new CameraService()
  private mediaUtil = MediaUtils.getInstance()
  private cameraManager: camera.CameraManager = undefined
  cameras: Array<camera.CameraDevice> = undefined
  private cameraInput: camera.CameraInput = undefined
  private previewOutput: camera.PreviewOutput = undefined
  private photoOutput: camera.PhotoOutput = undefined
  private cameraOutputCapability: camera.CameraOutputCapability = undefined
  private captureSession: camera.CaptureSession = undefined
  private mReceiver: image.ImageReceiver = undefined
  private fileAsset: mediaLibrary.FileAsset = undefined
  private fd: number = -1
  private videoRecorder: media.VideoRecorder = undefined
  private videoOutput: camera.VideoOutput = undefined
  private handleTakePicture: (photoUri: string) => void = undefined
  private videoConfig: any = {
    audioSourceType: 1,
    videoSourceType: 0,
    profile: {
      audioBitrate: 48000,
      audioChannels: 2,
      audioCodec: 'audio/mp4v-es',
      audioSampleRate: 48000,
      durationTime: 1000,
      fileFormat: 'mp4',
      videoBitrate: 280000,
      videoCodec: 'video/mp4v-es',
      videoFrameWidth: 640,
      videoFrameHeight: 480,
      videoFrameRate: 15,

    },
    rotation: 270,
    url: '',
    orientationHint: 0,
    location: { latitude: 30, longitude: 130 },
    maxSize: 10000,
    maxDuration: 10000
  }
  private videoProfileObj: camera.VideoProfile = {
    format: 1,
    size: {
      "width": 640,
      "height": 480
    },
    frameRateRange: {
      "min": 5,
      "max": 5
    }
  }
  private photoProfileObj: camera.Profile = {
    format: 1,
    size: {
      "width": 640,
      "height": 480
    }
  }
  private videoOutputStopBol: boolean = true
  resolution: any = null
  photoResolution: any = null
  videoResolution: any = null
  screensObj: any = null

  async getScreensObj() {
    let screens = await screen.getAllScreens()
    this.screensObj = screens[0].supportedModeInfo
    Logger.info(this.tag, ` this.screensObj success` + JSON.stringify(this.screensObj))
  }

  constructor() {
    try {
      this.mReceiver = image.createImageReceiver(CameraSize.WIDTH, CameraSize.HEIGHT, image.ImageFormat.JPEG, 8)
      Logger.info(this.tag, 'createImageReceiver')
      this.mReceiver.on('imageArrival', () => {
        Logger.info(this.tag, 'imageArrival')
        this.mReceiver.readNextImage((err, image) => {
          Logger.info(this.tag, 'readNextImage')
          if (err || image === undefined) {
            Logger.error(this.tag, 'failed to get valid image')
            return
          }
          image.getComponent(4, (errMsg, img) => {
            Logger.info(this.tag, 'getComponent')
            if (errMsg || img === undefined) {
              Logger.info(this.tag, 'failed to get valid buffer')
              return
            }
            let buffer
            if (img.byteBuffer) {
              buffer = img.byteBuffer
            } else {
              Logger.error(this.tag, 'img.byteBuffer is undefined')
            }
            this.savePicture(buffer, image)
          })
        })
      })
    } catch (err) {
      Logger.info(this.tag, `image Receiver err ${err.message}`)
    }
  }

  async savePicture(buffer: ArrayBuffer, img: image.Image) {
    try {
      Logger.info(this.tag, 'savePicture')
      let imgFileAsset = await this.mediaUtil.createAndGetUri(mediaLibrary.MediaType.IMAGE)
      let imgPhotoUri = imgFileAsset.uri
      Logger.info(this.tag, `photoUri = ${imgPhotoUri}`)
      let imgFd = await this.mediaUtil.getFdPath(imgFileAsset)
      Logger.info(this.tag, `fd = ${imgFd}`)
      await fileio.write(imgFd, buffer)
      await imgFileAsset.close(imgFd)
      await img.release()
      Logger.info(this.tag, 'save image done')
      if (this.handleTakePicture) {
        this.handleTakePicture(imgPhotoUri)
      }
    } catch (err) {
      Logger.info(this.tag, `save picture err ${err.message}`)
    }
  }

  async initCamera(surfaceId: number, cameraDeviceIndex: number, obj?, photoIndex?, previewObj?) {
    try {
      if (deviceInfo.deviceType === 'default') {
        this.videoConfig.videoSourceType = 1
      } else {
        this.videoConfig.videoSourceType = 0
      }
      Logger.info(this.tag, `cameraDeviceIndex success: ${cameraDeviceIndex}`)
      await this.getScreensObj()
      await this.releaseCamera()
      await this.getCameraManagerFn()
      await this.getSupportedCamerasFn()
      await this.getSupportedOutputCapabilityFn(cameraDeviceIndex)
      if (previewObj) {
        previewObj.format = this.cameraOutputCapability.previewProfiles[0].format
        Logger.info(this.tag, `previewObj format: ${previewObj.format}`)
      }
      await this.createPreviewOutputFn(previewObj ? previewObj : this.cameraOutputCapability.previewProfiles[0], surfaceId)
      //            await this.createPhotoOutputFn(this.photoProfileObj)
      await this.createPhotoOutputFn(obj ? obj : this.cameraOutputCapability.photoProfiles[photoIndex?photoIndex:0])
      await this.createCameraInputFn(this.cameras[cameraDeviceIndex])
      await this.cameraInputOpenFn()
      await this.sessionFlowFn()

    } catch (err) {
      Logger.info(this.tag, 'initCamera err: ' + JSON.stringify(err.message))
    }
  }

  // 曝光模式
  isExposureModeSupportedFn(ind) {
    try {
      let status = this.captureSession.isExposureModeSupported(ind)
      Logger.info(this.tag, `isExposureModeSupported success: ${status}`)
      prompt.showToast({
        message: status ? '支持此模式' : '不支持此模式',
        duration: 2000,
        bottom: '60%'
      })
      // 设置曝光模式
      this.captureSession.setExposureMode(ind)
      Logger.info(this.tag, `setExposureMode success`)
      // 获取当前曝光模式
      let exposureMode = this.captureSession.getExposureMode()
      Logger.info(this.tag, `getExposureMode success: ${exposureMode}`)
    } catch (err) {
      Logger.info(this.tag, `isExposureModeSupportedFn fail: ${err} , message: ${err.message}, code: ${err.code}`)
    }
  }

  // 曝光区域
  isMeteringPoint(Point1) {
    try {
      // 获取当前曝光模式
      let exposureMode = this.captureSession.getExposureMode()
      Logger.info(this.tag, `getExposureMode success: ${exposureMode}`)
      // 设置曝光区域中心点
      this.captureSession.setMeteringPoint(Point1)
      Logger.info(this.tag, `setMeteringPoint success`)
      // 查询曝光区域中心点
      let exposurePoint = this.captureSession.getMeteringPoint()
      Logger.info(this.tag, `getMeteringPoint success: ${exposurePoint}`)
    } catch (err) {
      Logger.info(this.tag, `isMeteringPoint fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 曝光补偿
  isExposureBiasRange(ind) {
    try {
      // 查询曝光补偿范围
      let biasRangeArray = this.captureSession.getExposureBiasRange()
      Logger.info(this.tag, `getExposureBiasRange success: ${biasRangeArray}`)
      // 设置曝光补偿
      this.captureSession.setExposureBias(ind)
      Logger.info(this.tag, `setExposureBias success: ${ind}`)
      // 查询当前曝光值
      let exposureValue = this.captureSession.getExposureValue()
      Logger.info(this.tag, `getExposureValue success: ${exposureValue}`)
    } catch (err) {
      Logger.info(this.tag, `isExposureBiasRange fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 对焦模式
  isFocusMode(ind) {
    try {
      // 检测对焦模式是否支持
      let status = this.captureSession.isFocusModeSupported(ind)
      Logger.info(this.tag, `isFocusModeSupported success: ${status}`)
      prompt.showToast({
        message: status ? '支持此模式' : '不支持此模式',
        duration: 2000,
        bottom: '60%'
      })
      // 设置对焦模式
      this.captureSession.setFocusMode(ind)
      Logger.info(this.tag, `setFocusMode success`)
      // 获取当前对焦模式
      let afMode = this.captureSession.getFocusMode()
      Logger.info(this.tag, `getFocusMode success: ${afMode}`)
    } catch (err) {
      Logger.info(this.tag, `isFocusMode fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 对焦点
  isFocusPoint(Point) {
    try {
      // 设置对焦点
      this.captureSession.setFocusPoint(Point)
      Logger.info(this.tag, `setFocusPoint success`)
      // 获取当前对焦点
      let point = this.captureSession.getFocusPoint()
      Logger.info(this.tag, `getFocusPoint success: ${point}`)
    } catch (err) {
      Logger.info(this.tag, `isFocusPoint fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 闪光灯
  hasFlashFn(ind) {
    try {
      // 检测是否有闪光灯
      let status = this.captureSession.hasFlash()
      Logger.info(this.tag, `hasFlash success: ${status}`)
      // 检测闪光灯模式是否支持
      let status1 = this.captureSession.isFlashModeSupported(ind)
      Logger.info(this.tag, `isFlashModeSupported success: ${status1}`)
      prompt.showToast({
        message: status1 ? '支持此模式' : '不支持此模式',
        duration: 2000,
        bottom: '60%'
      })
      // 设置闪光灯模式
      this.captureSession.setFlashMode(ind)
      Logger.info(this.tag, `setFlashMode success`)
      // 获取当前设备的闪光灯模式
      let flashMode = this.captureSession.getFlashMode()
      Logger.info(this.tag, `getFlashMode success: ${flashMode}`)
    } catch (err) {
      Logger.info(this.tag, `hasFlashFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 变焦
  setZoomRatioFn(num) {
    try {
      // 获取当前支持的变焦范围
      let zoomRatioRange = this.captureSession.getZoomRatioRange()
      Logger.info(this.tag, `getZoomRatioRange success: ${zoomRatioRange}`)
      // 设置变焦比
      Logger.info(this.tag, `setZoomRatioFn num: ${num}`)
      this.captureSession.setZoomRatio(num)
      Logger.info(this.tag, `setZoomRatio success`)
      // 获取当前对焦比
      let zoomRatio = this.captureSession.getZoomRatio()
      Logger.info(this.tag, `getZoomRatio success: ${zoomRatio}`)
    } catch (err) {
      Logger.info(this.tag, `setZoomRatioFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 防抖
  isVideoStabilizationModeSupportedFn(ind) {
    try {
      // 查询是否支持指定的视频防抖模式
      let isSupported = this.captureSession.isVideoStabilizationModeSupported(ind)
      Logger.info(this.tag, `isVideoStabilizationModeSupported success: ${isSupported}`)
      prompt.showToast({
        message: isSupported ? '支持此模式' : '不支持此模式',
        duration: 2000,
        bottom: '60%'
      })
      // 设置视频防抖
      this.captureSession.setVideoStabilizationMode(ind)
      Logger.info(this.tag, `setVideoStabilizationMode success`)
      // 查询当前正在使用的防抖模式
      let vsMode = this.captureSession.getActiveVideoStabilizationMode()
      Logger.info(this.tag, `getActiveVideoStabilizationMode success: ${vsMode}`)
    } catch (err) {
      Logger.info(this.tag, `isVideoStabilizationModeSupportedFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  setTakePictureCallback(callback) {
    this.handleTakePicture = callback
  }

  // 照片方向判断
  onChangeRotation() {
    if (globalThis.photoOrientation == 0) {
      return 0
    }
    if (globalThis.photoOrientation == 1) {
      return 90
    }
    if (globalThis.photoOrientation == 2) {
      return 180
    }
    if (globalThis.photoOrientation == 3) {
      return 270
    }
  }

  // 照片地理位置逻辑，后续靠定位实现，当前传入固定值
  onChangeLocation() {
    if (globalThis.settingDataObj.locationBol) {
      return {
        latitude: 12,
        longitude: 77,
        altitude: 1000
      }
    }
    return {
      latitude: 0,
      longitude: 0,
      altitude: 0
    }
  }

  // 拍照
  async takePicture(imageRotation?) {
    try {
      Logger.info(this.tag, 'takePicture start')
      let photoSettings = {
        rotation: imageRotation ? Number(imageRotation) : 0,
        quality: 1,
        location: {
          latitude: 0,
          longitude: 0,
          altitude: 0
        },
        mirror: false
      }
      Logger.info(this.tag, `photoOutput capture photoSettings: ` + JSON.stringify(photoSettings))
      await this.photoOutput.capture(photoSettings)
      Logger.info(this.tag, 'takePicture end')
    } catch (err) {
      Logger.info(this.tag, `takePicture fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 获取Fd
  async getFileFd() {
    let filesDir = globalThis.abilityContext.filesDir
    Logger.info(this.tag, `beginConfig 3`)
    let path = filesDir + '/' + 'test.mp4'
    Logger.info(this.tag, `beginConfig 4`)
    let file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC)
    Logger.info(this.tag, `getFileFd : ${file.fd}`)
    return file.fd
  }

  // 开始录制
  async startVideo() {
    try {
      Logger.info(this.tag, `startVideo begin`)
      await this.captureSession.stop()
      await this.captureSession.beginConfig()
      // await this.captureSession.removeOutput(this.photoOutput);
      this.fd = await this.getFileFd()
      this.videoRecorder = await media.createVideoRecorder()
      this.videoConfig.url = `fd://${this.fd}`
      this.videoConfig.profile.videoFrameWidth = this.cameraOutputCapability.videoProfiles[0].size.width
      this.videoConfig.profile.videoFrameHeight = this.cameraOutputCapability.videoProfiles[0].size.height
      await this.videoRecorder.prepare(this.videoConfig)
      let videoId = await this.videoRecorder.getInputSurface()
      // Logger.info(this.tag, `videoProfileObj: ` + JSON.stringify(this.videoProfileObj))
      Logger.info(this.tag, `videoConfig.profile: ` + JSON.stringify(this.videoConfig.profile))
      Logger.info(this.tag, `videoProfileObj1: ` + JSON.stringify(this.cameraOutputCapability.videoProfiles[0]))
      this.videoOutput = await this.cameraManager.createVideoOutput(this.cameraOutputCapability.videoProfiles[0], videoId)
      Logger.info(this.tag, `createVideoOutput success: ${this.videoOutput}`)
      await this.captureSession.addOutput(this.videoOutput)
      Logger.info(this.tag, `startVideo begin1`)
      await this.captureSession.commitConfig()
      Logger.info(this.tag, `startVideo begin2`)
      await this.captureSession.start()
      Logger.info(this.tag, `startVideo begin3`)
      await this.videoOutput.start()
      Logger.info(this.tag, `startVideo begin4`)
      await this.videoRecorder.start().then(() => {
        setTimeout(async () => {
          await this.stopVideo()
          Logger.info(this.tag, `setTimeout stopVideo end`)
        }, 3000)
      })
      Logger.info(this.tag, `videoOutput end`)
    } catch (err) {
      Logger.info(this.tag, `startVideo fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 停止录制
  async stopVideo() {
    try {
      if (this.videoRecorder) {
        await this.videoRecorder.stop()
        await this.videoRecorder.release()
      }
      if (this.videoOutput) {
        if (this.videoOutputStopBol) {
          await this.videoOutput.stop()
        }
        await this.videoOutput.release()
      }
      if (this.fileAsset) {
        await this.fileAsset.close(this.fd)
        return this.fileAsset
      }
      Logger.info(this.tag, `stopVideo success`)
    } catch (err) {
      Logger.info(this.tag, `stopVideo fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 查询相机设备在模式下支持的输出能力
  async getSupportedOutputCapabilityFn(cameraDeviceIndex) {
    Logger.info(this.tag, `cameraOutputCapability cameraId: ${this.cameras[cameraDeviceIndex].cameraId}`)
    // @ts-ignore
    this.cameraOutputCapability = this.cameraManager.getSupportedOutputCapability(this.cameras[cameraDeviceIndex])
    let previewSize = []
    let photoSize = []
    let videoSize = []
    this.cameraOutputCapability.previewProfiles.forEach((item, index) => {
      Logger.info(this.tag, `cameraOutputCapability previewProfiles index: ${index}, item:` + JSON.stringify(item))
      previewSize.push({
        value: `${item.size.width}x${item.size.height}`
      })
    })
    this.cameraOutputCapability.photoProfiles.forEach((item, index) => {
      Logger.info(this.tag, `cameraOutputCapability photoProfiles index: ${index}, item:` + JSON.stringify(item))
      photoSize.push({
        value: `${item.size.width}x${item.size.height}`
      })
    })
    this.cameraOutputCapability.videoProfiles.forEach((item, index) => {
      Logger.info(this.tag, `cameraOutputCapability videoProfiles index: ${index}, item:` + JSON.stringify(item))
      videoSize.push({
        value: `${item.size.width}x${item.size.height}`
      })
    })
    Logger.info(this.tag, `cameraOutputCapability previewProfiles:` + JSON.stringify(this.cameraOutputCapability.previewProfiles))
    Logger.info(this.tag, `cameraOutputCapability photoProfiles:` + JSON.stringify(this.cameraOutputCapability.photoProfiles))
    Logger.info(this.tag, `cameraOutputCapability videoProfiles:` + JSON.stringify(this.cameraOutputCapability.videoProfiles))
    Logger.info(this.tag, `cameraOutputCapability previewProfiles previewSize:` + JSON.stringify(previewSize))
    this.resolution = previewSize
    this.photoResolution = photoSize
    this.videoResolution = videoSize
    return previewSize
  }

  // 释放会话及其相关参数
  async releaseCamera() {
    try {
      if (this.cameraInput) {
        await this.cameraInput.release()
      }
      if (this.previewOutput) {
        await this.previewOutput.release()
      }
      if (this.photoOutput) {
        await this.photoOutput.release()
      }
      if (this.videoOutput) {
        await this.videoOutput.release()
      }
      if (this.captureSession) {
        await this.captureSession.release()
      }
      Logger.info(this.tag, `releaseCamera success`)
    } catch (err) {
      Logger.info(this.tag, `releaseCamera fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 释放会话
  async releaseSession() {
    await this.previewOutput.stop()
    await this.photoOutput.release()
    await this.captureSession.release()
    Logger.info(this.tag, `releaseSession success`)
  }

  // 获取相机管理器实例
  async getCameraManagerFn() {
    try {
      this.cameraManager = await camera.getCameraManager(globalThis.abilityContext)
      Logger.info(this.tag, `getCameraManager success: ` + JSON.stringify(this.cameraManager))
    } catch (err) {
      Logger.info(this.tag, `getCameraManagerFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 获取支持指定的相机设备对象
  async getSupportedCamerasFn() {
    try {
      this.cameras = await this.cameraManager.getSupportedCameras()
      Logger.info(this.tag, `getSupportedCameras success: ` + JSON.stringify(this.cameras))
      Logger.info(this.tag, `getSupportedCameras length success: ${this.cameras.length}`)
    } catch (err) {
      Logger.info(this.tag, `getSupportedCamerasFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 创建previewOutput输出对象
  async createPreviewOutputFn(previewProfilesObj, surfaceId) {
    try {
      Logger.info(this.tag, `createPreviewOutputFn previewProfilesObj success: ` + JSON.stringify(previewProfilesObj))
      this.previewOutput = await this.cameraManager.createPreviewOutput(previewProfilesObj, surfaceId.toString())
      Logger.info(this.tag, `createPreviewOutputFn success: ` + JSON.stringify(this.previewOutput))
    } catch (err) {
      Logger.info(this.tag, `createPreviewOutputFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 创建photoOutput输出对象
  async createPhotoOutputFn(photoProfileObj) {
    try {
      Logger.info(this.tag, `createPhotoOutputFn photoProfileObj success: ` + JSON.stringify(photoProfileObj))
      let mSurfaceId = await this.mReceiver.getReceivingSurfaceId()
      this.photoOutput = await this.cameraManager.createPhotoOutput(photoProfileObj, mSurfaceId)
      Logger.info(this.tag, `createPhotoOutputFn success: ` + JSON.stringify(this.photoOutput))
    } catch (err) {
      Logger.info(this.tag, `createPhotoOutputFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 创建cameraInput输出对象
  async createCameraInputFn(cameraDeviceIndex) {
    try {
      this.cameraInput = await this.cameraManager.createCameraInput(cameraDeviceIndex)
      Logger.info(this.tag, `createCameraInputFn success: ${this.cameraInput}`)
    } catch (err) {
      Logger.info(this.tag, `createCameraInputFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }

  // 打开相机
  async cameraInputOpenFn() {
    await this.cameraInput.open()
      .then((data) => {
        Logger.info(this.tag, `cameraInputOpenFn open success: ${data}`)
      })
      .catch((err) => {
        Logger.info(this.tag, `cameraInputOpenFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
      })
  }

  // 会话流程
  async sessionFlowFn() {
    try {
      // 创建captureSession实例
      this.captureSession = await this.cameraManager.createCaptureSession()
      // 开始配置会话
      await this.captureSession.beginConfig()
      // cameraInput加入会话
      await this.captureSession.addInput(this.cameraInput)
      // previewOutput加入会话
      await this.captureSession.addOutput(this.previewOutput)
      // photoOutput加入会话
      await this.captureSession.addOutput(this.photoOutput)
      // 提交配置会话
      await this.captureSession.commitConfig()
      // 开启会话
      await this.captureSession.start()
      Logger.info(this.tag, `sessionFlowFn success`)
    } catch (err) {
      Logger.info(this.tag, `sessionFlowFn fail err: ${err}, message: ${err.message}, code: ${err.code}`)
    }
  }
}

export default new CameraService()