HarmonyOS鸿蒙Next中uniapp怎么实现人脸识别功能

可以使用uts插件调用鸿蒙端人体监测功能

需要申请ohos.permission.CAMERA权限

import { BusinessError } from '@kit.BasicServicesKit';
import { interactiveLiveness } from '@kit.VisionKit';
import { abilityAccessCtrl, PermissionRequestResult, Permissions } from '@kit.AbilityKit';
import { image } from '@kit.ImageKit';

import { DetectOptions } from '../interface.uts'

// Permission.ets
function grant(permission: Permissions): Promise<boolean> {
    return grants([permission]);
}

function grants(permissions: Array<Permissions>): Promise<boolean> {
    return new Promise(async (resolve, reject) => {
        try {
            let context = getContext();

            let atManager: abilityAccessCtrl.AtManager = abilityAccessCtrl.createAtManager();
            let permissionResult: PermissionRequestResult = await atManager.requestPermissionsFromUser(context, permissions);
            let grantStatus: Array<number> = permissionResult.authResults;
            let length: number = grantStatus.length;

            let flag = false;
            for (let i = 0; i < length; i++) {
                if (grantStatus[i] === 0) {
                    // 用户授权，可以继续访问目标操作
                    flag = true;
                    // 只有一个权限
                    break;
                } else {
                    // 用户拒绝授权，提示用户必须授权才能访问当前页面的功能，并引导用户到系统设置中打开相应的权限
                }
            }
            resolve(flag);
        } catch (err) {
            reject(err);
        }
    });
}

// ImageUtil.ets
function pixelMapToArrayBuffer(mPixelMap: image.PixelMap, format: string = "image/jpeg", quality: number = 100): Promise<ArrayBuffer> {
    return new Promise(async (resolve, reject) => {
        try {
            const imagePackerApi = image.createImagePacker();
            let packOpts : image.PackingOption = { format, quality };
            const data = await imagePackerApi.packing(mPixelMap, packOpts)
            resolve(data)
        } catch (error) {
            reject(error);
        }
    })
}

// LivenessUtil.ets
const DEFAULT_LIVENESS_CONFIG: interactiveLiveness.InteractiveLivenessConfig = {
    isSilentMode: "INTERACTIVE_MODE" as interactiveLiveness.DetectionMode,
    routeMode: "back" as interactiveLiveness.RouteRedirectionMode,
    actionsNum: 3
}

const BUSINESS_ERROR_CODES = [1008301002, 1008302000, 1008302001, 1008302002, 1008302003, 1008302004];
const DETECTION_MODES: Array<String> = ['INTERACTIVE_MODE', 'SILENT_MODE']
const ACTIONS_NUMS: Array<Number> = [1, 2, 3, 4]

function _livenessDetection(livenessConfig: interactiveLiveness.InteractiveLivenessConfig): Promise<interactiveLiveness.InteractiveLivenessResult> {
    return new Promise(async (resolve, reject) => {
        try {
            const isGranted = await grant("ohos.permission.CAMERA");
            if (!isGranted) {
                reject({code: 201, message: "Permission denied"} as BusinessError)
                return;
            }
            interactiveLiveness.startLivenessDetection(livenessConfig, async (err, result: interactiveLiveness.InteractiveLivenessResult | undefined) => {
                if (err.code !== 0 || result === undefined) {
                    reject(err)
                    return
                }
                resolve(result);
            })
        } catch (error) {
            reject(error);
        }
    })
}

interface LivenessDetectionResult {
    isLive: boolean
    image: ArrayBuffer
}

function livenessDetection(livenessConfig: interactiveLiveness.InteractiveLivenessConfig = DEFAULT_LIVENESS_CONFIG): Promise<LivenessDetectionResult> {
    return new Promise(async (resolve, reject) => {
        try {

            const detectionResult = await _livenessDetection(livenessConfig);
            if (detectionResult?.mPixelMap) {
                const arrayBuffer = await pixelMapToArrayBuffer(detectionResult.mPixelMap)
                resolve({
                    isLive: true,
                    image: arrayBuffer
                } as LivenessDetectionResult)
            } else {
                resolve({
                    isLive: false
                } as LivenessDetectionResult)
            }
        } catch (error) {
            if (BUSINESS_ERROR_CODES.includes((error as BusinessError).code)) {
                resolve({
                    isLive: false
                } as LivenessDetectionResult)
            } else {
                reject(error);
            }
        }
    })
}

// 主要的部分
function validateOptions(options: DetectOptions): boolean {
    let actionsNum = options.actionsNum;
    let isSilentMode = options.isSilentMode;

    if (actionsNum && typeof actionsNum !== 'number') {
        return false;
    }

    if (isSilentMode && typeof isSilentMode !== 'string') {
        return false;
    }

    if (actionsNum && !ACTIONS_NUMS.includes(actionsNum)) {
        return false;
    }

    if (isSilentMode && !DETECTION_MODES.includes(isSilentMode)) {
        return false;
    }

    return true;
}

export function detect(options: DetectOptions): void {
	if (!validateOptions(options)) {
		const businessError = {code: 401, message: "Parameter error"} as BusinessError;
		options?.fail?.(businessError);
		options?.complete?.(businessError);
		return;
	}
    livenessDetection({
        actionsNum: options.actionsNum,
        isSilentMode: options.isSilentMode as interactiveLiveness.DetectionMode,
		routeMode: "back" as interactiveLiveness.RouteRedirectionMode
    } as interactiveLiveness.InteractiveLivenessConfig).then(result => {
        const detectResult:DetectResult = {
            alive: result.isLive,
            image: result.image
        }
        options?.success?.(detectResult);
        options?.complete?.(detectResult);
    }).catch((error: BusinessError) => {
        options?.fail?.(error);
        options?.complete?.(error);
    })
}

<template>
	<view>
		<view>ohos.permission.CAMERA 需要加这个权限</view>
		<button @tap="detectLiveness">活体检测</button>
		<image v-if="imageData" :src="imageData" mode="widthFix"></image>
	</view>
</template>

<script>
	import livenessUtil from '@/uni_modules/hw-liveness'
	export default {
		data() {
			return {
				imageData: ''
			}
		},
		methods: {
			detectLiveness() {
				livenessUtil.detect({
					actionsNum: 3,
					success: (res) => {
						console.log(JSON.stringify(res))
						uni.showModal({
							title: res.alive? '检测成功' : '检测失败'
						})
						this.imageData = "data:image/jpeg;base64," + uni.arrayBufferToBase64(res.image)
					},
					fail: (err) => {
						uni.showModal({
							title: err.message
						})
					}
				});
			}
		}
	}
</script>

<style>
</style>

HarmonyOS Next中，UniApp实现人脸识别需使用系统提供的AI能力接口。通过@ohos.multimodalInput.facialAuth（人脸认证）Kit实现。主要步骤：1. 检查设备支持；2. 调用相关API进行人脸采集与认证。需在module.json5中声明ohos.permission.FACE_AUTH权限。