通过摄像头实时预览拍摄画面，并截取一帧用于识别转换PixelMap时报错

import camera from '@ohos.multimedia.camera'; 
import image from '@ohos.multimedia.image'; 
import abilityAccessCtrl from '@ohos.abilityAccessCtrl'; 
import common from '@ohos.app.ability.common'; 
import fs from '@ohos.file.fs'; 
import { BusinessError } from '@kit.BasicServicesKit'; 
import PhotoAccessHelper from '@ohos.file.photoAccessHelper'; 
 
@Entry 
@Component 
struct Scan1 { 
  @State message: string = 'Hello World' 
  private mXComponentController: XComponentController = new XComponentController; 
  private surfaceId: string = '-1'; 
  @State imgUrl: PixelMap | undefined = undefined; 
  private context: ESObject = undefined 
  private previewProfilesObj2: camera.Profile | undefined = undefined; 
  private receiver: image.ImageReceiver | undefined = undefined; 
  @State pixma: PixelMap | undefined = undefined 
  @State photoOutput: camera.PhotoOutput | undefined = undefined; 
  aboutToAppear() { 
    //申请权限 
    let context = getContext() as common.UIAbilityContext; 
    abilityAccessCtrl.createAtManager().requestPermissionsFromUser(context, ['ohos.permission.CAMERA']).then(() => { 
 
      this.createDualChannelPreview(this.surfaceId); 
    }); 
 
  } 
  onPageShow(): void { 
    this.createDualChannelPreview(this.surfaceId); 
 
  } 
  async createDualChannelPreview(XComponentSurfaceId: string): Promise<void> { 
    let cameraManager = await camera.getCameraManager(getContext() as ESObject); 
    let camerasDevices: Array<camera.CameraDevice> = cameraManager.getSupportedCameras(); // 获取支持的相机设备对象 
    // 获取profile对象 
    let profiles: camera.CameraOutputCapability = cameraManager.getSupportedOutputCapability(camerasDevices[0]); // 获取对应相机设备profiles 
    let previewProfiles: Array<camera.Profile> = profiles.previewProfiles; 
    // 预览流2 
    this.previewProfilesObj2 = previewProfiles[0]; 
    this.receiver = image.createImageReceiver(this.previewProfilesObj2.size.width, this.previewProfilesObj2.size.height, 2000, 8); 
    // 创建 预览流2 输出对象 
    let imageReceiverSurfaceId: string = await this.receiver.getReceivingSurfaceId(); 
    let previewOutput2: camera.PreviewOutput = cameraManager.createPreviewOutput(this.previewProfilesObj2, imageReceiverSurfaceId); 
    // 创建拍照输出流 
    // let photoOutput: camera.PhotoOutput | undefined = undefined; 
    let photoProfilesArray: Array<camera.Profile> = profiles.photoProfiles; 
    try { 
      this.photoOutput = cameraManager.createPhotoOutput(photoProfilesArray[0]); 
    } catch (error) { 
      let err = error as BusinessError; 
      console.error('Failed to createPhotoOutput errorCode = ' + err.code); 
    } 
    if (this.photoOutput === undefined) { 
      return; 
    } 
    // 创建cameraInput对象 
    let cameraInput: camera.CameraInput = cameraManager.createCameraInput(camerasDevices[0]); 
    // 打开相机 
    await cameraInput.open(); 
    // 会话流程 
    let captureSession: camera.CaptureSession = cameraManager.createCaptureSession(); 
    // 开始配置会话 
    captureSession.beginConfig(); 
    // 把CameraInput加入到会话 
    captureSession.addInput(cameraInput); 
    // 把 预览流2 加入到会话 
    captureSession.addOutput(previewOutput2); 
    try { 
      captureSession.addOutput(this.photoOutput); 
    } catch (error) { 
      let err = error as BusinessError; 
      console.error('Failed to addOutput(photoOutput). errorCode = ' + err.code); 
    } 
    // 提交配置信息 
    await captureSession.commitConfig(); 
    // 会话开始 
    await captureSession.start(); 
    this.onImageArrival(this.receiver); 
    this.setPhotoOutputCb(this.photoOutput) 
  } 
  async savePicture(buffer: ArrayBuffer, img: image.Image) { 
    const context = getContext(this); 
    let photoAccessHelper: PhotoAccessHelper.PhotoAccessHelper = PhotoAccessHelper.getPhotoAccessHelper(context); 
    let options: PhotoAccessHelper.CreateOptions = { 
      title: Date.now().toString() 
    }; 
    let photoUri: string = await photoAccessHelper.createAsset(PhotoAccessHelper.PhotoType.IMAGE, 'jpg', options); 
    //createAsset的调用需要ohos.permission.READ_IMAGEVIDEO和ohos.permission.WRITE_IMAGEVIDEO的权限 
    let file: fs.File = fs.openSync(photoUri, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 
    await fs.write(file.fd, buffer); 
    fs.closeSync(file); 
    img.release(); 
  } 
  setPhotoOutputCb(photoOutput: camera.PhotoOutput) { 
    //设置回调之后，调用photoOutput的capture方法，就会将拍照的buffer回传到回调中 
    photoOutput.on('photoAvailable', (errCode: BusinessError, photo: camera.Photo): void => { 
      console.info('getPhoto start'); 
      console.info(`err: ${JSON.stringify(errCode)}`); 
      if (errCode || photo === undefined) { 
        console.error('getPhoto failed'); 
        return; 
      } 
      let imageObj = photo.main; 
      imageObj.getComponent(image.ComponentType.JPEG, (errCode: BusinessError, component: image.Component): void => { 
        console.info('getComponent start'); 
        if (errCode || component === undefined) { 
          console.error('getComponent failed'); 
          return; 
        } 
        let buffer: ArrayBuffer; 
        if (component.byteBuffer) { 
          buffer = component.byteBuffer; 
          if (component.byteBuffer as ArrayBuffer) { 
            let sourceOptions: image.SourceOptions = { 
              sourceDensity: 120, 
              // sourcePixelFormat: 3, // NV21 
              sourceSize: { 
                height: 240, 
                width: 320 
              }, 
            } 
            try { 
              let imageResource = image.createImageSource(component.byteBuffer); 
              imageResource.createPixelMap({}).then((res)=>{ 
                this.pixma = res; 
              }); 
            }catch (error) { 
              let err = error as BusinessError; 
              console.error('Failed to addOutput(photoOutput). errorCode = ' + err.code); 
            } 
          } else { 
            return; 
          } 
        } else { 
          console.error('byteBuffer is null'); 
          return; 
        } 
        this.savePicture(buffer, imageObj); 
      }); 
    }); 
  } 
  async onImageArrival(receiver: image.ImageReceiver): Promise<void> { 
    receiver.on('imageArrival', () => { 
      console.error("imageArrival callback"); 
      receiver.readLatestImage((err, nextImage: image.Image) => { 
        if (err || nextImage === undefined) { 
          return; 
        } 
        nextImage.getComponent(image.ComponentType.JPEG, async (err, imgComponent: image.Component) => { 
          if (err || imgComponent === undefined) { 
            return; 
          } 
          this.saveImageToFile(imgComponent.byteBuffer); 
          if (imgComponent.byteBuffer as ArrayBuffer) { 
            let sourceOptions: image.SourceOptions = { 
              sourceDensity: 120, 
              sourcePixelFormat: 8, // NV21 
              sourceSize: { 
                height: this.previewProfilesObj2!.size.height, 
                width: this.previewProfilesObj2!.size.width 
              }, 
            } 
            let imageResource = image.createImageSource(imgComponent.byteBuffer, sourceOptions); 
            let decodingOptions : image.DecodingOptions = { 
              editable: true, 
              desiredPixelFormat: 3, 
 
            } 
            imageResource.createPixelMap(decodingOptions).then((res)=>{ 
              this.imgUrl = res; 
            }); 
          } else { 
            return; 
          } 
          nextImage.release(); 
        }) 
      }) 
    }) 
  } 
  saveImageToFile(data: ArrayBuffer) { 
    const context = getContext(this); 
    let filePath = context.tempDir + "/test.jpg"; 
    console.info("path is " + filePath); 
    let file = fs.openSync(filePath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE); 
    fs.write(file.fd, data, (err, writeLen) => { 
      if (err) { 
        console.info("write failed with error message: " + err.message + ", error code: " + err.code); 
      } else { 
        console.info("write data to file succeed and size is:" + writeLen); 
        fs.closeSync(file); 
      } 
    }); 
  } 
  build() { 
    Column() { 
      Row() { 
        // 将编辑好的pixelMap传递给状态变量imagePixelMap后，通过Image组件进行渲染 
        Image(this.imgUrl).objectFit(ImageFit.None) 
      }.width('100%').height('50%').backgroundColor('#F0F0F0') 
      Row() { 
        Button() { 
          Text("拍照") 
            .fontColor(Color.Black) 
            .alignSelf(ItemAlign.Center) 
            .onClick(() => { 
              // this.capture(this.photoOutPut, null) 
              let settings: camera.PhotoCaptureSetting = { 
                quality: camera.QualityLevel.QUALITY_LEVEL_HIGH, // 设置图片质量高 
                rotation: camera.ImageRotation.ROTATION_0, // 设置图片旋转角度0 
                mirror: false // 设置镜像使能开关(默认关) 
              }; 
              if (this.photoOutput){ 
                this.photoOutput.capture(settings, (err: BusinessError) => { 
                  if (err) { 
                    console.error(`Failed to capture the photo. error: ${JSON.stringify(err)}`); 
                    return; 
                  } 
                  console.info('Callback invoked to indicate the photo capture request success.'); 
                }); 
              } 
 
            }) 
        } 
        .width(100) 
        .height(100) 
        Image(this.pixma) 
          .width(200) 
          .height(200) 
      } 
    } 
  } 
}