HarmonyOS 人脸活体检测问题

请参考示例如下：

import { abilityAccessCtrl, common, Permissions } from '@kit.AbilityKit';
import { interactiveLiveness } from '@kit.VisionKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { faceComparator } from '@kit.CoreVisionKit';
import { TAG } from '@ohos/hypium/src/main/Constant';

export class FaceCheck {

  // 校验CAMERA权限
  public privateStartDetection(context: common.UIAbilityContext, permissions: Permissions[]): Promise<boolean> {
    return new Promise((resolve, reject) => {
      abilityAccessCtrl.createAtManager().requestPermissionsFromUser(context, permissions).then((res) => {
        for (let i = 0; i < res.permissions.length; i++) {
          if (res.permissions[i] === "ohos.permission.CAMERA" && res.authResults[i] === 0) {
            resolve(true)
          } else {
            reject(false)
          }
        }
      })
    })
  }

  // 路由跳转到人脸活体验证控件
  public privateRouterLibrary(isSilentMode: string = 'SILENT_MODE', routeMode: string = "replace",
    actionsNum = 1): Promise<boolean> {
    let routerOptions: interactiveLiveness.InteractiveLivenessConfig = {
      isSilentMode: isSilentMode as interactiveLiveness.DetectionMode,
      routeMode: routeMode as interactiveLiveness.RouteRedirectionMode,
      actionsNum: actionsNum
    }

    return new Promise((resolve, reject) => {
      interactiveLiveness.startLivenessDetection(routerOptions).then((DetectState: boolean) => {
        return resolve(DetectState)


      }).catch((err: BusinessError) => {
        hilog.error(0x0001, "LivenessCollectionIndex", `Failed to jump. Code：${err.code}，message：${err.message}`);
        reject(false)
      })
    })
  }

  public async faceCompare(pixelMap: PixelMap,chooseImage1:PixelMap,dataValues:string): Promise<string> {
    if (!pixelMap || !chooseImage1) {
      hilog.error(0x0000, TAG, "Failed to choose image");
      return '';
    }
    // 调用人脸比对接口
    let visionInfo: faceComparator.VisionInfo = {
      pixelMap: pixelMap,
    };
    let visionInfo1: faceComparator.VisionInfo = {
      pixelMap: chooseImage1,
    };
    let data: faceComparator.FaceCompareResult = await faceComparator.compareFaces(visionInfo, visionInfo1);
    let faceString =
      "degree of similarity：" + this.toPercentage(data.similarity) + ((data.isSamePerson) ? ". is" : ". no") +
        "same person";
    hilog.info(0x0000, TAG, "faceString data is " + faceString);
    dataValues = faceString;
    return dataValues
  }

  private toPercentage(num: number): string {
    return `${(num * 100).toFixed(2)}%`;
  }
}
import { common, abilityAccessCtrl, Permissions } from '@kit.AbilityKit';
import { interactiveLiveness } from '@kit.VisionKit';
import { BusinessError } from '@kit.BasicServicesKit';
import { hilog } from '@kit.PerformanceAnalysisKit';

@Entry
@Component
struct FacePage {
  private context: common.UIAbilityContext = getContext(this) as common.UIAbilityContext;
  private array: Array<Permissions> = ["ohos.permission.CAMERA"];
  @State actionsNum: number = 0;
  @State isSilentMode: string = "INTERACTIVE_MODE";
  @State routeMode: string = "replace";
  @State resultInfo: interactiveLiveness.InteractiveLivenessResult = {
    livenessType: 0
  };
  @State failResult: Record<string, number | string> = {
    "code": 1008302000,
    "message": ""
  };

