change function

AB门禁模块实现说明.md

@@ -27,11 +27,36 @@
 
 ### ✅ checkGateABBeforeToDo() - 主要入口方法
 
+**新的同步API（推荐）**:
 ```java
 ABGateManager abGateManager = ABGateManager.getInstance();
 abGateManager.initialize(context);
 
-abGateManager.checkGateABBeforeToDo(new ABGateManager.ABGateCheckCallback() {
+// 在后台线程中调用（避免阻塞主线程）
+new Thread(() -> {
+    try {
+        boolean canProceed = abGateManager.checkGateABBeforeToDo();
+        
+        // 切换到主线程处理结果
+        runOnUiThread(() -> {
+            if (canProceed) {
+                // AB门检查通过，可以进行人脸识别
+                startFaceRecognition();
+            } else {
+                // AB门检查未通过，需要等待
+                showWaitingMessage();
+            }
+        });
+    } catch (Exception e) {
+        // 处理检查异常
+        LogManager.logError(TAG, "AB门检查异常", e);
+    }
+}).start();
+```
+
+**异步API（向后兼容）**:
+```java
+abGateManager.checkGateABBeforeToDoAsync(new ABGateManager.ABGateCheckCallback() {
     @Override
     public void onSuccess(boolean canProceed) {
         if (canProceed) {
@@ -49,7 +74,6 @@ abGateManager.checkGateABBeforeToDo(new ABGateManager.ABGateCheckCallback() {
         LogManager.logError(TAG, "AB门检查失败: " + errorMessage);
     }
 });
-```
 
 ### ✅ ABGateCheck() - 门状态检查
 
