result = new ArrayList<>(1);
+ result.add(largestFace);
+ return result;
+ }
+
+ /**
+ * 更新当前最大脸目标，并将刚退出目标位的人脸恢复为可重试状态。
+ * 这样目标再次成为最大脸时不会停留在已经没有异步任务的 SEARCHING 状态。
+ *
+ * @param trackId 当前最大脸跟踪编号；无目标或多人识别模式时为空
+ */
+ private void updateRecognitionTarget(@Nullable Integer trackId) {
+ Integer previousTrackId = currentRecognitionTargetTrackId;
+ if (Objects.equals(previousTrackId, trackId)) {
+ return;
+ }
+ currentRecognitionTargetTrackId = trackId;
+ if (recognizeConfiguration.isKeepMaxFace() && previousTrackId != null) {
+ RecognizeInfo previousInfo = recognizeInfoMap.get(previousTrackId);
+ if (previousInfo != null) {
+ previousInfo.setRecognizeStatus(RequestFeatureStatus.TO_RETRY);
+ previousInfo.setLiveness(LivenessInfo.UNKNOWN);
+ synchronized (previousInfo.getWaitLock()) {
+ previousInfo.getWaitLock().notifyAll();
+ }
+ }
+ }
+ }
+
+ /**
+ * 判断异步任务是否仍属于当前会话且仍是允许识别的目标脸。
+ *
+ * @param trackId 异步任务对应的人脸跟踪编号
+ * @param generation 创建异步任务时的业务会话代次
+ * @return 任务结果仍可进入识别回调时返回 true
+ */
+ private boolean isCurrentRecognitionTarget(@Nullable Integer trackId, long generation) {
+ return generation == sessionGeneration
+ && (!recognizeConfiguration.isKeepMaxFace()
+ || Objects.equals(currentRecognitionTargetTrackId, trackId));
+ }
+
@Override
public void onFail(Exception e) {
Log.e(TAG, "onFail:" + e.getMessage());
@@ -492,6 +603,9 @@ public class FaceHelper implements FaceListener {
@Override
public void onFaceFeatureInfoGet(@Nullable FaceFeature faceFeature, Integer trackId, Integer errorCode) {
+ if (!isCurrentRecognitionTarget(trackId, sessionGeneration)) {
+ return;
+ }
//FR成功
RecognizeInfo recognizeInfo = getRecognizeInfo(recognizeInfoMap, trackId);
if (faceFeature != null) {
@@ -610,6 +724,9 @@ public class FaceHelper implements FaceListener {
@Override
public void onFaceLivenessInfoGet(@Nullable LivenessInfo livenessInfo, Integer trackId, Integer errorCode) {
+ if (!isCurrentRecognitionTarget(trackId, sessionGeneration)) {
+ return;
+ }
if (livenessInfo != null) {
int liveness = livenessInfo.getLiveness();
Log.i(TAG, "onFaceLivenessInfoGet liveness:" + liveness);
@@ -649,14 +766,20 @@ public class FaceHelper implements FaceListener {
}
private void searchFace(final FaceFeature faceFeature, final Integer trackId) {
+ if (!isCurrentRecognitionTarget(trackId, sessionGeneration)) {
+ return;
+ }
CompareResult compareResult = FaceServer.getInstance().searchFaceFeature(faceFeature);
if (compareResult == null || compareResult.getFaceEntity() == null) {
retryRecognizeDelayed(trackId);
return;
}
compareResult.setTrackId(trackId);
+ // 相似度属于当前跟踪人脸，先保存再判断阈值，预览框才能展示真实的最近一次比对结果。
+ setSimilarity(trackId, compareResult.getSimilar());
boolean pass = compareResult.getSimilar() > recognizeConfiguration.getSimilarThreshold();
- recognizeCallback.onRecognized(compareResult, getRecognizeInfo(recognizeInfoMap, trackId).getLiveness(), pass);
+ recognizeCallback.onRecognized(compareResult, getRecognizeInfo(recognizeInfoMap, trackId).getLiveness(), pass,
+ recognitionFrameMap.get(trackId));
if (pass) {
String msg = "识别通过";
Log.i(TAG, "用户名字:" + compareResult.getFaceEntity().getUserName() + ";人脸id:" + compareResult.getFaceEntity().getFaceId() + ";");
@@ -688,6 +811,7 @@ public class FaceHelper implements FaceListener {
private Integer trackId;
private byte[] nv21Data;
private int isMask;
+ private final long generation;
/**
* 异步特征提取任务的构造函数
@@ -699,20 +823,26 @@ public class FaceHelper implements FaceListener {
* @param format 图像格式
*/
private FaceRecognizeRunnable(byte[] nv21Data, FacePreviewInfo facePreviewInfo, int width, int height, int format) {
+ this.generation = sessionGeneration;
if (nv21Data == null) {
return;
}
- this.nv21Data = nv21Data;
+ // Camera1 使用回调缓冲区复用帧内存，异步特征提取必须持有自己的快照，
+ // 否则下一帧会覆盖当前顾客数据，连续识别时可能出现错人或提取失败。
+ this.nv21Data = Arrays.copyOf(nv21Data, nv21Data.length);
this.faceInfo = new FaceInfo(facePreviewInfo.getFaceInfoRgb());
this.width = width;
this.height = height;
this.format = format;
this.trackId = facePreviewInfo.getTrackId();
this.isMask = facePreviewInfo.getMask();
+ recognitionFrameMap.put(this.trackId, new RecognitionFrameSnapshot(this.nv21Data, this.faceInfo,
+ this.width, this.height, System.currentTimeMillis()));
}
@Override
public void run() {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
if (nv21Data != null) {
if (frEngine != null) {
if (recognizeConfiguration.isEnableImageQuality()) {
@@ -763,14 +893,20 @@ public class FaceHelper implements FaceListener {
}
Log.i(TAG, "frTime:" + (System.currentTimeMillis() - irStartTime) + "ms");
if (frCode == ErrorInfo.MOK) {
- onFaceFeatureInfoGet(faceFeature, trackId, frCode);
+ synchronized (FaceHelper.this) {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
+ onFaceFeatureInfoGet(faceFeature, trackId, frCode);
+ }
} else {
onFaceFail(frCode, "fr failed errorCode is " + frCode);
}
}
private void onFaceFail(int code, String errorMsg) {
- onFaceFeatureInfoGet(null, trackId, code);
+ synchronized (FaceHelper.this) {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
+ onFaceFeatureInfoGet(null, trackId, code);
+ }
onFail(new Exception(errorMsg));
}
}
@@ -788,10 +924,13 @@ public class FaceHelper implements FaceListener {
private LivenessType livenessType;
private Object waitLock;
+ /** 创建活体任务时的会话代次，用于丢弃上一位顾客或上一目标脸的迟到结果。 */
+ private final long generation;
+
/**
* 异步活体任务的构造函数
*
- * @param nv21Data 可见光或红外图像数据
+ * @param nv21Data 可见光或红外图像数据；构造时复制，避免 Camera 复用缓冲区覆盖异步任务
* @param faceInfo 可见光人脸检测得到的人脸信息
* @param width 图像宽度
* @param height 图像高度
@@ -800,10 +939,11 @@ public class FaceHelper implements FaceListener {
* @param waitLock 活体检测通过后，调用该对象的notifyAll函数，通知识别线程活体已通过
*/
private FaceLivenessDetectRunnable(byte[] nv21Data, FacePreviewInfo faceInfo, int width, int height, int format, LivenessType livenessType, Object waitLock) {
+ this.generation = sessionGeneration;
if (nv21Data == null) {
return;
}
- this.nv21Data = nv21Data;
+ this.nv21Data = Arrays.copyOf(nv21Data, nv21Data.length);
this.faceInfo = new FaceInfo(faceInfo.getFaceInfoRgb());
this.width = width;
this.height = height;
@@ -815,6 +955,7 @@ public class FaceHelper implements FaceListener {
@Override
public void run() {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
if (nv21Data != null) {
if (flEngine != null) {
processLiveness();
@@ -864,6 +1005,7 @@ public class FaceHelper implements FaceListener {
}
if (flCode == ErrorInfo.MOK && !livenessInfoList.isEmpty()) {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
onFaceLivenessInfoGet(livenessInfoList.get(0), trackId, flCode);
if (livenessInfoList.get(0).getLiveness() == LivenessInfo.ALIVE) {
synchronized (waitLock) {
@@ -876,6 +1018,7 @@ public class FaceHelper implements FaceListener {
}
private void onProcessFail(int code, String msg) {
+ if (!isCurrentRecognitionTarget(trackId, generation)) return;
onFaceLivenessInfoGet(null, trackId, code);
onFail(new Exception(msg));
}
@@ -1003,6 +1146,15 @@ public class FaceHelper implements FaceListener {
return recognizeInfo == null ? null : recognizeInfo.getName();
}
+ public void setSimilarity(int trackId, float similarity) {
+ getRecognizeInfo(recognizeInfoMap, trackId).setSimilarity(similarity);
+ }
+
+ public Float getSimilarity(int trackId) {
+ RecognizeInfo recognizeInfo = recognizeInfoMap.get(trackId);
+ return recognizeInfo == null ? null : recognizeInfo.getSimilarity();
+ }
+
/**
* 设置可识别区域（相对于View）
@@ -1080,7 +1232,7 @@ public class FaceHelper implements FaceListener {
}
/**
- * 保留ftFaceList中最大的人脸
+ * 保留 ftFaceList 中面积最大的人脸。
*
* @param ftFaceList 人脸追踪时，一帧数据的人脸信息
*/
@@ -1090,7 +1242,7 @@ public class FaceHelper implements FaceListener {
}
FaceInfo maxFaceInfo = ftFaceList.get(0);
for (FaceInfo faceInfo : ftFaceList) {
- if (faceInfo.getRect().width() > maxFaceInfo.getRect().width()) {
+ if (faceArea(faceInfo.getRect()) > faceArea(maxFaceInfo.getRect())) {
maxFaceInfo = faceInfo;
}
}
@@ -1098,6 +1250,19 @@ public class FaceHelper implements FaceListener {
ftFaceList.add(maxFaceInfo);
}
+ /**
+ * 计算原始摄像头坐标中的有效矩形面积，异常或反向矩形按 0 处理。
+ *
+ * @param rect 虹软返回的人脸矩形
+ * @return 人脸矩形面积，单位为预览像素平方
+ */
+ private static long faceArea(@Nullable Rect rect) {
+ if (rect == null) {
+ return 0L;
+ }
+ return (long) Math.max(0, rect.width()) * Math.max(0, rect.height());
+ }
+
public static final class Builder {
private FaceEngine ftEngine;
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/help/callback/RecognizeCallback.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/help/callback/RecognizeCallback.java
index ebda709..3560be1 100644
--- a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/help/callback/RecognizeCallback.java
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/help/callback/RecognizeCallback.java
@@ -2,6 +2,7 @@ package io.flutter.plugins.facediscern.tool.face.help.callback;
import io.flutter.plugins.facediscern.tool.face.model.CompareResult;
+import io.flutter.plugins.facediscern.tool.face.model.RecognitionFrameSnapshot;
public interface RecognizeCallback {
/**
@@ -10,8 +11,10 @@ public interface RecognizeCallback {
* @param compareResult 比对结果
* @param liveness 活体值
* @param similarPass 是否通过（依据设置的阈值）
+ * @param frameSnapshot 实际提取特征的 NV21 和目标人脸框；旧 Activity 链路允许为空
*/
- void onRecognized(CompareResult compareResult, Integer liveness, boolean similarPass);
+ void onRecognized(CompareResult compareResult, Integer liveness, boolean similarPass,
+ RecognitionFrameSnapshot frameSnapshot);
/**
* 提示文字变更的回调
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognitionFrameSnapshot.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognitionFrameSnapshot.java
new file mode 100644
index 0000000..d83d4f1
--- /dev/null
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognitionFrameSnapshot.java
@@ -0,0 +1,62 @@
+package io.flutter.plugins.facediscern.tool.face.model;
+
+import com.arcsoft.face.FaceInfo;
+
+import java.util.Arrays;
+
+/**
+ * 人脸特征提取使用的可见光帧快照。
+ *
+ * Camera1 会复用回调缓冲区，因此这里必须复制 NV21 和 FaceInfo，保证异步比对成功后
+ * 仍然能裁剪出同一张实际命中目标的人脸图片。
+ */
+public final class RecognitionFrameSnapshot {
+ /** 原始 NV21 帧的独立副本。 */
+ private final byte[] nv21;
+
+ /** 该帧中实际参与特征提取的人脸框。 */
+ private final FaceInfo faceInfo;
+
+ /** NV21 原始宽度，单位为像素。 */
+ private final int width;
+
+ /** NV21 原始高度，单位为像素。 */
+ private final int height;
+
+ /** 相机回调采集时间，单位为 Unix 毫秒。 */
+ private final long capturedAt;
+
+ /** 创建一份不可变的人脸成功帧快照。 */
+ public RecognitionFrameSnapshot(byte[] nv21, FaceInfo faceInfo, int width, int height, long capturedAt) {
+ this.nv21 = nv21 == null ? null : Arrays.copyOf(nv21, nv21.length);
+ this.faceInfo = faceInfo == null ? null : new FaceInfo(faceInfo);
+ this.width = width;
+ this.height = height;
+ this.capturedAt = capturedAt;
+ }
+
+ /** 返回 NV21 快照副本，避免调用方修改共享内容。 */
+ public byte[] getNv21() {
+ return nv21 == null ? null : Arrays.copyOf(nv21, nv21.length);
+ }
+
+ /** 返回实际命中人脸框的独立副本。 */
+ public FaceInfo getFaceInfo() {
+ return faceInfo == null ? null : new FaceInfo(faceInfo);
+ }
+
+ /** 返回 NV21 原始宽度。 */
+ public int getWidth() {
+ return width;
+ }
+
+ /** 返回 NV21 原始高度。 */
+ public int getHeight() {
+ return height;
+ }
+
+ /** 返回相机帧采集时间。 */
+ public long getCapturedAt() {
+ return capturedAt;
+ }
+}
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfiguration.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfiguration.java
index e67f62e..96e41a4 100644
--- a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfiguration.java
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfiguration.java
@@ -6,6 +6,21 @@ import com.arcsoft.face.LivenessParam;
* 识别相关的配置项
*/
public class RecognizeConfiguration {
+ public static final int DEFAULT_EXTRACT_RETRY_COUNT = 3;
+ public static final int DEFAULT_LIVENESS_RETRY_COUNT = 3;
+ public static final int DEFAULT_MAX_DETECT_FACES = 1;
+ public static final int DEFAULT_RECOGNIZE_FAILED_RETRY_INTERVAL = 0;
+ public static final int DEFAULT_LIVENESS_FAILED_RETRY_INTERVAL = 0;
+ public static final float DEFAULT_SIMILAR_THRESHOLD = 0.8F;
+ public static final float DEFAULT_IMAGE_QUALITY_NO_MASK_THRESHOLD = 0.49F;
+ public static final float DEFAULT_IMAGE_QUALITY_MASK_THRESHOLD = 0.29F;
+ /** 在库照片质量诊断默认阈值，只用于终端运维分类。 */
+ public static final float DEFAULT_LIBRARY_FACE_QUALITY_THRESHOLD = 0.60F;
+ public static final float DEFAULT_RGB_LIVENESS_THRESHOLD = 0.5F;
+ public static final boolean DEFAULT_ENABLE_LIVENESS = false;
+ public static final boolean DEFAULT_ENABLE_IMAGE_QUALITY = true;
+ public static final boolean DEFAULT_KEEP_MAX_FACE = true;
+
/**
* 产生特征提取失败示语的特征提取次数（小于该值不提示）
*/
@@ -30,6 +45,10 @@ public class RecognizeConfiguration {
* 图像质量检测阈值：适用于戴口罩且人脸识别场景
*/
private float imageQualityMaskRecognizeThreshold;
+ /**
+ * 在库照片质量诊断阈值，不参与实时识别和特征注册。
+ */
+ private float libraryFaceQualityThreshold;
/**
* 识别失败重试间隔
*/
@@ -86,6 +105,7 @@ public class RecognizeConfiguration {
this.similarThreshold = builder.similarThreshold;
this.imageQualityNoMaskRecognizeThreshold = builder.imageQualityNoMaskRecognizeThreshold;
this.imageQualityMaskRecognizeThreshold = builder.imageQualityMaskRecognizeThreshold;
+ this.libraryFaceQualityThreshold = builder.libraryFaceQualityThreshold;
this.enableLiveness = builder.enableLiveness;
this.enableImageQuality = builder.enableImageQuality;
this.enableFaceAreaLimit = builder.enableFaceAreaLimit;
@@ -100,23 +120,25 @@ public class RecognizeConfiguration {
//TODO： demo不实现所有配置，若以下项也需要进行自定义配置，可参考其他配置项实现
public static class Builder {
- private int extractRetryCount = 3;
- private int livenessRetryCount = 3;
- private int maxDetectFaces = 3;
- private int recognizeFailedRetryInterval = 0;
- private int livenessFailedRetryInterval = 0;
- private float similarThreshold = 0.8f;
- private float imageQualityNoMaskRecognizeThreshold = 0.49f;
- private float imageQualityMaskRecognizeThreshold = 0.29f;
- private boolean enableLiveness = false;
+ private int extractRetryCount = DEFAULT_EXTRACT_RETRY_COUNT;
+ private int livenessRetryCount = DEFAULT_LIVENESS_RETRY_COUNT;
+ private int maxDetectFaces = DEFAULT_MAX_DETECT_FACES;
+ private int recognizeFailedRetryInterval = DEFAULT_RECOGNIZE_FAILED_RETRY_INTERVAL;
+ private int livenessFailedRetryInterval = DEFAULT_LIVENESS_FAILED_RETRY_INTERVAL;
+ private float similarThreshold = DEFAULT_SIMILAR_THRESHOLD;
+ private float imageQualityNoMaskRecognizeThreshold = DEFAULT_IMAGE_QUALITY_NO_MASK_THRESHOLD;
+ private float imageQualityMaskRecognizeThreshold = DEFAULT_IMAGE_QUALITY_MASK_THRESHOLD;
+ /** 在库照片质量诊断阈值，允许范围为0到1。 */
+ private float libraryFaceQualityThreshold = DEFAULT_LIBRARY_FACE_QUALITY_THRESHOLD;
+ private boolean enableLiveness = DEFAULT_ENABLE_LIVENESS;
private boolean enableFaceAreaLimit = false;
- private boolean enableImageQuality = false;
+ private boolean enableImageQuality = DEFAULT_ENABLE_IMAGE_QUALITY;
private boolean enableFaceSizeLimit = false;
private boolean enableFaceMoveLimit = false;
private int faceSizeLimit = 0;
private int faceMoveLimit = 0;
- private boolean keepMaxFace = false;
- private LivenessParam livenessParam;
+ private boolean keepMaxFace = DEFAULT_KEEP_MAX_FACE;
+ private LivenessParam livenessParam = new LivenessParam(DEFAULT_RGB_LIVENESS_THRESHOLD, DEFAULT_RGB_LIVENESS_THRESHOLD);
public Builder recognizeFailedRetryInterval(int val) {
this.recognizeFailedRetryInterval = val;
@@ -158,6 +180,17 @@ public class RecognizeConfiguration {
return this;
}
+ /**
+ * 设置在库照片质量诊断阈值。
+ *
+ * @param val 0到1之间的质量分界值
+ * @return 当前构建器
+ */
+ public Builder libraryFaceQualityThreshold(float val) {
+ this.libraryFaceQualityThreshold = val;
+ return this;
+ }
+
public Builder enableLiveness(boolean val) {
this.enableLiveness = val;
return this;
@@ -217,10 +250,51 @@ public class RecognizeConfiguration {
return imageQualityMaskRecognizeThreshold;
}
+ /**
+ * 读取在库照片质量诊断阈值。
+ *
+ * @return 0到1之间的质量分界值
+ */
+ public float getLibraryFaceQualityThreshold() {
+ return libraryFaceQualityThreshold;
+ }
+
public boolean isEnableImageQuality() {
return enableImageQuality;
}
+ /**
+ * 创建仅切换实时图像质量能力的运行时配置，其他现场参数保持不变。
+ *
+ * 该副本不会写回 SharedPreferences，专供虹软质量增值模块初始化失败时
+ * 降级本次识别会话，避免授权差异阻断原有特征提取和比对。
+ *
+ * @param enabled 本次识别会话是否执行实时图像质量检测
+ * @return 保留其余识别参数的新配置
+ */
+ public RecognizeConfiguration withImageQualityEnabled(boolean enabled) {
+ return new Builder()
+ .extractRetryCount(extractRetryCount)
+ .livenessRetryCount(livenessRetryCount)
+ .maxDetectFaces(maxDetectFaces)
+ .recognizeFailedRetryInterval(recognizeFailedRetryInterval)
+ .livenessFailedRetryInterval(livenessFailedRetryInterval)
+ .similarThreshold(similarThreshold)
+ .imageQualityNoMaskRecognizeThreshold(imageQualityNoMaskRecognizeThreshold)
+ .imageQualityMaskRecognizeThreshold(imageQualityMaskRecognizeThreshold)
+ .libraryFaceQualityThreshold(libraryFaceQualityThreshold)
+ .enableLiveness(enableLiveness)
+ .enableImageQuality(enabled)
+ .enableFaceAreaLimit(enableFaceAreaLimit)
+ .keepMaxFace(keepMaxFace)
+ .livenessParam(livenessParam)
+ .enableFaceSizeLimit(enableFaceSizeLimit)
+ .enableFaceMoveLimit(enableFaceMoveLimit)
+ .faceSizeLimit(faceSizeLimit)
+ .faceMoveLimit(faceMoveLimit)
+ .build();
+ }
+
public boolean isEnableFaceAreaLimit() {
return enableFaceAreaLimit;
}
@@ -291,6 +365,7 @@ public class RecognizeConfiguration {
"enableImageQuality: " + enableImageQuality + "\r\n" +
"imageQualityNoMaskRecognizeThreshold: " + imageQualityNoMaskRecognizeThreshold + "\r\n" +
"imageQualityMaskRecognizeThreshold: " + imageQualityMaskRecognizeThreshold + "\r\n" +
+ "libraryFaceQualityThreshold: " + libraryFaceQualityThreshold + "\r\n" +
"enableLiveness: " + enableLiveness + "\r\n" +
"livenessRetryCount: " + livenessRetryCount + "\r\n" +
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfigurationStore.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfigurationStore.java
new file mode 100644
index 0000000..685cd93
--- /dev/null
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeConfigurationStore.java
@@ -0,0 +1,142 @@
+package io.flutter.plugins.facediscern.tool.face.model;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import com.arcsoft.face.LivenessParam;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 保存终端本机的人脸识别策略，不写入业务数据库，避免配置升级影响 Floor 与人脸共享库。
+ */
+public final class RecognizeConfigurationStore {
+ private static final String PREFERENCES_NAME = "face_recognize_configuration";
+
+ private RecognizeConfigurationStore() {
+ }
+
+ public static RecognizeConfiguration load(Context context) {
+ SharedPreferences preferences = preferences(context);
+ return new RecognizeConfiguration.Builder()
+ .enableLiveness(preferences.getBoolean("enableLiveness", RecognizeConfiguration.DEFAULT_ENABLE_LIVENESS))
+ .similarThreshold(preferences.getFloat("similarThreshold", RecognizeConfiguration.DEFAULT_SIMILAR_THRESHOLD))
+ .livenessParam(new LivenessParam(
+ preferences.getFloat("rgbLivenessThreshold", RecognizeConfiguration.DEFAULT_RGB_LIVENESS_THRESHOLD),
+ RecognizeConfiguration.DEFAULT_RGB_LIVENESS_THRESHOLD))
+ .enableImageQuality(preferences.getBoolean("enableImageQuality", RecognizeConfiguration.DEFAULT_ENABLE_IMAGE_QUALITY))
+ .imageQualityNoMaskRecognizeThreshold(preferences.getFloat("imageQualityNoMaskRecognizeThreshold", RecognizeConfiguration.DEFAULT_IMAGE_QUALITY_NO_MASK_THRESHOLD))
+ .imageQualityMaskRecognizeThreshold(preferences.getFloat("imageQualityMaskRecognizeThreshold", RecognizeConfiguration.DEFAULT_IMAGE_QUALITY_MASK_THRESHOLD))
+ .libraryFaceQualityThreshold(preferences.getFloat("libraryFaceQualityThreshold", RecognizeConfiguration.DEFAULT_LIBRARY_FACE_QUALITY_THRESHOLD))
+ .keepMaxFace(preferences.getBoolean("keepMaxFace", RecognizeConfiguration.DEFAULT_KEEP_MAX_FACE))
+ .maxDetectFaces(preferences.getInt("maxDetectFaces", RecognizeConfiguration.DEFAULT_MAX_DETECT_FACES))
+ .extractRetryCount(preferences.getInt("extractRetryCount", RecognizeConfiguration.DEFAULT_EXTRACT_RETRY_COUNT))
+ .livenessRetryCount(preferences.getInt("livenessRetryCount", RecognizeConfiguration.DEFAULT_LIVENESS_RETRY_COUNT))
+ .recognizeFailedRetryInterval(preferences.getInt("recognizeFailedRetryInterval", RecognizeConfiguration.DEFAULT_RECOGNIZE_FAILED_RETRY_INTERVAL))
+ .livenessFailedRetryInterval(preferences.getInt("livenessFailedRetryInterval", RecognizeConfiguration.DEFAULT_LIVENESS_FAILED_RETRY_INTERVAL))
+ .build();
+ }
+
+ /**
+ * Flutter 只传允许现场调整的白名单字段，原生再次校验范围，防止异常参数拖垮识别线程。
+ */
+ public static RecognizeConfiguration save(Context context, Map values) {
+ RecognizeConfiguration current = load(context);
+ boolean enableLiveness = booleanValue(values, "enableLiveness", current.isEnableLiveness());
+ float similarThreshold = floatValue(values, "similarThreshold", current.getSimilarThreshold(), 0.5F, 0.99F);
+ float rgbLivenessThreshold = floatValue(values, "rgbLivenessThreshold", rgbLivenessThreshold(current), 0.3F, 0.9F);
+ boolean enableImageQuality = booleanValue(values, "enableImageQuality", current.isEnableImageQuality());
+ float noMaskThreshold = floatValue(values, "imageQualityNoMaskRecognizeThreshold", current.getImageQualityNoMaskRecognizeThreshold(), 0F, 1F);
+ float maskThreshold = floatValue(values, "imageQualityMaskRecognizeThreshold", current.getImageQualityMaskRecognizeThreshold(), 0F, 1F);
+ float libraryFaceQualityThreshold = floatValue(values, "libraryFaceQualityThreshold", current.getLibraryFaceQualityThreshold(), 0F, 1F);
+ boolean keepMaxFace = booleanValue(values, "keepMaxFace", current.isKeepMaxFace());
+ int maxDetectFaces = intValue(values, "maxDetectFaces", current.getMaxDetectFaces(), 1, 3);
+ int extractRetryCount = intValue(values, "extractRetryCount", current.getExtractRetryCount(), 0, 10);
+ int livenessRetryCount = intValue(values, "livenessRetryCount", current.getLivenessRetryCount(), 0, 10);
+ int recognizeRetryInterval = intValue(values, "recognizeFailedRetryInterval", current.getRecognizeFailedRetryInterval(), 0, 5000);
+ int livenessRetryInterval = intValue(values, "livenessFailedRetryInterval", current.getLivenessFailedRetryInterval(), 0, 5000);
+
+ boolean saved = preferences(context).edit()
+ .putBoolean("enableLiveness", enableLiveness)
+ .putFloat("similarThreshold", similarThreshold)
+ .putFloat("rgbLivenessThreshold", rgbLivenessThreshold)
+ .putBoolean("enableImageQuality", enableImageQuality)
+ .putFloat("imageQualityNoMaskRecognizeThreshold", noMaskThreshold)
+ .putFloat("imageQualityMaskRecognizeThreshold", maskThreshold)
+ .putFloat("libraryFaceQualityThreshold", libraryFaceQualityThreshold)
+ .putBoolean("keepMaxFace", keepMaxFace)
+ .putInt("maxDetectFaces", maxDetectFaces)
+ .putInt("extractRetryCount", extractRetryCount)
+ .putInt("livenessRetryCount", livenessRetryCount)
+ .putInt("recognizeFailedRetryInterval", recognizeRetryInterval)
+ .putInt("livenessFailedRetryInterval", livenessRetryInterval)
+ .commit();
+ if (!saved) throw new IllegalStateException("人脸识别配置保存失败");
+ return load(context);
+ }
+
+ public static RecognizeConfiguration reset(Context context) {
+ if (!preferences(context).edit().clear().commit()) {
+ throw new IllegalStateException("人脸识别配置恢复失败");
+ }
+ return load(context);
+ }
+
+ public static Map toMap(RecognizeConfiguration configuration) {
+ Map result = new HashMap<>();
+ result.put("enableLiveness", configuration.isEnableLiveness());
+ result.put("similarThreshold", configuration.getSimilarThreshold());
+ result.put("rgbLivenessThreshold", rgbLivenessThreshold(configuration));
+ result.put("enableImageQuality", configuration.isEnableImageQuality());
+ result.put("imageQualityNoMaskRecognizeThreshold", configuration.getImageQualityNoMaskRecognizeThreshold());
+ result.put("imageQualityMaskRecognizeThreshold", configuration.getImageQualityMaskRecognizeThreshold());
+ result.put("libraryFaceQualityThreshold", configuration.getLibraryFaceQualityThreshold());
+ result.put("keepMaxFace", configuration.isKeepMaxFace());
+ result.put("maxDetectFaces", configuration.getMaxDetectFaces());
+ result.put("extractRetryCount", configuration.getExtractRetryCount());
+ result.put("livenessRetryCount", configuration.getLivenessRetryCount());
+ result.put("recognizeFailedRetryInterval", configuration.getRecognizeFailedRetryInterval());
+ result.put("livenessFailedRetryInterval", configuration.getLivenessFailedRetryInterval());
+ result.put("livenessType", "RGB");
+ return result;
+ }
+
+ private static SharedPreferences preferences(Context context) {
+ return context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE);
+ }
+
+ private static float rgbLivenessThreshold(RecognizeConfiguration configuration) {
+ LivenessParam param = configuration.getLivenessParam();
+ return param == null ? RecognizeConfiguration.DEFAULT_RGB_LIVENESS_THRESHOLD : param.getRgbThreshold();
+ }
+
+ private static boolean booleanValue(Map values, String key, boolean fallback) {
+ Object value = values == null ? null : values.get(key);
+ if (value == null) return fallback;
+ if (!(value instanceof Boolean)) throw new IllegalArgumentException(key + " 必须为布尔值");
+ return (Boolean) value;
+ }
+
+ private static float floatValue(Map values, String key, float fallback, float min, float max) {
+ Object value = values == null ? null : values.get(key);
+ if (value == null) return fallback;
+ if (!(value instanceof Number)) throw new IllegalArgumentException(key + " 必须为数字");
+ float result = ((Number) value).floatValue();
+ if (Float.isNaN(result) || Float.isInfinite(result) || result < min || result > max) {
+ throw new IllegalArgumentException(key + " 必须在 " + min + " 到 " + max + " 之间");
+ }
+ return result;
+ }
+
+ private static int intValue(Map values, String key, int fallback, int min, int max) {
+ Object value = values == null ? null : values.get(key);
+ if (value == null) return fallback;
+ if (!(value instanceof Number)) throw new IllegalArgumentException(key + " 必须为整数");
+ int result = ((Number) value).intValue();
+ if (result < min || result > max) {
+ throw new IllegalArgumentException(key + " 必须在 " + min + " 到 " + max + " 之间");
+ }
+ return result;
+ }
+}
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeInfo.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeInfo.java
index 9350b37..bba4d54 100644
--- a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeInfo.java
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/model/RecognizeInfo.java
@@ -19,6 +19,8 @@ public class RecognizeInfo {
* 用于存储活体值
*/
private int liveness = LivenessInfo.UNKNOWN;
+ /** 最近一次人脸库比对相似度；尚未完成比对时为空。 */
+ private volatile Float similarity;
/**
* 用于存储活体检测出错重试次数
*/
@@ -52,6 +54,14 @@ public class RecognizeInfo {
return liveness;
}
+ public Float getSimilarity() {
+ return similarity;
+ }
+
+ public void setSimilarity(Float similarity) {
+ this.similarity = similarity;
+ }
+
public int increaseAndGetLivenessErrorRetryCount() {
return ++livenessErrorRetryCount;
}
@@ -83,4 +93,4 @@ public class RecognizeInfo {
public int getLivenessErrorRetryCount() {
return livenessErrorRetryCount;
}
-}
\ No newline at end of file
+}
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/servcie/FaceServer.java b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/servcie/FaceServer.java
index 04b092d..12f6dd9 100644
--- a/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/servcie/FaceServer.java
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/tool/face/servcie/FaceServer.java
@@ -11,6 +11,7 @@ import com.arcsoft.face.FaceEngine;
import com.arcsoft.face.FaceFeature;
import com.arcsoft.face.FaceFeatureInfo;
import com.arcsoft.face.FaceInfo;
+import com.arcsoft.face.ImageQualitySimilar;
import com.arcsoft.face.MaskInfo;
import com.arcsoft.face.SearchResult;
import com.arcsoft.face.enums.DetectFaceOrientPriority;
@@ -25,8 +26,13 @@ import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
+import java.util.Set;
+import java.util.HashSet;
import io.flutter.plugins.facediscern.tool.face.model.CompareResult;
import io.flutter.plugins.facediscern.tool.face.model.FaceEntity;
@@ -38,7 +44,10 @@ public class FaceServer {
private static final String TAG = "FaceServer";
private static FaceEngine faceEngine = null;
private static volatile FaceServer faceServer = null;
- private List faceRegisterInfoList = new ArrayList<>();
+ private final Map faceRegisterInfoMap = new HashMap<>();
+ private int engineInitCode = -99;
+ private int imageQualityInitCode = -99;
+ private boolean imageQualityReady;
private String imageRootPath;
/**
* 最大注册人脸数
@@ -48,19 +57,57 @@ public class FaceServer {
public synchronized void init(Context context) {
if (faceEngine == null && context != null) {
faceEngine = new FaceEngine();
- int engineCode = faceEngine.init(
+ int requestedCode = faceEngine.init(
context,
DetectMode.ASF_DETECT_MODE_IMAGE,
DetectFaceOrientPriority.ASF_OP_ALL_OUT,
1,
- FaceEngine.ASF_FACE_RECOGNITION | FaceEngine.ASF_FACE_DETECT | FaceEngine.ASF_MASK_DETECT
+ FaceEngine.ASF_FACE_RECOGNITION | FaceEngine.ASF_FACE_DETECT | FaceEngine.ASF_MASK_DETECT | FaceEngine.ASF_IMAGEQUALITY
);
- if (engineCode != ErrorInfo.MOK) {
- Log.e(TAG, "人脸引擎初始化失败code" + engineCode);
+ imageQualityInitCode = requestedCode;
+ if (requestedCode == ErrorInfo.MOK) {
+ engineInitCode = requestedCode;
+ imageQualityReady = true;
+ } else {
+ Log.w(TAG, "图像质量模块不可用，回退基础人脸引擎code" + requestedCode);
+ faceEngine.unInit();
+ faceEngine = null;
+ faceEngine = new FaceEngine();
+ engineInitCode = faceEngine.init(
+ context,
+ DetectMode.ASF_DETECT_MODE_IMAGE,
+ DetectFaceOrientPriority.ASF_OP_ALL_OUT,
+ 1,
+ FaceEngine.ASF_FACE_RECOGNITION | FaceEngine.ASF_FACE_DETECT | FaceEngine.ASF_MASK_DETECT
+ );
+ imageQualityReady = false;
+ if (engineInitCode != ErrorInfo.MOK) {
+ Log.e(TAG, "人脸引擎初始化失败code" + engineInitCode);
+ faceEngine.unInit();
+ faceEngine = null;
+ }
}
}
}
+ public synchronized int getEngineInitCode() {
+ return engineInitCode;
+ }
+
+ public synchronized boolean isEngineReady() {
+ return faceEngine != null && engineInitCode == ErrorInfo.MOK;
+ }
+
+ /** 返回当前授权是否包含虹软图像质量模块。 */
+ public synchronized boolean isImageQualityReady() {
+ return imageQualityReady;
+ }
+
+ /** 返回图像质量模块初始化返回码，用于终端诊断授权状态。 */
+ public synchronized int getImageQualityInitCode() {
+ return imageQualityInitCode;
+ }
+
public static FaceServer getInstance() {
if (faceServer == null) {
synchronized (FaceServer.class) {
@@ -76,58 +123,142 @@ public class FaceServer {
* 销毁
*/
public synchronized void release() {
- if (faceRegisterInfoList != null) {
- faceRegisterInfoList.clear();
- faceRegisterInfoList = null;
- }
+ faceRegisterInfoMap.clear();
if (faceEngine != null) {
synchronized (faceEngine) {
faceEngine.unInit();
}
faceEngine = null;
}
+ engineInitCode = -99;
+ imageQualityInitCode = -99;
+ imageQualityReady = false;
faceServer = null;
}
- public int registerFaceFeatureInfoListFromDb(List faceEntityList) {
+ /**
+ * 全量重建使用：先清空旧内存库，再按调用方传入的数据重新装载。
+ */
+ public synchronized int registerFaceFeatureInfoListFromDb(List faceEntityList) {
if (faceEngine == null) return -99;
+ faceEngine.removeFaceFeature(-1);
+ faceRegisterInfoMap.clear();
+ return registerFaceFeatureInfoBatchFromDb(faceEntityList);
+ }
+
+ /**
+ * 只追加当前批次，不清空其他人脸；用于分批全量装载和单用户增量替换。
+ */
+ public synchronized int registerFaceFeatureInfoBatchFromDb(List faceEntityList) {
+ if (faceEngine == null || faceEntityList == null || faceEntityList.isEmpty()) return -99;
List faceFeatureInfoList = new ArrayList<>();
for (FaceEntity faceEntity : faceEntityList) {
FaceFeatureInfo faceFeatureInfo = new FaceFeatureInfo((int) faceEntity.getFaceId(), faceEntity.getFaceModel());
faceFeatureInfoList.add(faceFeatureInfo);
}
- //首先清除FaceEngine中所有人脸数据，再添加新的人脸数据
- faceEngine.removeFaceFeature(-1);
int code = faceEngine.registerFaceFeature(faceFeatureInfoList);
if (code == ErrorInfo.MOK) {
- faceRegisterInfoList.addAll(faceEntityList);
+ for (FaceEntity faceEntity : faceEntityList) {
+ faceRegisterInfoMap.put(faceEntity.getFaceId(), faceEntity);
+ }
}
return code;
}
- // 注册单个人脸数据
- public int registerFaceFeatureInfoFromDb(FaceEntity faceEntity) {
- if (faceEntity != null && faceEngine != null) {
- FaceFeatureInfo faceFeatureInfo = new FaceFeatureInfo(faceEntity.getFaceId(), faceEntity.getFaceModel());
- int code = faceEngine.registerFaceFeature(faceFeatureInfo);
- if (code == ErrorInfo.MOK) {
- faceEntity.setFaceModel(faceFeatureInfo.getFeatureData());
- // 查询一下确保入库成功
- FaceFeatureInfo afterDetail = getFaceFeature(faceEntity.getFaceId());
- if (Objects.nonNull(afterDetail)) {
- long count = faceRegisterInfoList.stream().filter(v -> Objects.equals(v.getFaceId(), faceEntity.getFaceId())).count();
- if (count == 0) {
- faceRegisterInfoList.add(faceEntity);
- }
- return code;
- }
- }
+ /**
+ * 在同一虹软引擎互斥边界内原子替换单个搜索标识的人脸特征。
+ *
+ * 替换前复制旧特征和业务元数据；新特征注册失败或 SDK 抛异常时恢复旧特征，
+ * 避免坏图导致原本可识别的人脸永久丢失。
+ *
+ * @param faceEntity 包含搜索标识、用户元数据和新特征的目标人脸
+ * @return 虹软返回码，插件异常返回内部错误码 {@code -99}
+ */
+ public synchronized int replaceFaceFeature(FaceEntity faceEntity) {
+ if (faceEntity == null || faceEngine == null || faceEntity.getFaceId() == null || faceEntity.getFaceModel() == null) {
+ return -99;
}
- return -99;
+ int searchId = faceEntity.getFaceId();
+ FaceEntity oldEntity = copyFaceEntity(faceRegisterInfoMap.get(searchId));
+ try {
+ FaceFeatureInfo oldFeature = getFaceFeature(searchId);
+ if (oldEntity == null && oldFeature != null) {
+ oldEntity = new FaceEntity(searchId, oldFeature.getFeatureData());
+ }
+ faceEngine.removeFaceFeature(searchId);
+ faceRegisterInfoMap.remove(searchId);
+ FaceFeatureInfo newFeature = new FaceFeatureInfo(searchId, faceEntity.getFaceModel());
+ int code = faceEngine.registerFaceFeature(Collections.singletonList(newFeature));
+ if (code == ErrorInfo.MOK && getFaceFeature(searchId) != null) {
+ faceRegisterInfoMap.put(searchId, faceEntity);
+ return code;
+ }
+ restoreFaceFeature(searchId, oldEntity);
+ return code == ErrorInfo.MOK ? -99 : code;
+ } catch (Exception exception) {
+ Log.e(TAG, "替换人脸特征异常searchId:" + searchId + ";error:" + exception.getMessage(), exception);
+ restoreFaceFeature(searchId, oldEntity);
+ return -99;
+ }
+ }
+
+ /**
+ * 返回当前虹软内存库已登记的搜索标识快照，用于集合一致性判断。
+ *
+ * @return 与内部映射解耦的搜索标识集合
+ */
+ public synchronized Set getRegisteredFaceIds() {
+ return new HashSet<>(faceRegisterInfoMap.keySet());
+ }
+
+ /**
+ * 恢复单样本替换前的人脸特征；没有旧特征时保持目标搜索标识为空。
+ *
+ * @param searchId 需要恢复的虹软搜索标识
+ * @param oldEntity 替换前的特征和元数据，新增场景为空
+ */
+ private void restoreFaceFeature(int searchId, FaceEntity oldEntity) {
+ try {
+ faceEngine.removeFaceFeature(searchId);
+ faceRegisterInfoMap.remove(searchId);
+ if (oldEntity == null || oldEntity.getFaceModel() == null) return;
+ FaceFeatureInfo oldFeature = new FaceFeatureInfo(searchId, oldEntity.getFaceModel());
+ if (faceEngine.registerFaceFeature(Collections.singletonList(oldFeature)) == ErrorInfo.MOK) {
+ faceRegisterInfoMap.put(searchId, oldEntity);
+ } else {
+ Log.e(TAG, "恢复旧人脸特征失败searchId:" + searchId);
+ }
+ } catch (Exception exception) {
+ Log.e(TAG, "恢复旧人脸特征异常searchId:" + searchId + ";error:" + exception.getMessage(), exception);
+ }
+ }
+
+ /**
+ * 深拷贝内存库中的人脸业务元数据和特征，避免回滚快照被后续修改。
+ *
+ * @param source 待复制的人脸记录
+ * @return 独立副本，源记录为空时返回空
+ */
+ private FaceEntity copyFaceEntity(FaceEntity source) {
+ if (source == null) return null;
+ FaceEntity copy = new FaceEntity();
+ copy.setFaceId(source.getFaceId());
+ copy.setSampleId(source.getSampleId());
+ copy.setUserId(source.getUserId());
+ copy.setUserName(source.getUserName());
+ copy.setFaceFilePath(source.getFaceFilePath());
+ copy.setFaceModel(source.getFaceModel() == null ? null : source.getFaceModel().clone());
+ return copy;
+ }
+
+ // 注册单个人脸数据
+ public synchronized int registerFaceFeatureInfoFromDb(FaceEntity faceEntity) {
+ // 历史单条入口也复用带旧特征回滚的替换逻辑，避免 SDK 异常后丢失原可用样本。
+ return replaceFaceFeature(faceEntity);
}
// 从人脸数据库中搜索人脸
- public FaceFeatureInfo getFaceFeature(int searchId) {
+ public synchronized FaceFeatureInfo getFaceFeature(int searchId) {
FaceFeatureInfo faceFeatureInfo = null;
try {
faceFeatureInfo = faceEngine.getFaceFeature(searchId);
@@ -138,19 +269,49 @@ public class FaceServer {
}
// 获取人脸数量
- public int getTotalFaceCount() {
+ public synchronized int getTotalFaceCount() {
if (faceEngine == null) return -99;
return faceEngine.getFaceCount();
}
// 删除人脸-1删除全部
- public int removeFace(int searchId) {
+ public synchronized int removeFace(int searchId) {
if (faceEngine == null) return -99;
- return faceEngine.removeFaceFeature(searchId);
+ // MQ 和每日快照都可能重复删除同一样本；内存库已不存在时直接按幂等成功处理。
+ if (searchId != -1 && getFaceFeature(searchId) == null) {
+ faceRegisterInfoMap.remove(searchId);
+ return ErrorInfo.MOK;
+ }
+ int code = faceEngine.removeFaceFeature(searchId);
+ if (code == ErrorInfo.MOK) {
+ if (searchId == -1) {
+ faceRegisterInfoMap.clear();
+ } else {
+ faceRegisterInfoMap.remove(searchId);
+ }
+ }
+ return code;
+ }
+
+ /**
+ * 增量更新时仅移除该用户已注册的样本，避免同步单人后覆盖整个内存库。
+ */
+ public synchronized void removeFacesByUserId(String userId) {
+ if (faceEngine == null || userId == null) return;
+ List faceIds = new ArrayList<>();
+ for (Map.Entry entry : faceRegisterInfoMap.entrySet()) {
+ if (Objects.equals(userId, entry.getValue().getUserId())) {
+ faceIds.add(entry.getKey());
+ }
+ }
+ for (Integer faceId : faceIds) {
+ faceEngine.removeFaceFeature(faceId);
+ faceRegisterInfoMap.remove(faceId);
+ }
}
// 在特征库中搜索
- public CompareResult searchFaceFeature(FaceFeature faceFeature) {
+ public synchronized CompareResult searchFaceFeature(FaceFeature faceFeature) {
if (faceFeature == null) return null;
if (faceEngine == null) return null;
SearchResult searchResult = null;
@@ -160,8 +321,8 @@ public class FaceServer {
long searchCost = System.currentTimeMillis() - searchStart;
if (searchResult != null) {
FaceFeatureInfo faceFeatureInfo = searchResult.getFaceFeatureInfo();
- FaceEntity entity = faceRegisterInfoList.stream().filter(v -> Objects.equals(v.getFaceId(), faceFeatureInfo.getSearchId())).findFirst().get();
- if (Objects.isNull(entity)) {
+ FaceEntity entity = faceRegisterInfoMap.get(faceFeatureInfo.getSearchId());
+ if (entity == null) {
entity = new FaceEntity(faceFeatureInfo.getSearchId(), faceFeatureInfo.getFeatureData());
}
Log.i(TAG, "查询人脸总耗时:" + (System.currentTimeMillis() - searchStart) + "ms;username:" + entity.getUserName() + ";faceId:" + entity.getFaceId() + ";");
@@ -174,10 +335,23 @@ public class FaceServer {
}
- public byte[] registerBgr24(Context context, byte[] bgr24, int width, int height, String name) {
+ /** 保持旧调用方返回特征字节的兼容入口。 */
+ public synchronized byte[] registerBgr24(Context context, byte[] bgr24, int width, int height, String name) {
+ return registerBgr24WithQuality(context, bgr24, width, height, name).featureData;
+ }
+
+ /**
+ * 在统一解码结果上同时执行图像质量检测和虹软特征提取。
+ *
+ * 质量模块不可用或检测失败时仅记录failed状态，仍继续原有特征提取，兼容免费版授权。
+ */
+ public synchronized QualityFeatureResult registerBgr24WithQuality(Context context, byte[] bgr24, int width, int height, String name) {
+ QualityFeatureResult qualityResult = new QualityFeatureResult();
if (faceEngine == null || context == null || bgr24 == null || width % 4 != 0 || bgr24.length != width * height * 3) {
Log.e(TAG, "registerBgr24: invalid params");
- return null;
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = ErrorInfo.MERR_INVALID_PARAM;
+ return qualityResult;
}
//人脸检测
List faceInfoList = new ArrayList<>();
@@ -186,6 +360,25 @@ public class FaceServer {
code = faceEngine.detectFaces(bgr24, width, height, FaceEngine.CP_PAF_BGR24, faceInfoList);
}
if (code == ErrorInfo.MOK && !faceInfoList.isEmpty()) {
+ if (imageQualityReady) {
+ ImageQualitySimilar qualitySimilar = new ImageQualitySimilar();
+ int qualityCode;
+ synchronized (faceEngine) {
+ qualityCode = faceEngine.imageQualityDetect(
+ bgr24, width, height, FaceEngine.CP_PAF_BGR24,
+ faceInfoList.get(0), MaskInfo.NOT_WORN, qualitySimilar);
+ }
+ if (qualityCode == ErrorInfo.MOK) {
+ qualityResult.qualityStatus = "detected";
+ qualityResult.qualityScore = (double) qualitySimilar.getScore();
+ } else {
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = qualityCode;
+ }
+ } else {
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = imageQualityInitCode;
+ }
code = faceEngine.process(bgr24, width, height, FaceEngine.CP_PAF_BGR24, faceInfoList,
FaceEngine.ASF_MASK_DETECT);
if (code == ErrorInfo.MOK) {
@@ -198,16 +391,18 @@ public class FaceServer {
* 注册照要求不戴口罩
*/
Log.e(TAG, "registerBgr24: maskInfo is worn");
- return null;
+ return qualityResult;
}
if (isMask == MaskInfo.UNKNOWN) {
Log.e(TAG, "registerBgr24: maskInfo is unknown");
- return null;
+ return qualityResult;
}
}
} else {
Log.e(TAG, "registerBgr24 mask process fail res=" + code);
- return null;
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = code;
+ return qualityResult;
}
FaceFeature faceFeature = new FaceFeature();
/*
@@ -224,7 +419,9 @@ public class FaceServer {
Rect cropRect = getBestRect(width, height, faceInfoList.get(0).getRect());
if (cropRect == null) {
Log.e(TAG, "registerBgr24: cropRect is null");
- return null;
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = ErrorInfo.MERR_INVALID_PARAM;
+ return qualityResult;
}
cropRect.left &= ~3;
cropRect.top &= ~3;
@@ -233,25 +430,83 @@ public class FaceServer {
String imgPath = getImagePath(userName, context);
// 创建一个头像的Bitmap，存放旋转结果图
Bitmap headBmp = getHeadImage(bgr24, width, height, faceInfoList.get(0).getOrient(), cropRect, ArcSoftImageFormat.BGR24);
- try {
- FileOutputStream fos = new FileOutputStream(imgPath);
+ try (FileOutputStream fos = new FileOutputStream(imgPath)) {
headBmp.compress(Bitmap.CompressFormat.JPEG, 100, fos);
- fos.close();
} catch (IOException e) {
- e.printStackTrace();
- return null;
+ Log.e(TAG, "registerBgr24: save head image failed", e);
+ return qualityResult;
+ } finally {
+ if (!headBmp.isRecycled()) headBmp.recycle();
}
- return faceFeature.getFeatureData();
+ qualityResult.featureData = faceFeature.getFeatureData();
+ return qualityResult;
} else {
Log.e(TAG, "registerBgr24: extract face feature failed, code is " + code);
- return null;
+ return qualityResult;
}
} else {
Log.e(TAG, "registerBgr24: no face detected, code is " + code);
- return null;
+ qualityResult.qualityStatus = "failed";
+ qualityResult.qualityErrorCode = code == ErrorInfo.MOK
+ ? ErrorInfo.MERR_FSDK_FACEFEATURE_NO_FACE
+ : code;
+ return qualityResult;
}
}
+ /**
+ * 仅检测BGR24在库照片的质量，不提取或写入人脸特征。
+ *
+ * @param bgr24 BGR24图片数据
+ * @param width 图片宽度
+ * @param height 图片高度
+ * @return detected或failed质量结果
+ */
+ public synchronized QualityFeatureResult detectBgr24Quality(byte[] bgr24, int width, int height) {
+ QualityFeatureResult result = new QualityFeatureResult();
+ if (faceEngine == null || bgr24 == null || width % 4 != 0 || bgr24.length != width * height * 3) {
+ result.qualityStatus = "failed";
+ result.qualityErrorCode = ErrorInfo.MERR_INVALID_PARAM;
+ return result;
+ }
+ List faceInfoList = new ArrayList<>();
+ int detectCode = faceEngine.detectFaces(bgr24, width, height, FaceEngine.CP_PAF_BGR24, faceInfoList);
+ if (detectCode != ErrorInfo.MOK || faceInfoList.isEmpty()) {
+ result.qualityStatus = "failed";
+ result.qualityErrorCode = detectCode == ErrorInfo.MOK ? ErrorInfo.MERR_FSDK_FACEFEATURE_NO_FACE : detectCode;
+ return result;
+ }
+ if (!imageQualityReady) {
+ result.qualityStatus = "failed";
+ result.qualityErrorCode = imageQualityInitCode;
+ return result;
+ }
+ ImageQualitySimilar qualitySimilar = new ImageQualitySimilar();
+ int qualityCode = faceEngine.imageQualityDetect(
+ bgr24, width, height, FaceEngine.CP_PAF_BGR24,
+ faceInfoList.get(0), MaskInfo.NOT_WORN, qualitySimilar);
+ if (qualityCode == ErrorInfo.MOK) {
+ result.qualityStatus = "detected";
+ result.qualityScore = (double) qualitySimilar.getScore();
+ } else {
+ result.qualityStatus = "failed";
+ result.qualityErrorCode = qualityCode;
+ }
+ return result;
+ }
+
+ /** 原生图片特征与质量诊断的组合结果。 */
+ public static class QualityFeatureResult {
+ /** 注册特征字节，提取失败时为空。 */
+ public byte[] featureData;
+ /** 质量状态，稳定值为detected或failed。 */
+ public String qualityStatus = "pending";
+ /** 检测成功时的质量分。 */
+ public Double qualityScore;
+ /** 检测失败时的错误码。 */
+ public Integer qualityErrorCode;
+ }
+
private String getImagePath(String name, Context context) {
if (imageRootPath == null) {
imageRootPath = getImageDir(context);
diff --git a/android/app/src/main/java/io/flutter/plugins/facediscern/ui/viewmodel/FaceDiscernViewModel.java b/android/app/src/main/java/io/flutter/plugins/facediscern/ui/viewmodel/FaceDiscernViewModel.java
index 879bcdc..6817f69 100644
--- a/android/app/src/main/java/io/flutter/plugins/facediscern/ui/viewmodel/FaceDiscernViewModel.java
+++ b/android/app/src/main/java/io/flutter/plugins/facediscern/ui/viewmodel/FaceDiscernViewModel.java
@@ -18,6 +18,7 @@ import com.arcsoft.face.FaceInfo;
import com.arcsoft.face.GenderInfo;
import com.arcsoft.face.LivenessInfo;
import com.arcsoft.face.LivenessParam;
+import com.arcsoft.face.ErrorInfo;
import com.arcsoft.face.enums.DetectFaceOrientPriority;
import com.arcsoft.face.enums.DetectMode;
import com.google.gson.Gson;
@@ -35,6 +36,8 @@ import io.flutter.plugins.facediscern.tool.face.model.CompareResult;
import io.flutter.plugins.facediscern.tool.face.model.FaceEntity;
import io.flutter.plugins.facediscern.tool.face.model.FacePreviewInfo;
import io.flutter.plugins.facediscern.tool.face.model.RecognizeConfiguration;
+import io.flutter.plugins.facediscern.tool.face.model.RecognizeConfigurationStore;
+import io.flutter.plugins.facediscern.tool.face.model.RecognitionFrameSnapshot;
import io.flutter.plugins.facediscern.tool.face.widget.FaceRectView;
import io.flutter.plugins.facediscern.ui.FaceDiscern;
@@ -47,6 +50,12 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
private final String TAG = "FaceDiscernViewModel";
+ /**
+ * 仅识别最大脸时的预览检测上限。
+ * 原生配置允许的上限为 3，足以让收银员看清排队场景中的目标选择，同时只让一张脸进入识别线程。
+ */
+ private static final int KEEP_MAX_FACE_PREVIEW_LIMIT = 3;
+
// 相机预览的分辨率
private Camera.Size previewSize;
@@ -60,10 +69,12 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
private FaceEngine maskEngine;
// IMAGE模式活体检测引擎，用于预览帧人脸活体检测
private FaceEngine flEngine;
- // 各个引擎初始化的错误码
- private MutableLiveData ftInitCode = new MutableLiveData<>();
- private MutableLiveData frInitCode = new MutableLiveData<>();
- private MutableLiveData flInitCode = new MutableLiveData<>();
+ // 各个引擎初始化的错误码。虹软 init 是同步调用，不能通过 LiveData.postValue
+ // 异步保存后立刻读取，否则主线程消息尚未分发时会把成功初始化误判为失败。
+ private int ftInitCode = Integer.MIN_VALUE;
+ private int maskInitCode = Integer.MIN_VALUE;
+ private int frInitCode = Integer.MIN_VALUE;
+ private int flInitCode = Integer.MIN_VALUE;
/// ****************** end 引擎 end ******************
@@ -101,8 +112,31 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
private HashMap faceDiscern = null;
+ private RecognitionListener recognitionListener;
+
+ private RecognizeCallback faceHelperCallback = this;
+
private MutableLiveData recognizeConfiguration = new MutableLiveData<>();
+ /**
+ * 新的共享会话不再依赖 Activity 广播，由进程级 Manager 直接接收识别结果。
+ * 旧 Activity 不设置该监听时仍保持原有广播行为，避免破坏历史入口。
+ */
+ public interface RecognitionListener {
+ /**
+ * 返回当前会话唯一识别结果及实际成功帧，Manager 会在代次校验后生成现场证据。
+ *
+ * @param result 不含原始帧的识别用户与相似度结果
+ * @param generation 识别会话代次，旧 Activity 兼容链路使用 0
+ * @param frameSnapshot 实际参与成功比对的帧；旧 Activity 兼容链路允许为空
+ */
+ void onRecognized(HashMap result, long generation, RecognitionFrameSnapshot frameSnapshot);
+ }
+
+ public void setRecognitionListener(RecognitionListener recognitionListener) {
+ this.recognitionListener = recognitionListener;
+ }
+
public void setRgbFaceRectTransformer(FaceRectTransformer rgbFaceRectTransformer) {
faceHelper.setRgbFaceRectTransformer(rgbFaceRectTransformer);
}
@@ -119,46 +153,133 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
registerStatus = status;
}
- // 初始化引擎
+ /**
+ * 读取本机识别配置并初始化虹软检测、口罩、特征和可选活体引擎。
+ * 仅识别最大脸时扩大检测上限只服务预览标框，不会扩大实际参与比对的人脸数量。
+ *
+ * @param context 应用上下文，用于初始化虹软引擎和读取本机 SharedPreferences 配置
+ */
public void init(Context context) {
setContext(context);
+ ftInitCode = Integer.MIN_VALUE;
+ maskInitCode = Integer.MIN_VALUE;
+ frInitCode = Integer.MIN_VALUE;
+ flInitCode = Integer.MIN_VALUE;
boolean switchCamera = false;
previewConfig = new PreviewConfig(switchCamera ? Camera.CameraInfo.CAMERA_FACING_FRONT : Camera.CameraInfo.CAMERA_FACING_BACK, switchCamera ? Camera.CameraInfo.CAMERA_FACING_BACK : Camera.CameraInfo.CAMERA_FACING_FRONT, 0, 0);
- // 填入在设置界面设置好的配置信息
- boolean enableLive = false;
- boolean enableFaceQualityDetect = true;
- boolean enableFaceMoveLimit = false;
- boolean enableFaceSizeLimit = false;
- int faceSizeLimit = 160;
- int faceMoveLimit = 20;
- int maxDetectFaces = 1;
- boolean keepMaxFace = true;
- float similarThreshold = 0.8F;
- float imageQualityNoMaskRecognizeThreshold = 0.49F;
- float imageQualityMaskRecognizeThreshold = 0.29F;
- RecognizeConfiguration configuration = new RecognizeConfiguration.Builder().enableFaceMoveLimit(enableFaceMoveLimit).enableFaceSizeLimit(enableFaceSizeLimit).faceSizeLimit(faceSizeLimit).faceMoveLimit(faceMoveLimit).enableLiveness(enableLive).enableImageQuality(enableFaceQualityDetect).maxDetectFaces(maxDetectFaces).keepMaxFace(keepMaxFace).similarThreshold(similarThreshold).imageQualityNoMaskRecognizeThreshold(imageQualityNoMaskRecognizeThreshold).imageQualityMaskRecognizeThreshold(imageQualityMaskRecognizeThreshold).livenessParam(new LivenessParam(0.5F, 0.5F)).build();
+ // 单摄像头终端仅支持 RGB 活体，配置由设置页持久化并在每次冷启动识别引擎时读取。
+ livenessType = LivenessType.RGB;
+ RecognizeConfiguration configuration = RecognizeConfigurationStore.load(context);
+ boolean enableLive = configuration.isEnableLiveness();
+ boolean enableFaceQualityDetect = configuration.isEnableImageQuality();
+ int maxDetectFaces = effectiveMaxDetectFaces(configuration);
ftEngine = new FaceEngine();
- ftInitCode.postValue(ftEngine.init(context, DetectMode.ASF_DETECT_MODE_VIDEO, DetectFaceOrientPriority.ASF_OP_ALL_OUT, 1, FaceEngine.ASF_FACE_DETECT));
+ ftInitCode = ftEngine.init(context, DetectMode.ASF_DETECT_MODE_VIDEO, DetectFaceOrientPriority.ASF_OP_ALL_OUT, maxDetectFaces, FaceEngine.ASF_FACE_DETECT);
maskEngine = new FaceEngine();
- ftInitCode.postValue(maskEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_ALL_OUT, 1, FaceEngine.ASF_MASK_DETECT));
+ maskInitCode = maskEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_ALL_OUT, maxDetectFaces, FaceEngine.ASF_MASK_DETECT);
frEngine = new FaceEngine();
int frEngineMask = FaceEngine.ASF_FACE_RECOGNITION;
if (enableFaceQualityDetect) {
frEngineMask |= FaceEngine.ASF_IMAGEQUALITY;
}
- frInitCode.postValue(frEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_0_ONLY, 10, frEngineMask));
+ frInitCode = frEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_0_ONLY, maxDetectFaces, frEngineMask);
+ if (enableFaceQualityDetect && frInitCode != ErrorInfo.MOK) {
+ int qualityInitCode = frInitCode;
+ Log.w(TAG, "实时图像质量模块不可用，回退基础识别引擎code=" + qualityInitCode);
+ frEngine.unInit();
+ frEngine = new FaceEngine();
+ frInitCode = frEngine.init(
+ context,
+ DetectMode.ASF_DETECT_MODE_IMAGE,
+ DetectFaceOrientPriority.ASF_OP_0_ONLY,
+ maxDetectFaces,
+ FaceEngine.ASF_FACE_RECOGNITION);
+ if (frInitCode == ErrorInfo.MOK) {
+ // 只关闭本次会话的质量判断，保留管理员配置，授权恢复后下次会重新尝试。
+ configuration = configuration.withImageQualityEnabled(false);
+ }
+ }
//启用活体检测时，才初始化活体引擎
if (enableLive) {
flEngine = new FaceEngine();
int flEngineMask = (livenessType == LivenessType.RGB ? FaceEngine.ASF_LIVENESS : (FaceEngine.ASF_IR_LIVENESS | FaceEngine.ASF_FACE_DETECT));
- flInitCode.postValue(flEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_ALL_OUT, 10, flEngineMask));
- LivenessParam livenessParam = new LivenessParam(0.5F, 0.5F);
+ flInitCode = flEngine.init(context, DetectMode.ASF_DETECT_MODE_IMAGE, DetectFaceOrientPriority.ASF_OP_ALL_OUT, maxDetectFaces, flEngineMask);
+ LivenessParam livenessParam = configuration.getLivenessParam();
flEngine.setLivenessParam(livenessParam);
}
recognizeConfiguration.setValue(configuration);
flutterFaceCallbackIntent = new Intent(FaceBrodConstant.FACE_GLOBAL_INTENT);
+ Log.i(TAG, "虹软引擎初始化结果 " + getEngineInitSummary());
+ }
+
+ public boolean isEngineReady() {
+ RecognizeConfiguration configuration = recognizeConfiguration.getValue();
+ return ftInitCode == ErrorInfo.MOK
+ && maskInitCode == ErrorInfo.MOK
+ && frInitCode == ErrorInfo.MOK
+ && (configuration == null || !configuration.isEnableLiveness()
+ || flInitCode == ErrorInfo.MOK);
+ }
+
+ public String getEngineInitSummary() {
+ RecognizeConfiguration configuration = recognizeConfiguration.getValue();
+ boolean livenessEnabled = configuration != null && configuration.isEnableLiveness();
+ return "ft=" + ftInitCode
+ + ";mask=" + maskInitCode
+ + ";fr=" + frInitCode
+ + ";fl=" + (livenessEnabled ? flInitCode : "disabled")
+ + ";maxFaces=" + (configuration == null ? "unknown" : effectiveMaxDetectFaces(configuration))
+ + ";imageQuality=" + (configuration == null ? "unknown" : configuration.isEnableImageQuality());
+ }
+
+ public boolean isLivenessEnabled() {
+ RecognizeConfiguration configuration = recognizeConfiguration.getValue();
+ return configuration != null && configuration.isEnableLiveness();
+ }
+
+ public float getSimilarityThreshold() {
+ RecognizeConfiguration configuration = recognizeConfiguration.getValue();
+ return configuration == null ? RecognizeConfiguration.DEFAULT_SIMILAR_THRESHOLD : configuration.getSimilarThreshold();
+ }
+
+ /**
+ * 返回当前引擎是否启用“仅识别最大人脸”，供 Flutter 会话事件保持与原生识别策略一致。
+ *
+ * @return 当前配置开启时返回 true；引擎尚未完成配置加载时返回默认值
+ */
+ public boolean isKeepMaxFaceEnabled() {
+ RecognizeConfiguration configuration = recognizeConfiguration.getValue();
+ return configuration == null
+ ? RecognizeConfiguration.DEFAULT_KEEP_MAX_FACE
+ : configuration.isKeepMaxFace();
+ }
+
+ /**
+ * 解析虹软检测引擎的人脸上限。
+ * 开启最大脸模式时必须先检测到多张脸才能比较面积，因此固定提升至配置允许的三张上限。
+ *
+ * @param configuration 当前本机识别配置
+ * @return 传给虹软各引擎的单帧最大检测数量
+ */
+ private int effectiveMaxDetectFaces(RecognizeConfiguration configuration) {
+ if (configuration.isKeepMaxFace()) {
+ return Math.max(configuration.getMaxDetectFaces(), KEEP_MAX_FACE_PREVIEW_LIMIT);
+ }
+ return configuration.getMaxDetectFaces();
+ }
+
+ public Float getFaceSimilarity(int trackId) {
+ return faceHelper == null ? null : faceHelper.getSimilarity(trackId);
+ }
+
+ public Integer getFaceLiveness(int trackId) {
+ return faceHelper == null ? null : faceHelper.getLiveness(trackId);
+ }
+
+ public Integer getFaceRecognizeStatus(int trackId) {
+ return faceHelper == null ? null : faceHelper.getRecognizeStatus(trackId);
}
private void initFaceHelper(Camera.Size lastPreviewSize) {
@@ -171,8 +292,8 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
}
int horizontalOffset = 0;
int verticalOffset = 0;
- int maxDetectFaceNum = 1;
- faceHelper = new FaceHelper.Builder().ftEngine(ftEngine).maskEngine(maskEngine).frEngine(frEngine).flEngine(flEngine).frQueueSize(maxDetectFaceNum).flQueueSize(maxDetectFaceNum).previewSize(previewSize).recognizeCallback(this).recognizeConfiguration(recognizeConfiguration.getValue()).trackedFaceCount(trackedFaceCount == null ? 0 : trackedFaceCount).dualCameraFaceInfoTransformer(faceInfo -> {
+ int maxDetectFaceNum = recognizeConfiguration.getValue().getMaxDetectFaces();
+ faceHelper = new FaceHelper.Builder().ftEngine(ftEngine).maskEngine(maskEngine).frEngine(frEngine).flEngine(flEngine).frQueueSize(maxDetectFaceNum).flQueueSize(maxDetectFaceNum).previewSize(previewSize).recognizeCallback(faceHelperCallback).recognizeConfiguration(recognizeConfiguration.getValue()).trackedFaceCount(trackedFaceCount == null ? 0 : trackedFaceCount).dualCameraFaceInfoTransformer(faceInfo -> {
FaceInfo irFaceInfo = new FaceInfo(faceInfo);
irFaceInfo.getRect().offset(horizontalOffset, verticalOffset);
return irFaceInfo;
@@ -189,6 +310,17 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
initFaceHelper(lastPreviewSize);
}
+ /**
+ * 每个业务会话复用 FaceHelper 与 ArcSoft FaceEngine，只重置跟踪状态并切换代次回调。
+ * 这样连续排队无需重建线程池，上一位顾客的异步提取晚到时也不会串入下一笔订单。
+ */
+ public void beginSession(long generation) {
+ faceDiscern = null;
+ if (faceHelper == null) throw new IllegalStateException("人脸处理器尚未初始化");
+ faceHelperCallback = new SessionRecognizeCallback(generation);
+ faceHelper.beginSession(generation, faceHelperCallback);
+ }
+
public Point loadPreviewSize() {
String[] size = new String[]{"1280", "720"};
return new Point(Integer.parseInt(size[0]), Integer.parseInt(size[1]));
@@ -251,8 +383,36 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
public void destroy() {
if (faceHelper != null) {
faceHelper.release();
+ faceHelper = null;
}
- // FaceServer.getInstance().release();
+ if (ftEngine != null) {
+ synchronized (ftEngine) {
+ ftEngine.unInit();
+ }
+ ftEngine = null;
+ }
+ if (maskEngine != null) {
+ synchronized (maskEngine) {
+ maskEngine.unInit();
+ }
+ maskEngine = null;
+ }
+ if (frEngine != null) {
+ synchronized (frEngine) {
+ frEngine.unInit();
+ }
+ frEngine = null;
+ }
+ if (flEngine != null) {
+ synchronized (flEngine) {
+ flEngine.unInit();
+ }
+ flEngine = null;
+ }
+ faceDiscern = null;
+ recognitionListener = null;
+ faceHelperCallback = this;
+ // FaceServer 是跨会话的内存特征库，热会话关闭时不能释放，否则下一位顾客会重新装载全库。
}
public void stop() {
@@ -263,7 +423,8 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
// 识别结果回调
@Override
- public void onRecognized(CompareResult compareResult, Integer liveness, boolean similarPass) {
+ public void onRecognized(CompareResult compareResult, Integer liveness, boolean similarPass,
+ RecognitionFrameSnapshot frameSnapshot) {
try {
if (!similarPass) return;
HashMap json = new HashMap<>();
@@ -292,6 +453,12 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
flutterFaceCallbackIntent = new Intent(FaceBrodConstant.FACE_GLOBAL_INTENT);
}
Log.i(TAG, "人脸识别成功json:" + new Gson().toJson(faceDiscern));
+ if (recognitionListener != null) {
+ HashMap result = new HashMap<>(faceDiscern);
+ faceDiscern = null;
+ recognitionListener.onRecognized(result, 0L, null);
+ return;
+ }
flutterFaceCallbackIntent.putExtra("json", new Gson().toJson(faceDiscern));
context.sendBroadcast(flutterFaceCallbackIntent);
faceDiscern = null;
@@ -307,4 +474,52 @@ public class FaceDiscernViewModel extends ViewModel implements RecognizeCallback
Log.e(TAG, "提示文字变更的回调,错误error:" + e.getMessage(), e);
}
}
+
+ private HashMap buildRecognitionResult(CompareResult compareResult) {
+ HashMap json = new HashMap<>();
+ json.put("similar", compareResult.getSimilar());
+ json.put("cost", compareResult.getCost());
+ if (Objects.nonNull(compareResult.getFaceEntity())) {
+ FaceEntity face = compareResult.getFaceEntity();
+ json.put("faceId", face.getFaceId());
+ json.put("sampleId", face.getSampleId());
+ json.put("userId", face.getUserId());
+ json.put("userName", face.getUserName());
+ }
+ return json;
+ }
+
+ /** 会话专用回调只保存本代识别结果，避免共享字段被旧异步任务覆盖。 */
+ private final class SessionRecognizeCallback implements RecognizeCallback {
+ /** 创建该回调时绑定的会话代次，旧代异步结果不得进入新会话。 */
+ private final long generation;
+
+ /** 当前代已经通过阈值的人脸用户和相似度结果，通知成功后立即清空。 */
+ private HashMap result;
+
+ /** 创建只服务指定会话代次的回调。 */
+ private SessionRecognizeCallback(long generation) {
+ this.generation = generation;
+ }
+
+ @Override
+ public void onRecognized(CompareResult compareResult, Integer liveness, boolean similarPass,
+ RecognitionFrameSnapshot frameSnapshot) {
+ if (!similarPass) return;
+ result = buildRecognitionResult(compareResult);
+ pendingFrameSnapshot = frameSnapshot;
+ }
+
+ @Override
+ public void onNoticeChanged(String notice) {
+ if (!Objects.equals(notice, "") || result == null || recognitionListener == null) return;
+ HashMap current = new HashMap<>(result);
+ result = null;
+ recognitionListener.onRecognized(current, generation, pendingFrameSnapshot);
+ pendingFrameSnapshot = null;
+ }
+
+ /** 与 result 同一次特征提取对应的成功帧，转交 Manager 后立即释放引用。 */
+ private RecognitionFrameSnapshot pendingFrameSnapshot;
+ }
}
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/ApkUpdateManager.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/ApkUpdateManager.kt
new file mode 100644
index 0000000..ea69e3e
--- /dev/null
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/ApkUpdateManager.kt
@@ -0,0 +1,194 @@
+package com.example.pj_supermarket_cloud
+
+import android.content.Context
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.os.Build
+import java.io.File
+import java.security.MessageDigest
+
+/**
+ * 校验并通过 Root 静默覆盖安装当前应用 APK。
+ *
+ * 安装前强制校验包名、签名和版本码，Root 仅用于执行 `pm install -r`，不会卸载重装、
+ * 绕过签名或清理应用数据，从而保留本地数据库与 Device Owner 状态。
+ */
+object ApkUpdateManager {
+ /** 待更新状态使用的原生偏好文件，应用替换后仍随数据目录保留。 */
+ private const val PREFERENCES_NAME = "apk_update_runtime"
+
+ /** 是否存在等待新版本启动确认的更新。 */
+ private const val PENDING_KEY = "pending"
+
+ /** 后台目标版本码。 */
+ private const val EXPECTED_VERSION_CODE_KEY = "expected_version_code"
+
+ /** 下载到应用私有目录的 APK 绝对路径。 */
+ private const val APK_PATH_KEY = "apk_path"
+
+ /** 安装命令最长允许 3 分钟，超时后按失败处理。 */
+ private const val INSTALL_TIMEOUT_MILLIS = 180_000L
+
+ /**
+ * 校验 APK 是否可安全覆盖当前应用。
+ *
+ * @param context 当前应用上下文
+ * @param apkPath 应用私有目录中的 APK 绝对路径
+ * @param expectedVersionCode 服务端声明的目标版本码
+ * @return MethodChannel 可直接返回的结构化校验结果
+ */
+ fun validate(context: Context, apkPath: String, expectedVersionCode: Long): Map {
+ val file = File(apkPath)
+ if (!file.isFile || file.length() <= 0L) {
+ return failure("APK_NOT_FOUND", "安装包不存在或为空")
+ }
+ val archive = packageArchiveInfo(context, apkPath)
+ ?: return failure("APK_INVALID", "无法解析安装包，请重新下载")
+ val current = currentPackageInfo(context)
+ val archiveVersionCode = versionCode(archive)
+ val currentVersionCode = versionCode(current)
+ if (archive.packageName != context.packageName) {
+ return failure("PACKAGE_MISMATCH", "安装包包名与当前应用不一致")
+ }
+ if (archiveVersionCode != expectedVersionCode) {
+ return failure("VERSION_MISMATCH", "安装包版本码与后台目标版本不一致")
+ }
+ if (archiveVersionCode <= currentVersionCode) {
+ return failure("VERSION_NOT_HIGHER", "目标版本不高于当前版本，已拒绝重复或降级安装")
+ }
+ if (signerDigests(archive).intersect(signerDigests(current)).isEmpty()) {
+ return failure("SIGNATURE_MISMATCH", "安装包签名与当前应用不一致")
+ }
+ return mapOf(
+ "valid" to true,
+ "code" to "OK",
+ "message" to "安装包校验通过",
+ "packageName" to archive.packageName,
+ "versionCode" to archiveVersionCode,
+ "versionName" to archive.versionName
+ )
+ }
+
+ /**
+ * 重新校验 Root 与 APK 后执行覆盖安装；待更新状态先于命令写入，保证进程被替换时可恢复。
+ */
+ fun install(context: Context, apkPath: String, expectedVersionCode: Long): Map {
+ val validation = validate(context, apkPath, expectedVersionCode)
+ if (validation["valid"] != true) return validation
+ val root = RootCommandRunner.checkRoot()
+ if (root["available"] != true) {
+ return failure("ROOT_UNAVAILABLE", root["message"]?.toString() ?: "Root 不可用")
+ }
+
+ preferences(context).edit()
+ .putBoolean(PENDING_KEY, true)
+ .putLong(EXPECTED_VERSION_CODE_KEY, expectedVersionCode)
+ .putString(APK_PATH_KEY, apkPath)
+ .commit()
+ val command = RootCommandRunner.execute(
+ "pm install -r ${RootCommandRunner.quoteShell(apkPath)}",
+ INSTALL_TIMEOUT_MILLIS
+ )
+ val success = command.exitCode == 0 && command.output.contains("Success", ignoreCase = true)
+ if (!success) {
+ clearPending(context, deleteApk = true)
+ val message = when {
+ command.timedOut -> "APK 安装超时，请检查系统安装服务"
+ command.output.isNotBlank() -> command.output
+ else -> "pm install -r 执行失败（退出码 ${command.exitCode ?: -1}）"
+ }
+ return failure("INSTALL_FAILED", message)
+ }
+ return mapOf(
+ "valid" to true,
+ "code" to "INSTALL_STARTED",
+ "message" to "安装命令已成功执行，等待新版本启动确认",
+ "versionCode" to expectedVersionCode
+ )
+ }
+
+ /**
+ * 应用启动时确认待更新版本并清理私有 APK；版本未提升时保留明确失败结果并终止恢复。
+ */
+ fun consumePending(context: Context): Map {
+ val prefs = preferences(context)
+ if (!prefs.getBoolean(PENDING_KEY, false)) {
+ return mapOf("pending" to false, "success" to false)
+ }
+ val expected = prefs.getLong(EXPECTED_VERSION_CODE_KEY, -1L)
+ val current = versionCode(currentPackageInfo(context))
+ val success = expected > 0L && current >= expected
+ val message = if (success) {
+ "自动更新完成，当前 Build $current"
+ } else {
+ "自动更新未完成，当前 Build $current，目标 Build $expected"
+ }
+ clearPending(context, deleteApk = true)
+ return mapOf(
+ "pending" to true,
+ "success" to success,
+ "message" to message,
+ "currentVersionCode" to current,
+ "expectedVersionCode" to expected
+ )
+ }
+
+ /** 读取当前安装应用的包信息与签名证书。 */
+ @Suppress("DEPRECATION")
+ private fun currentPackageInfo(context: Context): PackageInfo =
+ context.packageManager.getPackageInfo(context.packageName, signatureFlags())
+
+ /** 从 APK 文件解析包信息与签名证书；文件损坏或格式不支持时返回空。 */
+ @Suppress("DEPRECATION")
+ private fun packageArchiveInfo(context: Context, path: String): PackageInfo? =
+ context.packageManager.getPackageArchiveInfo(path, signatureFlags())
+
+ /** 根据 Android 版本选择签名信息标志，兼容项目最低 Android 7。 */
+ @Suppress("DEPRECATION")
+ private fun signatureFlags(): Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ PackageManager.GET_SIGNING_CERTIFICATES
+ } else {
+ PackageManager.GET_SIGNATURES
+ }
+
+ /** 统一读取 64 位版本码，Android 9 以下回退旧整型字段。 */
+ @Suppress("DEPRECATION")
+ private fun versionCode(info: PackageInfo): Long = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ info.longVersionCode
+ } else {
+ info.versionCode.toLong()
+ }
+
+ /** 计算 APK 当前签名者 SHA-256 摘要集合，用交集兼容多签名包。 */
+ @Suppress("DEPRECATION")
+ private fun signerDigests(info: PackageInfo): Set {
+ val signatures = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ info.signingInfo?.apkContentsSigners ?: emptyArray()
+ } else {
+ info.signatures ?: emptyArray()
+ }
+ return signatures.map { signature ->
+ MessageDigest.getInstance("SHA-256")
+ .digest(signature.toByteArray())
+ .joinToString("") { byte -> "%02x".format(byte) }
+ }.toSet()
+ }
+
+ /** 构造统一失败结构，避免 Flutter 解析不同异常文本。 */
+ private fun failure(code: String, message: String): Map = mapOf(
+ "valid" to false,
+ "code" to code,
+ "message" to message
+ )
+
+ /** 清理待更新偏好，并按调用场景删除应用私有目录中的 APK。 */
+ private fun clearPending(context: Context, deleteApk: Boolean) {
+ val prefs = preferences(context)
+ if (deleteApk) prefs.getString(APK_PATH_KEY, null)?.let { File(it).delete() }
+ prefs.edit().clear().commit()
+ }
+
+ /** 返回只归当前应用所有的原生待更新偏好。 */
+ private fun preferences(context: Context) =
+ context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE)
+}
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskBootReceiver.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskBootReceiver.kt
new file mode 100644
index 0000000..bd1e3d5
--- /dev/null
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskBootReceiver.kt
@@ -0,0 +1,23 @@
+package com.example.pj_supermarket_cloud
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+/**
+ * 开机时仅在应用已经是 Device Owner 时拉起；应用包替换后始终拉起新版本，并按现有
+ * Device Owner 与自动进入配置恢复 Kiosk。
+ */
+class KioskBootReceiver : BroadcastReceiver() {
+ /** 仅处理开机完成和本应用包替换事件，并按 Device Owner 状态决定是否拉起主界面。 */
+ override fun onReceive(context: Context, intent: Intent) {
+ val action = intent.action
+ if (action != Intent.ACTION_BOOT_COMPLETED && action != Intent.ACTION_MY_PACKAGE_REPLACED) return
+ if (action == Intent.ACTION_BOOT_COMPLETED && !KioskModeManager.prepareForBoot(context)) return
+ if (action == Intent.ACTION_MY_PACKAGE_REPLACED) KioskModeManager.prepareForBoot(context)
+
+ val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName) ?: return
+ launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+ context.startActivity(launchIntent)
+ }
+}
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskDeviceAdminReceiver.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskDeviceAdminReceiver.kt
new file mode 100644
index 0000000..b4f9aa2
--- /dev/null
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskDeviceAdminReceiver.kt
@@ -0,0 +1,10 @@
+package com.example.pj_supermarket_cloud
+
+import android.app.admin.DeviceAdminReceiver
+
+/**
+ * 专用收银终端的设备管理接收器。
+ *
+ * 该接收器只作为 Device Owner 的系统入口，应用不会在普通安装状态下自行提升权限。
+ */
+class KioskDeviceAdminReceiver : DeviceAdminReceiver()
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskModeManager.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskModeManager.kt
new file mode 100644
index 0000000..abbcc95
--- /dev/null
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/KioskModeManager.kt
@@ -0,0 +1,355 @@
+package com.example.pj_supermarket_cloud
+
+import android.app.Activity
+import android.app.ActivityManager
+import android.app.admin.DevicePolicyManager
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+
+/**
+ * 管理 Android 专用设备模式。
+ *
+ * 只有 Device Owner 才能可靠限制主页、最近任务和状态栏。普通设备管理员或沉浸式全屏
+ * 都不视为 Kiosk 可用，避免界面把“看起来全屏”误报为“无法退出”。
+ */
+object KioskModeManager {
+ /** Kiosk 原生配置使用的应用私有偏好文件。 */
+ private const val PREFERENCES_NAME = "kiosk_runtime"
+
+ /** 是否在进入 App 时自动恢复 Lock Task 的持久化键。 */
+ private const val AUTO_ENTER_ENABLED_KEY = "auto_enter_enabled"
+
+ /** Root 执行 DPM 命令的最长等待时间。 */
+ private const val DPM_TIMEOUT_MILLIS = 30_000L
+
+ /** 厂商系统栏被边缘手势唤出后重新隐藏的等待时间，避免与手势动画同帧争用。 */
+ private const val SYSTEM_BAR_REHIDE_DELAY_MILLIS = 250L
+
+ /** 返回 Flutter 设置页和心跳共用的实时 Kiosk 能力与运行状态。 */
+ fun status(context: Context): Map {
+ val policyManager = policyManager(context)
+ val deviceOwner = policyManager.isDeviceOwnerApp(context.packageName)
+ val autoEnterEnabled = isAutoEnterEnabled(context)
+ return mapOf(
+ "deviceAdminActive" to policyManager.isAdminActive(adminComponent(context)),
+ "deviceOwner" to deviceOwner,
+ "available" to deviceOwner,
+ "active" to isKioskActive(context),
+ "lockTaskPermitted" to policyManager.isLockTaskPermitted(context.packageName),
+ "autoEnterEnabled" to autoEnterEnabled,
+ "bootAutoStartSupported" to deviceOwner
+ )
+ }
+
+ /**
+ * Activity 每次回到前台时按配置补齐白名单并进入锁定任务。管理员退出到桌面的过程
+ * 不会触发新的 onPostResume；用户再次主动打开 App 时才会重新进入 Kiosk。
+ */
+ fun enterIfAvailable(activity: Activity) {
+ if (!isAutoEnterEnabled(activity) || !ensureLockTaskPolicy(activity)) return
+ if (!isKioskActive(activity)) {
+ try {
+ activity.startLockTask()
+ } catch (_: IllegalArgumentException) {
+ return
+ } catch (_: IllegalStateException) {
+ return
+ } catch (_: SecurityException) {
+ return
+ }
+ }
+ if (isKioskActive(activity)) hideSystemBars(activity)
+ }
+
+ /**
+ * Device Owner 设备始终支持开机拉起 App；只有开启自动进入时才预先恢复 Kiosk 策略。
+ */
+ fun prepareForBoot(context: Context): Boolean {
+ if (!policyManager(context).isDeviceOwnerApp(context.packageName)) return false
+ if (isAutoEnterEnabled(context)) {
+ return ensureLockTaskPolicy(context)
+ }
+ return try {
+ policyManager(context).setStatusBarDisabled(adminComponent(context), false)
+ true
+ } catch (_: Exception) {
+ true
+ }
+ }
+
+ /**
+ * 解除当前锁定并回到系统 HOME。保留 Lock Task 白名单，自动进入配置开启时，用户
+ * 下次主动打开 App 会通过 onPostResume 重新锁定。
+ */
+ fun exitToHome(activity: Activity): Boolean {
+ val policyManager = policyManager(activity)
+ if (!policyManager.isDeviceOwnerApp(activity.packageName)) return false
+
+ return try {
+ if (isKioskActive(activity)) activity.stopLockTask()
+ policyManager.setStatusBarDisabled(adminComponent(activity), false)
+ showSystemBars(activity)
+
+ val homeIntent = Intent(Intent.ACTION_MAIN).apply {
+ addCategory(Intent.CATEGORY_HOME)
+ addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
+ }
+ if (homeIntent.resolveActivity(activity.packageManager) != null) {
+ activity.startActivity(homeIntent)
+ } else {
+ activity.moveTaskToBack(true)
+ }
+ true
+ } catch (_: Exception) {
+ // 退出失败时恢复终端策略，不能把设备留在既未锁定也未回到桌面的中间状态。
+ if (isAutoEnterEnabled(activity) && ensureLockTaskPolicy(activity)) {
+ enterIfAvailable(activity)
+ }
+ false
+ }
+ }
+
+ /**
+ * 保存 Kiosk 自动进入配置并立即同步当前 Activity 的 Lock Task 状态。
+ *
+ * 设置页本身已经受管理员密码保护，因此关闭开关时直接退出当前 Lock Task 但仍停留在
+ * App 内；开启时立即补齐策略并进入，避免持久化值与当前系统状态需要多次切换才一致。
+ */
+ fun setAutoEnterEnabled(activity: Activity, enabled: Boolean): Map {
+ if (!policyManager(activity).isDeviceOwnerApp(activity.packageName)) return status(activity)
+ preferences(activity).edit().putBoolean(AUTO_ENTER_ENABLED_KEY, enabled).commit()
+ if (enabled) {
+ enterIfAvailable(activity)
+ } else {
+ exitCurrentKiosk(activity)
+ }
+ if (isKioskActive(activity) != enabled) {
+ // 系统状态切换失败时回滚持久化值，避免界面显示关闭但设备仍处于 Lock Task。
+ preferences(activity).edit().putBoolean(AUTO_ENTER_ENABLED_KEY, !enabled).commit()
+ }
+ return status(activity)
+ }
+
+ /**
+ * 仅在用户主动触发后通过 Root 配置当前应用为 Device Owner。
+ *
+ * 本方法不会删除系统账户、移除其他 Owner 或修改设备策略文件；Android 拒绝时按常见
+ * 限制返回稳定错误编码，调用方可给管理员明确处理建议。
+ */
+ fun provisionDeviceOwnerWithRoot(context: Context): Map {
+ val policyManager = policyManager(context)
+ if (policyManager.isDeviceOwnerApp(context.packageName)) {
+ return provisionResult(true, "ALREADY_OWNER", "当前应用已经是 Device Owner")
+ }
+ val root = RootCommandRunner.checkRoot()
+ if (root["available"] != true) {
+ return provisionResult(false, "ROOT_UNAVAILABLE", root["message"]?.toString() ?: "Root 不可用")
+ }
+ val component = adminComponent(context).flattenToShortString()
+ val command = RootCommandRunner.execute(
+ "dpm set-device-owner --user 0 ${RootCommandRunner.quoteShell(component)}",
+ DPM_TIMEOUT_MILLIS
+ )
+ if (policyManager.isDeviceOwnerApp(context.packageName)) {
+ return provisionResult(true, "OK", "Device Owner 配置成功")
+ }
+
+ val output = command.output.lowercase()
+ val (code, message) = when {
+ command.timedOut -> "DPM_TIMEOUT" to "DPM 命令执行超时，请检查厂商系统策略"
+ "account" in output -> "ACCOUNT_EXISTS" to "设备存在系统账户，Android 不允许配置 Device Owner；请在设备初始化部署阶段处理账户后重试"
+ "already" in output && ("owner" in output || "profile" in output) ->
+ "OWNER_EXISTS" to "设备已存在其他 Device Owner 或 Profile Owner，当前应用不会自动移除它"
+ "system user" in output || "primary user" in output || "user 0" in output && "not" in output ->
+ "NON_PRIMARY_USER" to "当前不在 Android 主用户（user 0）环境，无法配置 Device Owner"
+ "unknown command" in output || "not found" in output || "unsupported" in output ->
+ "COMMAND_UNSUPPORTED" to "当前系统不支持 dpm set-device-owner 命令"
+ else -> "OEM_RESTRICTED" to (command.output.ifBlank {
+ "Android 或厂商策略拒绝配置 Device Owner，请检查设备初始化状态"
+ })
+ }
+ return provisionResult(false, code, message)
+ }
+
+ /** 窗口重新获得焦点时恢复 Kiosk 系统栏策略，防止临时系统界面留下可退出入口。 */
+ fun reapplySystemBars(activity: Activity) {
+ if (isKioskActive(activity)) hideSystemBars(activity)
+ }
+
+ /** 判断 Android 当前是否处于完全锁定的 Lock Task 模式。 */
+ fun isKioskActive(context: Context): Boolean {
+ val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+ return activityManager.lockTaskModeState == ActivityManager.LOCK_TASK_MODE_LOCKED
+ }
+
+ /** 为当前 Device Owner 配置 Lock Task 白名单、系统栏策略和长按电源菜单能力。 */
+ private fun ensureLockTaskPolicy(context: Context): Boolean {
+ val policyManager = policyManager(context)
+ if (!policyManager.isDeviceOwnerApp(context.packageName)) return false
+ return try {
+ policyManager.setLockTaskPackages(adminComponent(context), arrayOf(context.packageName))
+ policyManager.setStatusBarDisabled(adminComponent(context), true)
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ policyManager.setLockTaskFeatures(
+ adminComponent(context),
+ // 仅放行系统全局操作菜单，使管理员仍能长按电源关机；主页和最近任务继续禁用。
+ DevicePolicyManager.LOCK_TASK_FEATURE_GLOBAL_ACTIONS
+ )
+ }
+ policyManager.isLockTaskPermitted(context.packageName)
+ } catch (_: Exception) {
+ false
+ }
+ }
+
+ /**
+ * 应用 Kiosk 系统栏策略，并监听厂商 SystemUI 与输入法可见性变化。
+ *
+ * Android 沉浸模式允许边缘手势短暂唤出系统栏；RK3568 固件不会按标准行为自动收回，
+ * 因此在动画结束后再次应用策略。输入法显示期间仅恢复导航栏，使系统输入法保留收起
+ * 键盘入口；输入法关闭后再隐藏全部系统栏，不能为了键盘操作永久暴露系统导航。
+ */
+ private fun hideSystemBars(activity: Activity) {
+ val decorView = activity.window.decorView
+ var imeVisible = isInputMethodVisible(activity)
+ var rehidePosted = false
+
+ /**
+ * 厂商 SystemUI 完成边缘手势动画后再恢复沉浸模式；同一轮 Insets 与旧版可见性
+ * 回调只排队一次，并在执行前复核 Kiosk 和输入法状态，避免误隐藏键盘导航入口。
+ */
+ fun scheduleSystemBarRehide() {
+ if (rehidePosted) return
+ rehidePosted = true
+ decorView.postDelayed(
+ {
+ rehidePosted = false
+ if (isKioskActive(activity) && !isInputMethodVisible(activity)) {
+ applyKioskSystemBars(activity, false)
+ }
+ },
+ SYSTEM_BAR_REHIDE_DELAY_MILLIS
+ )
+ }
+
+ ViewCompat.setOnApplyWindowInsetsListener(decorView) { _, insets ->
+ val nextImeVisible = insets.isVisible(WindowInsetsCompat.Type.ime())
+ val systemBarsVisible =
+ insets.isVisible(WindowInsetsCompat.Type.statusBars()) ||
+ insets.isVisible(WindowInsetsCompat.Type.navigationBars())
+ if (imeVisible != nextImeVisible) {
+ imeVisible = nextImeVisible
+ decorView.post {
+ if (isKioskActive(activity)) {
+ applyKioskSystemBars(activity, nextImeVisible)
+ }
+ }
+ } else if (!nextImeVisible && systemBarsVisible) {
+ // RK3568 的 Android 11 不一定触发旧版可见性回调，必须直接监听 Insets。
+ scheduleSystemBarRehide()
+ }
+ // 不消费 Insets，Flutter 仍需获得准确的 viewInsets 以完成键盘避让布局。
+ insets
+ }
+ @Suppress("DEPRECATION")
+ decorView.setOnSystemUiVisibilityChangeListener {
+ if (!isKioskActive(activity)) return@setOnSystemUiVisibilityChangeListener
+ // 保留旧回调兼容 RK 厂商固件中的混合 SystemUI 实现。
+ scheduleSystemBarRehide()
+ }
+ applyKioskSystemBars(activity, imeVisible)
+ ViewCompat.requestApplyInsets(decorView)
+ }
+
+ /**
+ * 根据输入法状态应用 AndroidX Insets 与 Android 11 厂商固件仍依赖的系统栏标记。
+ *
+ * Lock Task 继续负责禁用 Home 与最近任务；输入法可见时恢复的导航栏仅提供系统返回/
+ * 收起键盘入口，状态栏始终保持隐藏。
+ */
+ @Suppress("DEPRECATION")
+ private fun applyKioskSystemBars(activity: Activity, imeVisible: Boolean) {
+ val decorView = activity.window.decorView
+ decorView.systemUiVisibility = if (imeVisible) {
+ View.SYSTEM_UI_FLAG_FULLSCREEN or
+ View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+ View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
+ } else {
+ View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY or
+ View.SYSTEM_UI_FLAG_FULLSCREEN or
+ View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
+ View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+ View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
+ View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
+ }
+ WindowCompat.setDecorFitsSystemWindows(activity.window, false)
+ WindowCompat.getInsetsController(activity.window, activity.window.decorView).apply {
+ hide(WindowInsetsCompat.Type.statusBars())
+ if (imeVisible) {
+ show(WindowInsetsCompat.Type.navigationBars())
+ } else {
+ hide(WindowInsetsCompat.Type.navigationBars())
+ }
+ systemBarsBehavior =
+ WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
+ }
+ }
+
+ /** 返回当前输入法是否实际占用窗口，空 Insets 视为键盘未显示。 */
+ private fun isInputMethodVisible(activity: Activity): Boolean =
+ ViewCompat.getRootWindowInsets(activity.window.decorView)
+ ?.isVisible(WindowInsetsCompat.Type.ime()) == true
+
+ /** 关闭当前 Lock Task 但停留在 App 内，并立即恢复可用的系统栏。 */
+ private fun exitCurrentKiosk(activity: Activity) {
+ try {
+ if (isKioskActive(activity)) activity.stopLockTask()
+ } catch (_: Exception) {
+ // 后续实时状态会向 Flutter 暴露关闭失败，不能在这里伪造成功。
+ }
+ try {
+ policyManager(activity).setStatusBarDisabled(adminComponent(activity), false)
+ } catch (_: Exception) {
+ // 部分厂商在 Lock Task 切换帧内暂时拒绝策略变更，系统栏恢复仍继续执行。
+ }
+ showSystemBars(activity)
+ }
+
+ /** 管理员关闭或退出 Kiosk 时移除自动重隐藏监听，并恢复正常窗口边距与系统栏。 */
+ @Suppress("DEPRECATION")
+ private fun showSystemBars(activity: Activity) {
+ val decorView = activity.window.decorView
+ ViewCompat.setOnApplyWindowInsetsListener(decorView, null)
+ decorView.setOnSystemUiVisibilityChangeListener(null)
+ decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+ WindowCompat.setDecorFitsSystemWindows(activity.window, true)
+ WindowCompat.getInsetsController(activity.window, decorView)
+ .show(WindowInsetsCompat.Type.systemBars())
+ }
+
+ /** 返回 Manifest 已注册的设备管理员组件。 */
+ private fun adminComponent(context: Context) = ComponentName(context, KioskDeviceAdminReceiver::class.java)
+
+ /** 获取系统 DevicePolicyManager，所有 Owner 判断以其实时结果为准。 */
+ private fun policyManager(context: Context) =
+ context.getSystemService(Context.DEVICE_POLICY_SERVICE) as DevicePolicyManager
+
+ /** 读取进入 App 自动恢复 Kiosk 的原生持久化配置，旧设备默认开启。 */
+ private fun isAutoEnterEnabled(context: Context) =
+ preferences(context).getBoolean(AUTO_ENTER_ENABLED_KEY, true)
+
+ /** 返回仅归当前应用所有的 Kiosk 偏好存储。 */
+ private fun preferences(context: Context) =
+ context.getSharedPreferences(PREFERENCES_NAME, Context.MODE_PRIVATE)
+
+ /** 构造 MethodChannel 可直接返回的 DPM 配置结果。 */
+ private fun provisionResult(success: Boolean, code: String, message: String): Map =
+ mapOf("success" to success, "code" to code, "message" to message)
+}
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/MainActivity.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/MainActivity.kt
index afc3f9a..4c8a358 100644
--- a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/MainActivity.kt
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/MainActivity.kt
@@ -1,28 +1,348 @@
package com.example.pj_supermarket_cloud
+import android.content.Context
+import android.app.ActivityManager
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.net.TrafficStats
+import android.hardware.display.DisplayManager
+import android.os.Build
+import android.os.Debug
+import android.os.Process
+import android.os.StatFs
+import android.os.SystemClock
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.telephony.TelephonyManager
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugins.GeneratedPluginRegistrant
import io.flutter.plugins.facediscern.flutter.FlutterFaceDiscernPlugin
+import io.flutter.plugins.facediscern.flutter.FlutterFaceSubScreenPlugin
+import io.flutter.plugins.facediscern.session.FaceRecognitionSessionManager
+import io.flutter.plugin.common.MethodChannel
+import com.rex.flutter_subscreen_plugin.FlutterSubScreenProvider
+import com.rex.flutter_subscreen_plugin.FlutterSubscreenPlugin
+import java.util.concurrent.Executors
+/**
+ * 终端主屏 Flutter Activity，集中注册人脸、副屏、运行状态、Root/Kiosk 和 APK 更新通道。
+ */
class MainActivity : FlutterActivity() {
+ /** 保存进程级运行时基准，Activity 重建时不重置 App 运行时长。 */
+ companion object {
+ /** 进程首次加载 Activity 类时的单调时钟，用于心跳报告当前 App 运行时长。 */
+ private val processStartedAtMillis = SystemClock.elapsedRealtime()
+ }
+
+ /** Flutter 运行环境、Root/Kiosk 与 APK 操作共用的 MethodChannel 名称。 */
+ private val runtimeChannel = "biz_xfj/runtime_environment"
+
+ /** 主屏向独立副屏 Engine 转发轻量消息的 MethodChannel 名称。 */
+ private val subScreenChannel = "screen_plugin_sub_channel"
+
+ /** Root、DPM 与 APK 安装均在后台串行执行，避免阻塞 Flutter 主线程和 Android UI。 */
+ private val privilegedExecutor = Executors.newSingleThreadExecutor()
+
+ /** 注册项目原生插件和运行时通道；耗时特权命令始终转交后台执行器。 */
override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
super.configureFlutterEngine(flutterEngine)
// 人脸识别插件
val flutterFaceDiscernPlugin = FlutterFaceDiscernPlugin()
flutterEngine.plugins.add(flutterFaceDiscernPlugin)
+ flutterEngine.plugins.add(FlutterFaceSubScreenPlugin())
+
+ // 副屏是独立 Flutter Engine，需要独立的人脸通道和 TextureRegistry；
+ // 两个插件实例最终共享同一个进程级 Camera/虹软 Session。
+ FlutterSubscreenPlugin.registerThirdPlugins(
+ arrayListOf(FlutterFaceSubScreenPlugin()),
+ flutterEngine.plugins
+ )
+
+ MethodChannel(flutterEngine.dartExecutor.binaryMessenger, runtimeChannel).setMethodCallHandler { call, result ->
+ when (call.method) {
+ "getRuntimeEnvironment" -> {
+ val displayManager = getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
+ val packageInfo = packageManager.getPackageInfo(packageName, 0)
+ @Suppress("DEPRECATION")
+ val apkVersionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+ packageInfo.longVersionCode
+ } else {
+ packageInfo.versionCode.toLong()
+ }
+ result.success(
+ mapOf(
+ "isEmulator" to isEmulator(),
+ "displayCount" to displayManager.displays.size,
+ // 系统和安装包版本来自当前进程实际运行环境，不能使用后台目标版本代替。
+ "androidVersion" to Build.VERSION.RELEASE,
+ "androidSdkInt" to Build.VERSION.SDK_INT,
+ "apkVersionName" to (packageInfo.versionName ?: ""),
+ "apkVersionCode" to apkVersionCode
+ )
+ )
+ }
+ "getNetworkSnapshot" -> result.success(getNetworkSnapshot())
+ "getPerformanceSnapshot" -> result.success(getPerformanceSnapshot())
+ "vibrate" -> {
+ val duration = call.argument("durationMs")?.toLong() ?: 60L
+ result.success(vibrateForBlockedDialog(duration.coerceIn(20L, 200L)))
+ }
+ "isSubScreenShowing" -> result.success(
+ FlutterSubScreenProvider.instance.presentation?.isShowing == true
+ )
+ "sendViceMessage" -> {
+ val method = call.argument("method")
+ val params = call.argument>("params") ?: emptyMap()
+ if (method.isNullOrBlank()) {
+ result.error("INVALID_ARGUMENT", "缺少副屏消息方法", null)
+ } else {
+ val subEngine = FlutterSubScreenProvider.instance.flutterEngine
+ if (subEngine == null) {
+ result.success(false)
+ } else {
+ try {
+ // 只做单向通知，不注册回调等待副屏；副屏异常不能占住主屏硬件链路。
+ MethodChannel(subEngine.dartExecutor.binaryMessenger, subScreenChannel)
+ .invokeMethod(method, params)
+ result.success(true)
+ } catch (error: Exception) {
+ result.error("VICE_MESSAGE_FAILED", "副屏消息转发失败", error.message)
+ }
+ }
+ }
+ }
+ "getKioskStatus" -> result.success(KioskModeManager.status(this))
+ "checkRootAccess" -> runPrivileged(result) {
+ RootCommandRunner.checkRoot()
+ }
+ "enableKioskWithRoot" -> {
+ privilegedExecutor.execute {
+ val provision = try {
+ KioskModeManager.provisionDeviceOwnerWithRoot(applicationContext)
+ } catch (error: Exception) {
+ mapOf(
+ "success" to false,
+ "code" to "DPM_FAILED",
+ "message" to (error.message ?: "Device Owner 配置失败")
+ )
+ }
+ runOnUiThread {
+ if (provision["success"] == true) {
+ KioskModeManager.setAutoEnterEnabled(this, true)
+ }
+ result.success(provision + ("status" to KioskModeManager.status(this)))
+ }
+ }
+ }
+ "setKioskAutoEnterEnabled" -> {
+ val enabled = call.argument("enabled")
+ if (enabled == null) {
+ result.error("INVALID_ARGUMENT", "缺少 Kiosk 自动进入配置", null)
+ } else {
+ result.success(KioskModeManager.setAutoEnterEnabled(this, enabled))
+ }
+ }
+ "exitKioskToHome" -> result.success(KioskModeManager.exitToHome(this))
+ "validateApk" -> {
+ val path = call.argument("path")
+ val expectedVersionCode = call.argument("expectedVersionCode")?.toLong()
+ if (path.isNullOrBlank() || expectedVersionCode == null) {
+ result.error("INVALID_ARGUMENT", "缺少 APK 路径或目标版本码", null)
+ } else {
+ runPrivileged(result) {
+ ApkUpdateManager.validate(applicationContext, path, expectedVersionCode)
+ }
+ }
+ }
+ "installApkWithRoot" -> {
+ val path = call.argument("path")
+ val expectedVersionCode = call.argument("expectedVersionCode")?.toLong()
+ if (path.isNullOrBlank() || expectedVersionCode == null) {
+ result.error("INVALID_ARGUMENT", "缺少 APK 路径或目标版本码", null)
+ } else {
+ runPrivileged(result) {
+ ApkUpdateManager.install(applicationContext, path, expectedVersionCode)
+ }
+ }
+ }
+ "consumePendingUpdate" -> runPrivileged(result) {
+ ApkUpdateManager.consumePending(applicationContext)
+ }
+ else -> result.notImplemented()
+ }
+ }
GeneratedPluginRegistrant.registerWith(flutterEngine)
-//
-//
-// FlutterSubscreenPlugin.registerThirdPlugins(
-// arrayListOf(
-//
-// ),
-// this.flutterEngine!!.plugins
-// )
}
-}
\ No newline at end of file
+ /** Activity 回到可交互状态时按原生持久化配置恢复 Kiosk。 */
+ override fun onPostResume() {
+ super.onPostResume()
+ KioskModeManager.enterIfAvailable(this)
+ }
+
+ /** 销毁主 Activity 时同步释放副屏 Engine 和特权命令线程，避免持有失效资源。 */
+ override fun onDestroy() {
+ val subScreenProvider = FlutterSubScreenProvider.instance
+ try {
+ // Android 12 以下副屏使用 Overlay Presentation，任务被划掉时必须在
+ // Activity 销毁前同步移除窗口并销毁独立 Engine，不能只依赖 Dart 生命周期回调。
+ try {
+ subScreenProvider.closeSubDisplay()
+ } finally {
+ try {
+ subScreenProvider.flutterEngine?.destroy()
+ } finally {
+ subScreenProvider.onDispose()
+ }
+ }
+ } finally {
+ privilegedExecutor.shutdownNow()
+ super.onDestroy()
+ }
+ }
+
+ /** 系统报告低内存时释放当前人脸识别会话的高占用资源。 */
+ override fun onTrimMemory(level: Int) {
+ super.onTrimMemory(level)
+ if (level >= TRIM_MEMORY_RUNNING_LOW) {
+ // 低内存时优先释放 Camera/EGL/会话级引擎，跨会话 FaceServer 特征库仍由进程保留。
+ FaceRecognitionSessionManager.getInstance(applicationContext).releaseForLowMemory()
+ }
+ }
+
+ /** 窗口重新获得焦点时恢复 Kiosk 系统栏隐藏策略。 */
+ override fun onWindowFocusChanged(hasFocus: Boolean) {
+ super.onWindowFocusChanged(hasFocus)
+ if (hasFocus) KioskModeManager.reapplySystemBars(this)
+ }
+
+ @Suppress("DEPRECATION")
+ /** Kiosk 运行时拦截系统返回键，普通模式继续使用 FlutterActivity 默认行为。 */
+ override fun onBackPressed() {
+ // 当前 FlutterActivity 基线没有 OnBackPressedDispatcher，Kiosk 运行时直接拦截系统返回。
+ if (KioskModeManager.isKioskActive(this)) return
+ super.onBackPressed()
+ }
+
+ /**
+ * 使用 Android Build 特征识别常见虚拟机，避免在虚拟设备上初始化串口、人脸和副屏硬件。
+ */
+ private fun isEmulator(): Boolean {
+ return Build.FINGERPRINT.startsWith("generic") ||
+ Build.FINGERPRINT.lowercase().contains("emulator") ||
+ Build.MODEL.contains("google_sdk") ||
+ Build.MODEL.lowercase().contains("emulator") ||
+ Build.MODEL.contains("Android SDK built for x86") ||
+ Build.MANUFACTURER.lowercase().contains("genymotion") ||
+ Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic") ||
+ Build.PRODUCT == "google_sdk" ||
+ Build.PRODUCT.lowercase().contains("sdk_gphone") ||
+ Build.PRODUCT.lowercase().contains("vbox86p") ||
+ Build.HARDWARE.lowercase().contains("goldfish") ||
+ Build.HARDWARE.lowercase().contains("ranchu")
+ }
+
+ /**
+ * 返回当前物理网络类型和累计流量。Flutter 侧只计算相邻快照差值，避免测速请求
+ * 额外占用收银终端带宽，也不依赖外部测速服务是否可用。
+ */
+ private fun getNetworkSnapshot(): Map {
+ val connectivity = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+ val capabilities = connectivity.getNetworkCapabilities(connectivity.activeNetwork)
+ val type = when {
+ capabilities == null -> "offline"
+ capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ethernet"
+ capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> "wifi"
+ capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> mobileNetworkType()
+ else -> "network"
+ }
+ return mapOf(
+ "type" to type,
+ "connected" to (capabilities != null),
+ "rxBytes" to TrafficStats.getTotalRxBytes().coerceAtLeast(0L),
+ "txBytes" to TrafficStats.getTotalTxBytes().coerceAtLeast(0L)
+ )
+ }
+
+ /**
+ * 返回轻量的进程与设备资源快照。CPU 使用率由 Flutter 比较两次累计进程时间计算，
+ * 原生层不创建额外线程或定时器，避免运行状态展示反过来增加终端负载。
+ */
+ private fun getPerformanceSnapshot(): Map {
+ val activityManager = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
+ val memoryInfo = ActivityManager.MemoryInfo()
+ activityManager.getMemoryInfo(memoryInfo)
+ val storage = StatFs(filesDir.absolutePath)
+ return mapOf(
+ "systemUptimeSeconds" to SystemClock.elapsedRealtime() / 1_000L,
+ "appUptimeSeconds" to (SystemClock.elapsedRealtime() - processStartedAtMillis).coerceAtLeast(0L) / 1_000L,
+ "processCpuTimeMs" to Process.getElapsedCpuTime(),
+ "logicalProcessorCount" to Runtime.getRuntime().availableProcessors().coerceAtLeast(1),
+ "memoryTotalBytes" to memoryInfo.totalMem,
+ "memoryAvailableBytes" to memoryInfo.availMem,
+ "appMemoryBytes" to Debug.getPss().toLong() * 1024L,
+ "storageTotalBytes" to storage.totalBytes,
+ "storageAvailableBytes" to storage.availableBytes
+ )
+ }
+
+ /**
+ * 为禁止关闭的业务弹框提供短震动提示；设备不具备震动器时返回 false 供 Flutter 回退。
+ */
+ @Suppress("DEPRECATION")
+ private fun vibrateForBlockedDialog(durationMillis: Long): Boolean {
+ val vibrator = getSystemService(Context.VIBRATOR_SERVICE) as? Vibrator ?: return false
+ if (!vibrator.hasVibrator()) return false
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ vibrator.vibrate(VibrationEffect.createOneShot(durationMillis, VibrationEffect.DEFAULT_AMPLITUDE))
+ } else {
+ vibrator.vibrate(durationMillis)
+ }
+ return true
+ }
+
+ @Suppress("DEPRECATION")
+ /** 将蜂窝网络制式归一为心跳接口使用的 2g/3g/4g/5g/mobile 编码。 */
+ private fun mobileNetworkType(): String {
+ return try {
+ val telephony = getSystemService(Context.TELEPHONY_SERVICE) as TelephonyManager
+ when (telephony.dataNetworkType) {
+ TelephonyManager.NETWORK_TYPE_NR -> "5g"
+ TelephonyManager.NETWORK_TYPE_LTE -> "4g"
+ TelephonyManager.NETWORK_TYPE_UMTS,
+ TelephonyManager.NETWORK_TYPE_HSDPA,
+ TelephonyManager.NETWORK_TYPE_HSUPA,
+ TelephonyManager.NETWORK_TYPE_HSPA,
+ TelephonyManager.NETWORK_TYPE_HSPAP -> "3g"
+ TelephonyManager.NETWORK_TYPE_GPRS,
+ TelephonyManager.NETWORK_TYPE_EDGE,
+ TelephonyManager.NETWORK_TYPE_CDMA,
+ TelephonyManager.NETWORK_TYPE_1xRTT -> "2g"
+ else -> "mobile"
+ }
+ } catch (_: SecurityException) {
+ "mobile"
+ }
+ }
+
+ /**
+ * 在专用后台线程执行高延迟原生动作，并始终切回主线程完成 MethodChannel 回调。
+ */
+ private fun runPrivileged(result: MethodChannel.Result, action: () -> Any?) {
+ privilegedExecutor.execute {
+ try {
+ val payload = action()
+ runOnUiThread { result.success(payload) }
+ } catch (error: Exception) {
+ runOnUiThread {
+ result.error("PRIVILEGED_OPERATION_FAILED", error.message, null)
+ }
+ }
+ }
+ }
+
+}
diff --git a/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/RootCommandRunner.kt b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/RootCommandRunner.kt
new file mode 100644
index 0000000..9fbf30e
--- /dev/null
+++ b/android/app/src/main/kotlin/com/example/pj_supermarket_cloud/RootCommandRunner.kt
@@ -0,0 +1,191 @@
+package com.example.pj_supermarket_cloud
+
+import android.os.SystemClock
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+/**
+ * 统一执行需要 Root 的短生命周期 shell 命令。
+ *
+ * 所有调用方必须显式给出超时；标准错误并入标准输出并限制返回长度，避免子进程管道阻塞
+ * 或把不可控的系统输出长期保留在 Flutter 层。
+ */
+object RootCommandRunner {
+ /** Root 检查固定超时，超过 5 秒按不可用处理。 */
+ private const val ROOT_CHECK_TIMEOUT_MILLIS = 5_000L
+
+ /** 返回给上层的最大诊断字符数。 */
+ private const val MAX_OUTPUT_LENGTH = 2_000
+
+ /** 并发读取子进程输出，防止输出缓冲区写满后命令无法退出。 */
+ private val outputExecutor = Executors.newCachedThreadPool()
+
+ /**
+ * 当前进程已经确认可用的 su 参数格式；首次调用时为空，由只读 Root 检查或语法回退确定。
+ */
+ @Volatile
+ private var preferredInvocationMode: SuInvocationMode? = null
+
+ /**
+ * Android 设备现场存在两类常见 su 参数协议，枚举值只描述进程参数格式，不改变业务命令。
+ */
+ private enum class SuInvocationMode {
+ /** Magisk、KernelSU 和 SuperSU 常见的 `su -c ` 格式。 */
+ OPTION_C,
+
+ /** AOSP userdebug 与部分厂商固件要求显式 UID 的 `su 0 sh -c ` 格式。 */
+ UID_ZERO_SHELL
+ }
+
+ /**
+ * 一次 Root 命令执行结果。
+ *
+ * @property exitCode 进程退出码；超时或无法启动时为空
+ * @property output 合并并截断后的标准输出与错误输出
+ * @property timedOut 是否因超过调用方限制被终止
+ */
+ data class CommandResult(
+ val exitCode: Int?,
+ val output: String,
+ val timedOut: Boolean
+ )
+
+ /**
+ * 使用设备支持的 su 参数格式执行命令并轮询退出状态，兼容项目最低 Android 版本。
+ *
+ * 部分厂商 su 会把 `-c` 当成 UID 并返回 `invalid uid/gid '-c'`。仅识别到这个明确的
+ * 参数语法错误时才回退到 `su 0 sh -c`，因此不会把可能已经执行过的安装或 DPM 命令
+ * 重复执行；两次尝试共享调用方给出的总超时。
+ *
+ * @param command 传给 Root shell 的完整命令
+ * @param timeoutMillis 两种参数格式合计允许的最大执行时间，单位毫秒
+ * @return 包含退出码、诊断输出与超时状态的结果
+ */
+ fun execute(command: String, timeoutMillis: Long): CommandResult {
+ val normalizedTimeout = timeoutMillis.coerceAtLeast(1L)
+ val preferred = preferredInvocationMode
+ if (preferred != null) {
+ return executeWithMode(command, normalizedTimeout, preferred)
+ }
+
+ val startedAt = SystemClock.elapsedRealtime()
+ val optionResult = executeWithMode(command, normalizedTimeout, SuInvocationMode.OPTION_C)
+ if (!isOptionCSyntaxRejected(optionResult)) {
+ if (!optionResult.timedOut && optionResult.exitCode != null) {
+ preferredInvocationMode = SuInvocationMode.OPTION_C
+ }
+ return optionResult
+ }
+
+ val elapsed = SystemClock.elapsedRealtime() - startedAt
+ val remaining = (normalizedTimeout - elapsed).coerceAtLeast(1L)
+ val uidResult = executeWithMode(command, remaining, SuInvocationMode.UID_ZERO_SHELL)
+ if (!uidResult.timedOut && uidResult.exitCode != null) {
+ preferredInvocationMode = SuInvocationMode.UID_ZERO_SHELL
+ }
+ return uidResult
+ }
+
+ /**
+ * 按指定 su 参数协议启动一次子进程；本方法不进行协议回退，避免特权命令重复执行。
+ *
+ * @param command 传给 Root shell 的完整命令
+ * @param timeoutMillis 本次进程允许执行的最长时间，单位毫秒
+ * @param mode 本次使用的 su 参数协议
+ * @return 单次进程的退出码、诊断输出和超时状态
+ */
+ private fun executeWithMode(
+ command: String,
+ timeoutMillis: Long,
+ mode: SuInvocationMode
+ ): CommandResult {
+ var process: Process? = null
+ return try {
+ val processCommand = when (mode) {
+ SuInvocationMode.OPTION_C -> listOf("su", "-c", command)
+ SuInvocationMode.UID_ZERO_SHELL -> listOf("su", "0", "sh", "-c", command)
+ }
+ val runningProcess = ProcessBuilder(processCommand)
+ .redirectErrorStream(true)
+ .start()
+ process = runningProcess
+ val outputFuture = outputExecutor.submit {
+ runningProcess.inputStream.bufferedReader().use { it.readText() }
+ }
+ val deadline = SystemClock.elapsedRealtime() + timeoutMillis
+ var exitCode: Int? = null
+ while (SystemClock.elapsedRealtime() <= deadline) {
+ exitCode = try {
+ runningProcess.exitValue()
+ } catch (_: IllegalThreadStateException) {
+ null
+ }
+ if (exitCode != null) break
+ Thread.sleep(50)
+ }
+ val timedOut = exitCode == null
+ if (timedOut) runningProcess.destroy()
+ val output = try {
+ outputFuture.get(500, TimeUnit.MILLISECONDS)
+ } catch (_: Exception) {
+ ""
+ }
+ CommandResult(exitCode, sanitize(output), timedOut)
+ } catch (error: Exception) {
+ process?.destroy()
+ CommandResult(null, sanitize(error.message ?: "无法执行 su 命令"), false)
+ }
+ }
+
+ /**
+ * 判断标准 `su -c` 是否被设备误当成 UID/GID 或未知选项。
+ *
+ * 只有命中明确参数错误才允许换协议重试；授权拒绝、命令失败和超时都原样返回，避免
+ * DPM 或 APK 安装等具有副作用的命令被执行两次。
+ */
+ private fun isOptionCSyntaxRejected(result: CommandResult): Boolean {
+ if (result.timedOut || result.exitCode == null || result.exitCode == 0) return false
+ val output = result.output.lowercase()
+ val mentionsOptionC = "'-c'" in output || "\"-c\"" in output || " -c" in output
+ return mentionsOptionC && (
+ "invalid uid/gid" in output ||
+ "invalid uid" in output ||
+ "unknown option" in output ||
+ "unrecognized option" in output ||
+ "illegal option" in output
+ )
+ }
+
+ /**
+ * 真实执行 Root shell 的 `id` 检查；不能只根据 su 文件是否存在进行判断。
+ */
+ fun checkRoot(): Map {
+ val command = execute("id", ROOT_CHECK_TIMEOUT_MILLIS)
+ val available = command.exitCode == 0 && Regex("(^|\\s)uid=0([\\s(]|$)")
+ .containsMatchIn(command.output)
+ val message = when {
+ command.timedOut -> "Root 授权超时（5秒），请检查 su 授权策略"
+ available -> "已通过 su 执行 id 确认 uid=0"
+ command.exitCode == null -> command.output.ifBlank { "未找到 su 或 Root 命令无法启动" }
+ command.output.isBlank() -> "su 返回退出码 ${command.exitCode}，未确认 uid=0"
+ else -> command.output
+ }
+ return mapOf(
+ "available" to available,
+ "exitCode" to (command.exitCode ?: -1),
+ "timedOut" to command.timedOut,
+ "message" to message
+ )
+ }
+
+ /**
+ * 使用单引号安全包裹 shell 路径，避免空格或特殊字符改变安装命令含义。
+ */
+ fun quoteShell(value: String): String = "'${value.replace("'", "'\\''")}'"
+
+ /** 将多行命令输出压缩为界面可读摘要并限制长度。 */
+ private fun sanitize(output: String): String {
+ val compact = output.trim().replace(Regex("\\s+"), " ")
+ return if (compact.length <= MAX_OUTPUT_LENGTH) compact else compact.take(MAX_OUTPUT_LENGTH) + "..."
+ }
+}
diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml
new file mode 100644
index 0000000..58a1cbe
--- /dev/null
+++ b/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,5 @@
+
+
+ 收银终端设备管理
+ 用于启用开机自启和专用设备锁定模式
+
diff --git a/android/app/src/main/res/xml/kiosk_device_admin.xml b/android/app/src/main/res/xml/kiosk_device_admin.xml
new file mode 100644
index 0000000..8b4c99b
--- /dev/null
+++ b/android/app/src/main/res/xml/kiosk_device_admin.xml
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/lib/app.dart b/lib/app.dart
index 82d2d79..cb675fc 100644
--- a/lib/app.dart
+++ b/lib/app.dart
@@ -29,6 +29,7 @@ class _MainAppState extends State with WidgetsBindingObserver {
@override
void didChangeAppLifecycleState(AppLifecycleState state) async {
+ SyncIdleTool.instance.updateLifecycle(state);
if (state == AppLifecycleState.paused ||
state == AppLifecycleState.detached) {
try {
@@ -81,9 +82,12 @@ class _MainAppState extends State with WidgetsBindingObserver {
GlobalRouteObserver(),
],
builder: EasyLoading.init(
- builder: (_, childSecond) => FTheme(
- data: themeData,
- child: childSecond!,
+ builder: (_, childSecond) => Listener(
+ onPointerDown: (_) => SyncIdleTool.instance.recordUserActivity(),
+ child: FTheme(
+ data: themeData,
+ child: childSecond!,
+ ),
),
),
);
diff --git a/lib/common/api/app_api.dart b/lib/common/api/app_api.dart
index b7f6791..66bd2b4 100644
--- a/lib/common/api/app_api.dart
+++ b/lib/common/api/app_api.dart
@@ -1,13 +1,24 @@
+import 'package:dio/dio.dart' as dio;
+
import 'package:pj_supermarket_cloud/common/index.dart';
+/// 终端 App 配置与版本接口入口，统一复用 HttpManage 的鉴权、租户和错误处理。
abstract class AppApi {
- /// 获取所有版本列表
+ ///
+ /// 分页获取匹配 App 编码和平台的已发布版本。
+ ///
+ /// [pa] 包含 appUniqueCode、platform、current 和 size；[silent] 为 true 时后台任务
+ /// 只记录异常，不弹业务 Toast。
static Future openCardList(
- dynamic pa,
- ) async {
+ dynamic pa, {
+ bool silent = false,
+ }) async {
final res = await HttpManage().dio.get(
"/integrated/app-version/ad/page",
queryParameters: pa,
+ options: dio.Options(
+ extra: {if (silent) HttpManage.silentRequestKey: true},
+ ),
);
if (res.data == null) return null;
return ServiceAppVersionPage.fromJson(res.data);
diff --git a/lib/common/api/hard_api.dart b/lib/common/api/hard_api.dart
index 276a7cf..e1b1257 100644
--- a/lib/common/api/hard_api.dart
+++ b/lib/common/api/hard_api.dart
@@ -1,6 +1,88 @@
+import 'dart:io';
+
+import 'package:dio/dio.dart' as dio;
+
import 'package:pj_supermarket_cloud/common/index.dart';
abstract class HardApi {
+ /// 按终端订单号或服务端订单 ID 对账识别证据状态；后台任务失败不弹业务 Toast。
+ static Future resolveOrderEvidence({
+ required String hardId,
+ String? androidOrderCode,
+ String? orderId,
+ }) async {
+ final res = await HttpManage().dio.get(
+ '/hard/hard-order-evidence/ad/resolve',
+ queryParameters: {
+ if (androidOrderCode != null) 'androidOrderCode': androidOrderCode,
+ if (orderId != null) 'orderId': orderId,
+ },
+ options: dio.Options(
+ headers: {'DEVICE-ID': hardId},
+ extra: {HttpManage.silentRequestKey: true},
+ ),
+ );
+ if (res.data == null) return null;
+ return ServiceOrderEvidenceResolve.fromJson(res.data);
+ }
+
+ /// 提交识别元数据、触发参考图复制或报告本地图片永久缺失。
+ static Future submitOrderEvidence({
+ required String hardId,
+ required OrderEvidenceRequest request,
+ }) async {
+ final res = await HttpManage().dio.post(
+ '/hard/hard-order-evidence/ad/submit',
+ data: request.toJson(),
+ options: dio.Options(
+ headers: {'DEVICE-ID': hardId},
+ extra: {HttpManage.silentRequestKey: true},
+ ),
+ );
+ if (res.data == null) return null;
+ return ServiceOrderEvidenceUploadResult.fromJson(res.data);
+ }
+
+ /// 使用统一 Dio 鉴权和租户头上传现场图片，multipart 文件名不包含终端完整路径。
+ static Future uploadOrderEvidence({
+ required String hardId,
+ required OrderEvidenceRequest request,
+ required String filePath,
+ }) async {
+ final file = File(filePath);
+ final fileName = file.uri.pathSegments.last;
+ final form = dio.FormData.fromMap({
+ ...request.toJson(),
+ 'file': await dio.MultipartFile.fromFile(filePath, filename: fileName),
+ });
+ final res = await HttpManage().dio.post(
+ '/hard/hard-order-evidence/ad/upload',
+ data: form,
+ options: dio.Options(
+ headers: {'DEVICE-ID': hardId},
+ contentType: 'multipart/form-data',
+ extra: {HttpManage.silentRequestKey: true},
+ ),
+ );
+ if (res.data == null) return null;
+ return ServiceOrderEvidenceUploadResult.fromJson(res.data);
+ }
+
+ /// 静默上报食堂、超市 Android 终端最新运行状态；后台失败不得弹出业务 Toast。
+ static Future terminalHeartbeat({
+ required String hardId,
+ required Map data,
+ }) async {
+ await HttpManage().dio.post(
+ '/hard/hard-api/ad/terminal-heartbeat',
+ data: data,
+ options: dio.Options(
+ headers: {'DEVICE-ID': hardId},
+ extra: {HttpManage.silentRequestKey: true},
+ ),
+ );
+ }
+
/// 获取硬件配置信息
static Future bind(dynamic pa) async {
final res = await HttpManage().dio.post(
@@ -45,11 +127,92 @@ abstract class HardApi {
return ServiceUser.fromJson(res.data);
}
+ /// 仅按当前终端和识别身份查询本人预约，调用方不得补充商户或其他用户参数。
+ static Future queryReservationMenu(
+ ReservationMenuQueryRequest request,
+ ) async {
+ final res = await HttpManage().dio.post(
+ "/hard/hard-api/ad/reservation-menu/query",
+ data: request.toJson(),
+ );
+ if (res.data == null) return null;
+ return ServiceReservationMenuQuery.fromJson(res.data);
+ }
+
+ /// 只按查询结果中的订单 ID 核销一笔预约订单。
+ static Future cancelReservationOrder({
+ required int orderId,
+ }) async {
+ final setting = await AppSettingTool.getSysSetting();
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/reservation-menu/cancel',
+ data: {'orderId': orderId},
+ options: dio.Options(
+ headers: {
+ if (setting.serviceId != null) 'DEVICE-ID': setting.serviceId,
+ },
+ ),
+ );
+ return res.data == true;
+ }
+
+ /// 一次提交多笔同一用户预约订单，服务端在同一事务内核销并合并生成一张兑换券。
+ static Future cancelReservationOrders({
+ required List orderIds,
+ }) async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) {
+ throw StateError('当前业务终端尚未绑定');
+ }
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/reservation-menu/cancel-batch',
+ data: {'orderIds': orderIds},
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ return res.data == true;
+ }
+
+ /// 分页查询当前设备的预约核销记录，设备范围由服务端再次校验。
+ static Future verificationRecordPage({
+ required int current,
+ required int size,
+ required VerificationRecordQueryRequest request,
+ }) async {
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/verification-record/page',
+ queryParameters: {'current': current, 'size': size},
+ data: request.toJson(),
+ options: dio.Options(headers: {'DEVICE-ID': request.hardId}),
+ );
+ if (res.data == null) return null;
+ return ServiceVerificationRecordPage.fromJson(res.data);
+ }
+
+ /// 分页查询当前设备的交易记录；scope=MERCHANT 时按终端所属商户查询全部设备。
+ static Future terminalOrderRecordPage({
+ required int current,
+ required int size,
+ required TerminalOrderRecordQueryRequest request,
+ }) async {
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/order-record/page',
+ queryParameters: {'current': current, 'size': size},
+ data: request.toJson(),
+ options: dio.Options(headers: {'DEVICE-ID': '${request.hardId}'}),
+ );
+ if (res.data == null) return null;
+ return ServiceTerminalOrderRecordPage.fromJson(res.data);
+ }
+
/// 创建硬件订单
static Future createHardwareOrder(dynamic formData) async {
final res = await HttpManage().dio.post(
"/hard/hard-api/ad/create-order",
data: formData,
+ options: dio.Options(
+ extra: {HttpManage.rejectBusinessErrorKey: true},
+ ),
);
if (res.data == null) return null;
return res.data;
@@ -61,11 +224,45 @@ abstract class HardApi {
final res = await HttpManage().dio.post(
"/hard/hard-api/ad/create-hard-qr-code-order",
data: formData,
+ options: dio.Options(
+ extra: {HttpManage.rejectBusinessErrorKey: true},
+ ),
);
if (res.data == null) return null;
return ServiceHardCreateHardQrCodeScanOrder.fromJson(res.data);
}
+ /// 创建与 Hardware 业务订单绑定的支付宝、微信聚合订单码。
+ static Future createAggregateOrderCodePay(
+ dynamic formData) async {
+ final res = await HttpManage().dio.post(
+ "/hard/hard-api/ad/create-aggregate-order-code-pay",
+ data: formData,
+ options: dio.Options(
+ extra: {HttpManage.rejectBusinessErrorKey: true},
+ ),
+ );
+ if (res.data == null) return null;
+ return ServiceHardAggregateOrderCodePay.fromJson(res.data);
+ }
+
+ /// 查询聚合支付状态；成功响应表示 Hardware 业务订单已同步完成结算。
+ static Future
+ getAggregateOrderCodePayStatus({
+ required String orderId,
+ required String aggregateNo,
+ }) async {
+ final res = await HttpManage().dio.get(
+ "/hard/hard-api/ad/aggregate-order-code-pay/status",
+ queryParameters: {
+ "orderId": orderId,
+ "aggregateNo": aggregateNo,
+ },
+ );
+ if (res.data == null) return null;
+ return ServiceHardAggregateOrderCodePayStatus.fromJson(res.data);
+ }
+
/// 根据订单id,获取订单详情
static Future getOrder(dynamic formData) async {
final res = await HttpManage().dio.get(
@@ -120,6 +317,69 @@ abstract class HardApi {
return ServiceGenerateInvoice.fromJson(res.data);
}
+ /// 业务终端按 DEVICE-ID 创建打印任务，目标打印机只由服务端绑定关系决定。
+ static Future createPrinterTask({
+ required String orderId,
+ String printType = '1',
+ }) async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) throw StateError('当前业务终端尚未绑定');
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/printer/task',
+ data: {
+ 'orderId': int.parse(orderId),
+ 'printType': printType,
+ },
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ return res.data != null;
+ }
+
+ /// 在线查询当前业务终端为指定订单生成的打印凭证，不读取终端本地打印记录。
+ static Future> getPrinterRecords({
+ required String orderId,
+ }) async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) throw StateError('当前业务终端尚未绑定');
+ final res = await HttpManage().dio.get(
+ '/hard/hard-api/ad/printer/records',
+ queryParameters: {'orderId': int.parse(orderId)},
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ if (res.data == null) return const [];
+ if (res.data is! List) throw const FormatException('打印凭证记录格式错误');
+ return (res.data as List)
+ .map((item) => ServicePrintRecord.fromJson(
+ Map.from(item as Map),
+ ))
+ .toList(growable: false);
+ }
+
+ /// 提交当前业务终端已打印兑换券的人工重打原因并取得新任务。
+ static Future reprintVoucher({
+ required String historyId,
+ required String reason,
+ }) async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) throw StateError('当前业务终端尚未绑定');
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/printer/reprint',
+ data: {
+ 'historyId': int.parse(historyId),
+ 'reprintReason': reason,
+ },
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ if (res.data == null) return null;
+ if (res.data is! Map) throw const FormatException('兑换券重打任务格式错误');
+ return ServicePrintRecord.fromJson(
+ Map.from(res.data as Map),
+ );
+ }
+
/// 打印成功
static Future printInvoice(dynamic formData) async {
final res = await HttpManage().dio.get(
@@ -130,6 +390,85 @@ abstract class HardApi {
return true;
}
+ /// 读取当前食堂或超市终端绑定的逻辑打印机及 USB/ESC-POS 参数。
+ static Future?> getPrinterBinding() async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) throw StateError('当前业务终端尚未绑定设备 ID');
+ final res = await HttpManage().dio.get(
+ '/hard/hard-api/ad/printer/bootstrap',
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ if (res.data == null) return null;
+ if (res.data is! Map) throw const FormatException('打印机绑定配置格式错误');
+ return Map.from(res.data as Map);
+ }
+
+ /// 由当前业务终端把实际枚举到的 USB 打印机型号和 VID/PID 上报到绑定的 EY_PRINT 配置。
+ static Future> reportPrinterInfo({
+ required String hardId,
+ required PrinterInfoReportRequest request,
+ }) async {
+ final res = await HttpManage().dio.post(
+ '/hard/hard-api/ad/printer/info',
+ data: request.toJson(),
+ options: dio.Options(headers: {'DEVICE-ID': hardId}),
+ );
+ if (res.data is! Map) throw const FormatException('打印机信息上报响应格式错误');
+ return Map.from(res.data as Map);
+ }
+
+ /// 拉取当前业务终端所绑定打印机的未完成任务，补偿 MQTT 离线窗口。
+ static Future> getPrinterTasks() async {
+ final setting = await AppSettingTool.getSysSetting();
+ final hardId = setting.serviceId;
+ if (hardId == null || hardId.isEmpty) return const [];
+ final res = await HttpManage().dio.get(
+ '/hard/hard-api/ad/printer/tasks',
+ options: dio.Options(
+ headers: {'DEVICE-ID': hardId},
+ extra: {HttpManage.silentRequestKey: true},
+ ),
+ );
+ if (res.data is! List) return const [];
+ return (res.data as List).whereType