/**
|
* 人脸识别服务模块
|
* 处理人脸识别相关的业务逻辑，包括人脸注册和人脸比对
|
*/
|
import logger from "../../dxmodules/dxLogger.js";
|
import dxCommon from "../../dxmodules/dxCommon.js";
|
import bus from "../../dxmodules/dxEventBus.js";
|
import dxMap from "../../dxmodules/dxMap.js";
|
import driver from "../driver.js";
|
import config from "../../dxmodules/dxConfig.js";
|
import sqliteService from "./sqliteService.js";
|
import std from "../../dxmodules/dxStd.js";
|
import pool from "../../dxmodules/dxWorkerPool.js";
|
|
let map = dxMap.get("LOGIN")
|
const faceService = {}
|
|
// 语音播放防抖控制
|
let lastPlayTime = 0
|
const PLAY_DELAY = 2000 // 2秒内不重复播放相同语音
|
|
/**
|
* 语音播放防抖函数
|
* @param {function} playFunction - 播放函数
|
* @returns {boolean} 是否执行了播放
|
*/
|
function debouncePlay(playFunction) {
|
const now = Date.now()
|
if (now - lastPlayTime > PLAY_DELAY) {
|
lastPlayTime = now
|
playFunction()
|
return true
|
}
|
return false
|
}
|
|
// 双人认证状态管理
|
let dualAuthState = {
|
firstUserId: null, // 第一个用户ID
|
firstUserName: null, // 第一个用户姓名
|
firstUserFileName: null, // 第一个用户人脸图片文件路径
|
firstUserIdCard: null, // 第一个用户身份证号
|
firstUserType: null, // 第一个用户身份类型
|
secondUserId: null, // 第二个用户ID
|
secondUserName: null, // 第二个用户姓名
|
secondUserIdCard: null, // 第二个用户身份证号
|
secondUserType: null, // 第二个用户身份类型
|
startTime: 0, // 开始时间
|
timeout: null, // 定时器
|
authComplete: false // 认证是否完成
|
}
|
|
/**
|
* 接收人脸识别消息并处理
|
* @param {object} data - 人脸识别数据
|
*/
|
faceService.receiveMsg = function (data) {
|
logger.info('[faceService] receiveMsg :' + JSON.stringify(data))
|
// 触发退出空闲状态事件（锁屏和息屏）
|
bus.fire("exitIdle")
|
|
switch (data.type) {
|
case "register":
|
// 注册人脸处理
|
for (let i = 0; i < data.faces.length; i++) {
|
const element = data.faces[i];
|
bus.fire("beginAddFace", element)
|
}
|
break;
|
case "compare":
|
// 人脸比对处理
|
// 显示姓名，代表有注册过人脸，但是权限不一定有效，需要进一步认证
|
for (let i = 0; i < data.faces.length; i++) {
|
const element = data.faces[i];
|
|
// 只有在认证未完成时才触发trackResult事件
|
if (!dualAuthState.authComplete) {
|
// 判断当前是第几个用户（用于双人认证）
|
let userIndex = 1 // 0表示未知，1表示第一个用户，2表示第二个用户
|
if (!dualAuthState.firstUserId) {
|
// 第一个用户还未设置，当前用户就是第一个用户
|
userIndex = 1
|
} else if (element.userId === dualAuthState.firstUserId) {
|
userIndex = 1
|
} else if (element.userId !== dualAuthState.firstUserId) {
|
userIndex = 2
|
}
|
|
logger.info('[faceService]: 准备触发trackResult事件, userIndex=' + userIndex + ', result=' + element.result + ', userId=' + element.userId + ', authComplete=' + dualAuthState.authComplete + ', fileName=' + element.fileName)
|
|
// 直接使用bus.fire触发trackResult事件
|
bus.fire("trackResult", { id: element.id, result: element.result, userId: element.userId, userIndex: userIndex, fileName: element.fileName })
|
}
|
|
if (element.result) {
|
// 人脸相似度验证通过
|
let ret = sqliteService.d1_person.find({ userId: element.userId })
|
|
if (dxMap.get("UI").get("faceAuthStart") == "Y") {
|
// 正在人脸登录
|
if (JSON.parse(ret[0].extra).type != 0) {
|
bus.fire("faceAuthResult", true)
|
} else {
|
bus.fire("faceAuthResult", false)
|
}
|
return
|
}
|
|
// 检查用户类型（管理员级别）
|
let userType = 0
|
try {
|
userType = JSON.parse(ret[0].extra).type || 0
|
} catch (error) {
|
logger.error("解析用户类型失败")
|
}
|
|
// 管理员级别用户（type != 0）直接认证通过
|
if (userType != 0) {
|
// 清除双人认证状态
|
clearDualAuthState()
|
|
// 根据语音模式播放相应的语音
|
switch (config.get("face.voiceMode")) {
|
case 0:
|
// 无语音
|
break;
|
case 1:
|
// 播放名字
|
driver.alsa.ttsPlay(ret[0].name)
|
break;
|
case 2:
|
// 播放问候语
|
driver.alsa.ttsPlay(config.get("face.voiceModeDate") ? config.get("face.voiceModeDate") : "欢迎光临")
|
break;
|
default:
|
break;
|
}
|
|
// 通行认证处理
|
bus.fire("access", { data: { type: "300", code: element.userId }, fileName: element.fileName })
|
} else {
|
// 非管理员级别用户，需要双人认证
|
handleDualAuth(element.userId, ret[0].name, element.fileName)
|
}
|
} else {
|
// 人脸相似度验证失败
|
if (dxMap.get("UI").get("faceAuthStart") == "Y") {
|
// 人脸登录失败
|
bus.fire("faceAuthResult", false)
|
} else {
|
// 陌生人处理
|
switch (config.get("face.stranger")) {
|
case 0:
|
// 无语音
|
break;
|
case 1:
|
// 播放请先注册（防抖控制）
|
debouncePlay(() => {
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/register.wav`)
|
})
|
break;
|
case 2:
|
// 播放陌生人你好（防抖控制）
|
debouncePlay(() => {
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/stranger.wav`)
|
})
|
break;
|
default:
|
break;
|
}
|
// 通行认证处理（相似度验证失败）
|
bus.fire("access", { data: { type: "300", code: element.userId }, fileName: element.fileName, similarity: false })
|
}
|
}
|
}
|
break;
|
default:
|
break;
|
}
|
}
|
|
// 监听通行解锁完成事件，重置双人认证状态
|
bus.on('accessUnlockComplete', () => {
|
logger.info('[faceService]: accessUnlockComplete事件触发，重置双人认证状态')
|
clearDualAuthState()
|
})
|
|
/**
|
* 清除双人认证状态
|
*/
|
function clearDualAuthState() {
|
dualAuthState.firstUserId = null
|
dualAuthState.firstUserName = null
|
dualAuthState.firstUserFileName = null
|
dualAuthState.firstUserIdCard = null
|
dualAuthState.firstUserType = null
|
dualAuthState.secondUserId = null
|
dualAuthState.secondUserName = null
|
dualAuthState.secondUserIdCard = null
|
dualAuthState.secondUserType = null
|
dualAuthState.startTime = 0
|
dualAuthState.authComplete = false // 重置认证完成标志
|
if (dualAuthState.timeout) {
|
std.clearTimeout(dualAuthState.timeout)
|
dualAuthState.timeout = null
|
}
|
}
|
|
/**
|
* 处理双人认证超时
|
*/
|
function handleDualAuthTimeout() {
|
try {
|
// 保存认证记录
|
if (dualAuthState.firstUserId && !dualAuthState.authComplete) {
|
// 查询第一用户的详细信息，获取身份类型
|
let firstUserType = dualAuthState.firstUserType || 0
|
if (!firstUserType) {
|
let res = sqliteService.d1_person.findByUserId(dualAuthState.firstUserId)
|
if (res.length > 0) {
|
try {
|
firstUserType = JSON.parse(res[0].extra).type || 0
|
} catch (error) {
|
logger.error("无第一用户类型")
|
}
|
}
|
}
|
|
// 查询第二用户的详细信息，获取身份类型
|
let secondUserType = dualAuthState.secondUserType || 0
|
if (dualAuthState.secondUserId && !secondUserType) {
|
let res = sqliteService.d1_person.findByUserId(dualAuthState.secondUserId)
|
if (res.length > 0) {
|
try {
|
secondUserType = JSON.parse(res[0].extra).type || 0
|
} catch (error) {
|
logger.error("无第二用户类型")
|
}
|
}
|
}
|
|
// 创建认证记录
|
const record = {
|
id: std.genRandomStr(16),
|
userId: dualAuthState.firstUserId,
|
userId2: dualAuthState.secondUserId || "",
|
type: "300", // 人脸认证（字符串格式）
|
code: dualAuthState.firstUserFileName, // 人脸抓拍图片路径
|
result: 1, // 认证失败（0成功，1失败）
|
time: Math.floor(Date.now() / 1000), // 时间戳（秒）
|
message: "双人认证超时",
|
extra: JSON.stringify({ name: dualAuthState.firstUserName, idCard: dualAuthState.firstUserIdCard, type: firstUserType }),
|
extra2: dualAuthState.secondUserId ? JSON.stringify({ name: dualAuthState.secondUserName || "", idCard: dualAuthState.secondUserIdCard || "", type: secondUserType }) : "",
|
permissionId: firstUserType.toString(),
|
permissionId2: dualAuthState.secondUserId ? secondUserType.toString() : ""
|
}
|
|
// 保存到数据库
|
sqliteService.d1_pass_record.save(record)
|
logger.info(`[faceService]: 保存双人认证超时记录: ${JSON.stringify(record)}`)
|
}
|
|
// 清除认证状态
|
clearDualAuthState()
|
|
// 播放失败提示音
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/verify_300_f.wav`)
|
|
// 语音提示认证失败
|
// driver.alsa.ttsPlay("双人认证超时，认证失败")
|
|
// 触发认证失败事件
|
bus.fire("showAccessResult", {
|
faceAuth: false,
|
gasConcentration: true,
|
accessAllowed: false,
|
message: "*双人认证超时，认证失败*"
|
})
|
|
// 触发通行失败事件，通知UI重置
|
bus.fire("accessRes", false)
|
|
|
} catch (error) {
|
logger.error(`[faceService]: 处理双人认证超时错误: ${error.message}`)
|
}
|
}
|
|
/**
|
* 处理双人认证逻辑
|
* @param {string} userId - 当前用户ID
|
* @param {string} userName - 当前用户姓名
|
* @param {string} fileName - 人脸图片文件路径
|
*/
|
function handleDualAuth(userId, userName, fileName) {
|
try {
|
if (!dualAuthState.firstUserId) {
|
// 第一次认证
|
dualAuthState.firstUserId = userId
|
dualAuthState.firstUserName = userName
|
dualAuthState.firstUserFileName = fileName
|
|
// 查询第一用户的详细信息，获取身份证号和身份类型
|
let res = sqliteService.d1_person.findByUserId(userId)
|
if (res.length > 0) {
|
let idCard
|
let userType = 0
|
try {
|
idCard = JSON.parse(res[0].extra).idCard
|
userType = JSON.parse(res[0].extra).type || 0
|
} catch (error) {
|
logger.error("无第一用户身份证号或类型")
|
}
|
dualAuthState.firstUserIdCard = idCard
|
dualAuthState.firstUserType = userType
|
}
|
|
dualAuthState.startTime = Date.now()
|
|
// 清除之前的定时器
|
if (dualAuthState.timeout) {
|
std.clearTimeout(dualAuthState.timeout)
|
}
|
|
// 设置1分钟超时
|
dualAuthState.timeout = std.setTimeout(() => {
|
// 超时处理，视为认证失败
|
handleDualAuthTimeout()
|
}, 60000)
|
|
// 语音提示-请第二用户进行认证
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/user2.wav`)
|
} else {
|
// 第二次认证
|
if (userId !== dualAuthState.firstUserId) {
|
// 不同用户，认证通过
|
// 查询第二用户的详细信息，获取身份证号和身份类型
|
let secondUserIdCard = ""
|
let secondUserType = 0
|
let res = sqliteService.d1_person.findByUserId(userId)
|
if (res.length > 0) {
|
try {
|
secondUserIdCard = JSON.parse(res[0].extra).idCard
|
secondUserType = JSON.parse(res[0].extra).type || 0
|
} catch (error) {
|
logger.error("无第二用户身份证号或类型")
|
}
|
}
|
|
// 保存双人认证状态信息，用于UI更新
|
let dualAuthInfo = {
|
firstUserId: dualAuthState.firstUserId,
|
firstUserName: dualAuthState.firstUserName,
|
secondUserId: userId,
|
secondUserName: userName,
|
secondUserIdCard: secondUserIdCard,
|
secondUserType: secondUserType
|
}
|
// 保存第一用户的人脸图片路径
|
let firstUserFileName = dualAuthState.firstUserFileName
|
// 设置认证完成标志
|
dualAuthState.authComplete = true
|
clearDualAuthState()
|
|
// 语音提示-双人认证通过
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/user2_s.wav`)
|
|
// 通行认证处理，传递双人认证信息
|
bus.fire("access", { data: { type: "300", code: userId, dualAuthInfo: dualAuthInfo, authComplete: true, firstUserFileName: firstUserFileName }, fileName: fileName })
|
} else {
|
// 同一用户，重新开始
|
dualAuthState.firstUserId = userId
|
dualAuthState.firstUserName = userName
|
|
// 查询用户的详细信息，获取身份证号和身份类型
|
let idCard
|
let userType = 0
|
let res = sqliteService.d1_person.findByUserId(userId)
|
if (res.length > 0) {
|
try {
|
idCard = JSON.parse(res[0].extra).idCard
|
userType = JSON.parse(res[0].extra).type || 0
|
} catch (error) {
|
logger.error("无用户身份证号或类型")
|
}
|
dualAuthState.firstUserIdCard = idCard
|
dualAuthState.firstUserType = userType
|
}
|
|
dualAuthState.startTime = Date.now()
|
|
// 清除之前的定时器
|
if (dualAuthState.timeout) {
|
std.clearTimeout(dualAuthState.timeout)
|
}
|
|
// 重新设置1分钟超时
|
dualAuthState.timeout = std.setTimeout(() => {
|
// 超时处理，视为认证失败
|
handleDualAuthTimeout()
|
}, 60000)
|
|
// 语音提示-请第二用户进行认证
|
driver.alsa.play(`/app/code/resource/${config.get("base.language") == "CN" ? "CN" : "EN"}/wav/user2.wav`)
|
}
|
}
|
} catch (error) {
|
logger.error(`[faceService]: 处理双人认证错误: ${error.message}`)
|
// 清除认证状态
|
clearDualAuthState()
|
}
|
}
|
/**
|
* 人脸注册错误枚举
|
* 包含各种注册失败的错误码和对应的错误信息
|
*/
|
faceService.regErrorEnum = {
|
"callback": {
|
title: "注册回调状态枚举",
|
"-1": "faceService.contrastFailure", // 对比失败
|
"-2": "faceService.scalingFailure", // 缩放失败
|
"-3": "faceService.failedToSavePicture", // 保存图片失败
|
"-4": "faceService.convertToBase64Fail", // 转换为base64失败
|
},
|
"feature": {
|
title: "特征值注册状态枚举",
|
"-1": "faceService.base64DecodingFail", // base64解码失败
|
"-10": "faceService.contrastFailure", // 对比失败
|
"-11": "faceService.similarityOverheight", // 相似度过高
|
},
|
"picture": {
|
title: "图片注册状态枚举",
|
"-1": "faceService.fileDoesNotExist", // 文件不存在
|
"-2": "faceService.theImageFormatIsNotSupported", // 图片格式不支持
|
"-3": "faceService.pictureReadFailure", // 图片读取失败
|
"-4": "faceService.thePictureSizeDoesNotMatch", // 图片尺寸不匹配
|
"-5": "faceService.imageParsingFailure", // 图片解析失败
|
"-6": "faceService.imageYUVProcessingFailed", // 图片YUV处理失败
|
"-7": "faceService.failedToConvertJpegToImage", // JPEG转换为图片失败
|
"-8": "faceService.faceInformationExtractionFailed", // 人脸信息提取失败
|
"-9": "faceService.theFaceIsNotUnique", // 人脸不唯一
|
"-10": "faceService.contrastFailure", // 对比失败
|
"-11": "faceService.similarityOverheight", // 相似度过高
|
}
|
}
|
|
export default faceService
|