  build() {
    Stack({
      alignContent: Alignment.Top
    }) {
      Column() {
        Row() {
          Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
            Text("选择模式：")
              .fontSize(18)
              .width("25%")
            Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
              Row() {
                Radio({ value: "INTERACTIVE_MODE", group: "isSilentMode" }).checked(true)
                  .height(24)
                  .width(24)
                  .onChange((isChecked: boolean) => {
                    this.isSilentMode = "INTERACTIVE_MODE"
                  })
                Text("动作活体检测")
                  .fontSize(16)
              }
              .margin({ right: 15 })

              Row() {
                Radio({ value: "SILENT_MODE", group: "isSilentMode" }).checked(false)
                  .height(24)
                  .width(24)
                  .onChange((isChecked: boolean) => {
                    this.isSilentMode = "SILENT_MODE";
                  })
                Text("静默活体检测")
                  .fontSize(16)
              }
            }
            .width("75%")
          }
        }
        .margin({ bottom: 30 })

        Row() {
          Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
            Text("验证完的跳转模式：")
              .fontSize(18)
              .width("25%")
            Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
              Row() {
                Radio({ value: "replace", group: "routeMode" }).checked(true)
                  .height(24)
                  .width(24)
                  .onChange((isChecked: boolean) => {
                    this.routeMode = "replace"
                  })
                Text("replace")
                  .fontSize(16)
              }
              .margin({ right: 15 })

              Row() {
                Radio({ value: "back", group: "routeMode" }).checked(false)
                  .height(24)
                  .width(24)
                  .onChange((isChecked: boolean) => {
                    this.routeMode = "back";
                  })
                Text("back")
                  .fontSize(16)
              }
            }
            .width("75%")
          }
        }
        .margin({ bottom: 30 })

        if (this.isSilentMode == "INTERACTIVE_MODE") {
          Row() {
            Flex({ direction: FlexDirection.Row, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
              Text("动作数量：")
                .fontSize(18)
                .width("25%")
              TextInput({
                placeholder: this.actionsNum != 0 ? this.actionsNum.toString() : "动作数量最多4个"
              })
                .type(InputType.Number)
                .placeholderFont({
                  size: 18,
                  weight: FontWeight.Normal,
                  family: "HarmonyHeiTi",
                  style: FontStyle.Normal
                })
                .fontSize(18)
                .fontWeight(FontWeight.Bold)
                .fontFamily("HarmonyHeiTi")
                .fontStyle(FontStyle.Normal)
                .width("65%")
                .onChange((value: string) => {
                  this.actionsNum = Number(value) as interactiveLiveness.ActionsNumber;
                })
            }
          }
        }
      }
      .margin({ left: 24, top: 80 })
      .zIndex(1)

      Stack({
        alignContent: Alignment.Bottom
      }) {
        if (this.resultInfo?.mPixelMap) {
          Image(this.resultInfo?.mPixelMap)
            .width(260)
            .height(260)
            .align(Alignment.Center)
            .margin({ bottom: 260 })
          Circle()
            .width(300)
            .height(300)
            .fillOpacity(0)
            .strokeWidth(60)
            .stroke(Color.White)
            .margin({ bottom: 250, left: 0 })
        }

        Text(this.resultInfo.mPixelMap ?
          "检测成功" :
          this.failResult.code != 1008302000 ?
            "检测失败" :
            "")
          .width("100%")
          .height(26)
          .fontSize(20)
          .fontColor("#000000")
          .fontFamily("HarmonyHeiTi")
          .margin({ top: 50 })
          .textAlign(TextAlign.Center)
          .fontWeight("Medium")
          .margin({ bottom: 240 })

        if(this.failResult.code != 1008302000) {
          Text(this.failResult.message as string)
            .width("100%")
            .height(26)
            .fontSize(16)
            .fontColor(Color.Gray)
            .textAlign(TextAlign.Center)
            .fontFamily("HarmonyHeiTi")
            .fontWeight("Medium")
            .margin({ bottom: 200 })
        }

        Button("开始检测", { type: ButtonType.Normal, stateEffect: true })
          .width(192)
          .height(40)
          .fontSize(16)
          .backgroundColor(0x317aff)
          .borderRadius(20)
          .margin({
            bottom: 56
          })
          .onClick(() => {
            this.privatestartDetection();
          })
      }
      .height("100%")
    }
  }

  onPageShow() {
    this.resultRelease();
    this.getDectionRsultInfo();
  }

  // 路由跳转到人脸活体验证控件
  private privaterouterLibrary() {
    let routerOptions: interactiveLiveness.InteractiveLivenessConfig = {
      "isSilentMode": this.isSilentMode as interactiveLiveness.DetectionMode,
      "routeMode": this.routeMode as interactiveLiveness.RouteRedirectionMode,
      "actionsNum": this.actionsNum
    }

    interactiveLiveness.startLivenessDetection(routerOptions).then((DetectState: boolean) => {
      hilog.info(0x0001, "LivenessCollectionIndex", `Succeeded in jumping.`);
    }).catch((err: BusinessError) => {
      hilog.error(0x0001, "LivenessCollectionIndex", `Failed to jump. Code：${err.code}，message：${err.message}`);
    })
  }

  // 校验CAMERA权限
  private privatestartDetection() {
    abilityAccessCtrl.createAtManager().requestPermissionsFromUser(this.context, this.array).then((res) => {
      for (let i = 0; i < res.permissions.length; i++) {
        if (res.permissions[i] === "ohos.permission.CAMERA" && res.authResults[i] === 0) {
          this.privaterouterLibrary();
        }
      }
    })
  }

  // 获取验证结果
  private getDectionRsultInfo() {
    // getInteractiveLivenessResult接口调用完会释放资源
    let resultInfo = interactiveLiveness.getInteractiveLivenessResult();
    resultInfo.then(data => {
      this.resultInfo = data;
    }).catch((err: BusinessError) => {
      this.failResult = {
        "code": err.code,
        "message": err.message
      }
    })
  }

  // result release
  private resultRelease() {
    this.resultInfo = {
      livenessType: 0
    }
    this.failResult = {
      "code": 1008302000,
      "message": ""
    }
  }
}