@@ -61,19 +85,27 @@ abGateManager.checkGateABBeforeToDo(new ABGateManager.ABGateCheckCallback() {
 3. 01表示开启，00表示关闭
 4. 只有当A门和B门都关闭时才返回true
 
+**新的同步API**:
 ```java
-abGateManager.ABGateCheck(new ABGateManager.ABGateCheckCallback() {
-    @Override
-    public void onSuccess(boolean gateAvailable) {
+// 在后台线程中调用
+new Thread(() -> {
+    try {
+        boolean gateAvailable = abGateManager.ABGateCheck();
         // gateAvailable = true: A门关闭 AND B门关闭
         // gateAvailable = false: A门或B门有开启状态
-    }
         
-    @Override
-    public void onError(String errorMessage) {
+        runOnUiThread(() -> {
+            if (gateAvailable) {
+                showMessage("门已全部关闭，可用");
+            } else {
+                showMessage("有门开启，不可用");
+            }
+        });
+    } catch (Exception e) {
         // UDP通信失败或解析错误
+        LogManager.logError(TAG, "门状态检查异常", e);
     }
-});
+}).start();
 ```
 
 ### ✅ ABPeopleCheck() - 人数检查
@@ -88,19 +120,27 @@ abGateManager.ABGateCheck(new ABGateManager.ABGateCheckCallback() {
 3. 解析返回的9字节数据，第5字节为人数
 4. 根据场景类型应用不同的判断逻辑
 
+**新的同步API**:
 ```java
-abGateManager.ABPeopleCheck(new ABGateManager.ABGateCheckCallback() {
-    @Override
-    public void onSuccess(boolean peopleCheckPassed) {
+// 在后台线程中调用
+new Thread(() -> {
+    try {
+        boolean peopleCheckPassed = abGateManager.ABPeopleCheck();
         // 进场: peopleCheckPassed = (人数 <= 1)
         // 离场: peopleCheckPassed = (人数 == 0)
-    }
         
-    @Override
-    public void onError(String errorMessage) {
+        runOnUiThread(() -> {
+            if (peopleCheckPassed) {
+                showMessage("人数符合要求");
+            } else {
+                showMessage("人数不符合要求");
+            }
+        });
+    } catch (Exception e) {
         // 485通信失败或485模式未启用
+        LogManager.logError(TAG, "人数检查异常", e);
     }
-});
+}).start();
 ```
 
 ## 在人脸识别界面中的集成

app/src/main/java/com/ouxuan/oxface/abgate/ABGateManager.java

@@ -86,71 +86,54 @@ public class ABGateManager {
      * 检测AB门状态和人数，判断是否可用
      * 主要入口方法：先检查门状态，再检查人数
      * 
-     * @param callback 检查结果回调
+     * @return true表示可用（A门关闭 AND B门关闭 AND 人数符合要求），false表示不可用
      */
-    public void checkGateABBeforeToDo(ABGateCheckCallback callback) {
+    public boolean checkGateABBeforeToDo() {
         LogManager.logInfo(TAG, "开始执行AB门检查流程");
         
-        if (callback == null) {
-            LogManager.logError(TAG, "回调参数为空");
-            return;
-        }
-        
+        try {
             // 第一步：检查AB门状态
             LogManager.logInfo(TAG, "第一步：检查AB门状态");
-        ABGateCheck(new ABGateCheckCallback() {
-            @Override
-            public void onSuccess(boolean gateAvailable) {
-                if (gateAvailable) {
-                    LogManager.logInfo(TAG, "门状态检查通过，开始第二步：检查门内人数");
-                    // 第二步：检查门内人数
-                    ABPeopleCheck(new ABGateCheckCallback() {
-                        @Override
-                        public void onSuccess(boolean peopleCheckPassed) {
-                            LogManager.logInfo(TAG, "人数检查完成，最终结果: " + peopleCheckPassed);
-                            callback.onSuccess(peopleCheckPassed);
-                        }
+            boolean gateCheckResult = ABGateCheck();
             
-                        @Override
-                        public void onError(String errorMessage) {
-                            LogManager.logError(TAG, "人数检查失败: " + errorMessage);
-                            callback.onError("人数检查失败: " + errorMessage);
-                        }
-                    });
-                } else {
+            if (!gateCheckResult) {
                 LogManager.logWarning(TAG, "门状态检查未通过，AB门当前不可用");
-                    callback.onSuccess(false);
-                }
+                return false;
             }
             
-            @Override
-            public void onError(String errorMessage) {
-                LogManager.logError(TAG, "门状态检查失败: " + errorMessage);
-                callback.onError("门状态检查失败: " + errorMessage);
+            LogManager.logInfo(TAG, "门状态检查通过，开始第二步：检查门内人数");
+            
+            // 第二步：检查门内人数
+            boolean peopleCheckResult = ABPeopleCheck();
+            
+            // 两个条件都为true时才返回true
+            boolean finalResult = gateCheckResult && peopleCheckResult;
+            LogManager.logInfo(TAG, "AB门检查完成 - 门状态: " + gateCheckResult + 
+                                  ", 人数检查: " + peopleCheckResult + 
+                                  ", 最终结果: " + finalResult);
+            
+            return finalResult;
+            
+        } catch (Exception e) {
+            LogManager.logError(TAG, "AB门检查异常: " + e.getMessage(), e);
+            return false;
         }
-        });
     }
     
     /**
      * AB门状态检查
      * 逻辑：A门关闭 AND B门关闭 时才返回true，否则返回false
      * 
-     * @param callback 检查结果回调
+     * @return true表示A门和B门都关闭，false表示有门开启
      */
-    public void ABGateCheck(ABGateCheckCallback callback) {
+    public boolean ABGateCheck() {
         LogManager.logInfo(TAG, "执行AB门状态检查");
         
-        if (callback == null) {
-            LogManager.logError(TAG, "ABGateCheck回调参数为空");
-            return;
-        }
-        
         // 检查UDP是否初始化
         if (!oxUDP.isInitialized()) {
             String errorMsg = "UDP门禁控制器未初始化";
             LogManager.logError(TAG, errorMsg);
-            callback.onError(errorMsg);
-            return;
+            throw new RuntimeException(errorMsg);
         }
         
         try {
@@ -194,26 +177,15 @@ public class ABGateManager {
                 oxUDP.queryGateState();
             }
             
-            // 异步处理结果，设置超时
-            gateCheckFuture
-                .orTimeout(GATE_CHECK_TIMEOUT, TimeUnit.MILLISECONDS)
-                .whenComplete((result, throwable) -> {
-                    mainHandler.post(() -> {
-                        if (throwable != null) {
-                            String errorMsg = "门状态检查超时或异常: " + throwable.getMessage();
-                            LogManager.logError(TAG, errorMsg);
-                            callback.onError(errorMsg);
-                        } else {
+            // 同步等待结果，设置超时
+            boolean result = gateCheckFuture.get(GATE_CHECK_TIMEOUT, TimeUnit.MILLISECONDS);
             LogManager.logInfo(TAG, "门状态检查完成，结果: " + result);
-                            callback.onSuccess(result);
-                        }
-                    });
-                });
+            return result;
                 
         } catch (Exception e) {
             String errorMsg = "门状态检查异常: " + e.getMessage();
             LogManager.logError(TAG, errorMsg, e);
-            callback.onError(errorMsg);
+            throw new RuntimeException(errorMsg);
         }
     }
     
@@ -223,9 +195,9 @@ public class ABGateManager {
      * - 进场设备：门内人数 > 1 时不可用（返回false）
      * - 离场设备：门内人数 != 0 时不可用（返回false）
      * 
-     * @param callback 检查结果回调
+     * @return true表示人数符合要求，false表示人数不符合要求
      */
-    public void ABPeopleCheck(ABGateCheckCallback callback) {
+    public boolean ABPeopleCheck() {
         LogManager.logInfo(TAG, "执行AB门内人数检查");
         
         if (callback == null) {
@@ -308,36 +280,41 @@ public class ABGateManager {
     }
     
     /**
-     * 同步方式检查AB门状态和人数（阻塞方法）
-     * 注意：此方法会阻塞当前线程，不建议在主线程调用
+     * 检测AB门状态和人数，判断是否可用。异步版本。
+     * 主要入口方法：先检查门状态，再检查人数
      * 
-     * @return true表示可用，false表示不可用
-     * @throws Exception 检查过程中的异常
+     * @param callback 检查结果回调
      */
-    public boolean checkGateABBeforeToDoSync() throws Exception {
-        LogManager.logInfo(TAG, "执行同步AB门检查");
-        
-        CompletableFuture<Boolean> future = new CompletableFuture<>();
+    public void checkGateABBeforeToDoAsync(ABGateCheckCallback callback) {
+        LogManager.logInfo(TAG, "开始执行异步AB门检查流程");
         
-        checkGateABBeforeToDo(new ABGateCheckCallback() {
-            @Override
-            public void onSuccess(boolean canProceed) {
-                future.complete(canProceed);
-            }
-            
-            @Override
-            public void onError(String errorMessage) {
-                future.completeExceptionally(new RuntimeException(errorMessage));
+        if (callback == null) {
+            LogManager.logError(TAG, "回调参数为空");
+            return;
         }
-        });
         
+        // 在后台线程执行同步检查
+        new Thread(() -> {
             try {
-            // 总超时时间为门状态检查 + 人数检查的时间
-            return future.get(GATE_CHECK_TIMEOUT + PEOPLE_CHECK_TIMEOUT + 2000, TimeUnit.MILLISECONDS);
+                boolean result = checkGateABBeforeToDo();
+                mainHandler.post(() -> callback.onSuccess(result));
             } catch (Exception e) {
-            LogManager.logError(TAG, "同步检查异常", e);
-            throw e;
+                String errorMsg = "AB门检查异常: " + e.getMessage();
+                LogManager.logError(TAG, errorMsg, e);
+                mainHandler.post(() -> callback.onError(errorMsg));
+            }
+        }).start();
     }
+     * 注意：此方法会阻塞当前线程，不建议在主线程调用
+     * 
+     * @return true表示可用，false表示不可用
+     * @throws Exception 检查过程中的异常
+     */
+    public boolean checkGateABBeforeToDoSync() throws Exception {
+        LogManager.logInfo(TAG, "执行同步AB门检查");
+        
+        // 直接调用主方法
+        return checkGateABBeforeToDo();
     }
     
     /**

app/src/main/java/com/ouxuan/oxface/abgate/ABGateTestActivity.java

@@ -117,24 +117,28 @@ public class ABGateTestActivity extends Activity {
         updateStatus("正在执行完整AB门检查...");
         LogManager.logInfo(TAG, "开始执行完整AB门检查");
         
-        abGateManager.checkGateABBeforeToDo(new ABGateManager.ABGateCheckCallback() {
-            @Override
-            public void onSuccess(boolean canProceed) {
-                String result = canProceed ? "检查通过，可以继续操作" : "检查未通过，请等待";
-                updateStatus("完整检查结果: " + result);
-                showToast(result);
-                LogManager.logInfo(TAG, "完整检查结果: " + result);
-            }
+        // 在后台线程执行同步检查
+        new Thread(() -> {
+            try {
+                boolean result = abGateManager.checkGateABBeforeToDo();
+                String resultText = result ? "检查通过，可以继续操作" : "检查未通过，请等待";
                 
-            @Override
-            public void onError(String errorMessage) {
-                String error = "完整检查失败: " + errorMessage;
+                runOnUiThread(() -> {
+                    updateStatus("完整检查结果: " + resultText);
+                    showToast(resultText);
+                    LogManager.logInfo(TAG, "完整检查结果: " + resultText);
+                });
+                
+            } catch (Exception e) {
+                String error = "完整检查异常: " + e.getMessage();
+                runOnUiThread(() -> {
                     updateStatus(error);
                     showToast(error);
-                LogManager.logError(TAG, error);
-            }
+                    LogManager.logError(TAG, error, e);
                 });
             }
+        }).start();
+    }
     
     /**
      * 执行门状态检查
@@ -143,24 +147,28 @@ public class ABGateTestActivity extends Activity {
         updateStatus("正在检查门状态...");
         LogManager.logInfo(TAG, "开始执行门状态检查");
         
-        abGateManager.ABGateCheck(new ABGateManager.ABGateCheckCallback() {
-            @Override
-            public void onSuccess(boolean gateAvailable) {
-                String result = gateAvailable ? "AB门已关闭，可用" : "AB门未完全关闭，不可用";
-                updateStatus("门状态检查结果: " + result);
-                showToast(result);
-                LogManager.logInfo(TAG, "门状态检查结果: " + result);
-            }
+        // 在后台线程执行同步检查
+        new Thread(() -> {
+            try {
+                boolean result = abGateManager.ABGateCheck();
+                String resultText = result ? "AB门已关闭，可用" : "AB门未完全关闭，不可用";
                 
-            @Override
-            public void onError(String errorMessage) {
-                String error = "门状态检查失败: " + errorMessage;
+                runOnUiThread(() -> {
+                    updateStatus("门状态检查结果: " + resultText);
+                    showToast(resultText);
+                    LogManager.logInfo(TAG, "门状态检查结果: " + resultText);
+                });
+                
+            } catch (Exception e) {
+                String error = "门状态检查异常: " + e.getMessage();
+                runOnUiThread(() -> {
                     updateStatus(error);
                     showToast(error);
-                LogManager.logError(TAG, error);
-            }
+                    LogManager.logError(TAG, error, e);
                 });
             }
+        }).start();
+    }
     
     /**
      * 执行人数检查
@@ -169,24 +177,28 @@ public class ABGateTestActivity extends Activity {
         updateStatus("正在检查门内人数...");
         LogManager.logInfo(TAG, "开始执行人数检查");
         
-        abGateManager.ABPeopleCheck(new ABGateManager.ABGateCheckCallback() {
-            @Override
-            public void onSuccess(boolean peopleCheckPassed) {
-                String result = peopleCheckPassed ? "人数符合要求" : "人数不符合要求";
-                updateStatus("人数检查结果: " + result);
-                showToast(result);
-                LogManager.logInfo(TAG, "人数检查结果: " + result);
-            }
+        // 在后台线程执行同步检查
+        new Thread(() -> {
+            try {
+                boolean result = abGateManager.ABPeopleCheck();
+                String resultText = result ? "人数符合要求" : "人数不符合要求";
                 
-            @Override
-            public void onError(String errorMessage) {
-                String error = "人数检查失败: " + errorMessage;
+                runOnUiThread(() -> {
+                    updateStatus("人数检查结果: " + resultText);
+                    showToast(resultText);
+                    LogManager.logInfo(TAG, "人数检查结果: " + resultText);
+                });
+                
+            } catch (Exception e) {
+                String error = "人数检查异常: " + e.getMessage();
+                runOnUiThread(() -> {
                     updateStatus(error);
                     showToast(error);
-                LogManager.logError(TAG, error);
-            }
+                    LogManager.logError(TAG, error, e);
                 });
             }
+        }).start();
+    }
     
     /**
      * 获取状态信息

app/src/main/java/com/ouxuan/oxface/abgate/ABGateUsageExample.java

@@ -37,16 +37,46 @@ public class ABGateUsageExample {
     public void checkBeforeFaceRecognition() {
         LogManager.logInfo(TAG, "开始执行人脸识别前的AB门检查");
         
-        abGateManager.checkGateABBeforeToDo(new ABGateManager.ABGateCheckCallback() {
+        // 方法1：使用同步方式（在后台线程中）
+        new Thread(() -> {
+            try {
+                boolean canProceed = abGateManager.checkGateABBeforeToDo();
+                
+                // 切换到主线程处理结果
+                android.os.Handler mainHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+                mainHandler.post(() -> {
+                    if (canProceed) {
+                        LogManager.logInfo(TAG, "AB门检查通过，可以进行人脸识别");
+                        proceedWithFaceRecognition();
+                    } else {
+                        LogManager.logWarning(TAG, "AB门检查未通过，请等待门关闭或人员离开");
+                        handleGateCheckFailed();
+                    }
+                });
+                
+            } catch (Exception e) {
+                LogManager.logError(TAG, "AB门检查异常: " + e.getMessage(), e);
+                
+                android.os.Handler mainHandler = new android.os.Handler(android.os.Looper.getMainLooper());
+                mainHandler.post(() -> handleGateCheckError(e.getMessage()));
+            }
+        }).start();
+    }
+    
+    /**
+     * 使用异步方式检查（保持向后兼容）
+     */
+    public void checkBeforeFaceRecognitionAsync() {
+        LogManager.logInfo(TAG, "开始执行人脸识别前的AB门检查（异步）");
+        
+        abGateManager.checkGateABBeforeToDoAsync(new ABGateManager.ABGateCheckCallback() {
             @Override
             public void onSuccess(boolean canProceed) {
                 if (canProceed) {
                     LogManager.logInfo(TAG, "AB门检查通过，可以进行人脸识别");
-                    // 在这里继续执行人脸识别逻辑
                     proceedWithFaceRecognition();
                 } else {
                     LogManager.logWarning(TAG, "AB门检查未通过，请等待门关闭或人员离开");
-                    // 在这里处理检查未通过的情况
                     handleGateCheckFailed();
                 }
             }
@@ -54,7 +84,6 @@ public class ABGateUsageExample {
             @Override
             public void onError(String errorMessage) {
                 LogManager.logError(TAG, "AB门检查失败: " + errorMessage);
-                // 在这里处理检查错误的情况
                 handleGateCheckError(errorMessage);
             }
         });