APP
/
oxFaceAndroid
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

change function

dev
赵明涛 1 day ago
parent
a850e4a10b
commit
a31179de57
4 changed files with 215 additions and 157 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 76
      AB门禁模块实现说明.md
  2. 151
      app/src/main/java/com/ouxuan/oxface/abgate/ABGateManager.java
  3. 108
      app/src/main/java/com/ouxuan/oxface/abgate/ABGateTestActivity.java
  4. 37
      app/src/main/java/com/ouxuan/oxface/abgate/ABGateUsageExample.java

76
AB门禁模块实现说明.md
View File

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

151
app/src/main/java/com/ouxuan/oxface/abgate/ABGateManager.java
View File

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

108
app/src/main/java/com/ouxuan/oxface/abgate/ABGateTestActivity.java
View File

@ -117,23 +117,27 @@ public class ABGateTestActivity extends Activity {
updateStatus("正在执行完整AB门检查..."); updateStatus("正在执行完整AB门检查...");
LogManager.logInfo(TAG, "开始执行完整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 ? "检查通过，可以继续操作" : "检查未通过，请等待";
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, e);
});
} }
@Override
public void onError(String errorMessage) {
String error = "完整检查失败: " + errorMessage;
updateStatus(error);
showToast(error);
LogManager.logError(TAG, error);
}
});
}).start();
} }
/** /**
@ -143,23 +147,27 @@ public class ABGateTestActivity extends Activity {
updateStatus("正在检查门状态..."); updateStatus("正在检查门状态...");
LogManager.logInfo(TAG, "开始执行门状态检查"); 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);
}
@Override
public void onError(String errorMessage) {
String error = "门状态检查失败: " + errorMessage;
updateStatus(error);
showToast(error);
LogManager.logError(TAG, error);
// 在后台线程执行同步检查
new Thread(() -> {
try {
boolean result = abGateManager.ABGateCheck();
String resultText = result ? "AB门已关闭，可用" : "AB门未完全关闭，不可用";
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, e);
});
} }
});
}).start();
} }
/** /**
@ -169,23 +177,27 @@ public class ABGateTestActivity extends Activity {
updateStatus("正在检查门内人数..."); updateStatus("正在检查门内人数...");
LogManager.logInfo(TAG, "开始执行人数检查"); 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);
}
@Override
public void onError(String errorMessage) {
String error = "人数检查失败: " + errorMessage;
updateStatus(error);
showToast(error);
LogManager.logError(TAG, error);
// 在后台线程执行同步检查
new Thread(() -> {
try {
boolean result = abGateManager.ABPeopleCheck();
String resultText = result ? "人数符合要求" : "人数不符合要求";
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, e);
});
} }
});
}).start();
} }
/** /**

37
app/src/main/java/com/ouxuan/oxface/abgate/ABGateUsageExample.java
View File

@ -37,16 +37,46 @@ public class ABGateUsageExample {
public void checkBeforeFaceRecognition() { public void checkBeforeFaceRecognition() {
LogManager.logInfo(TAG, "开始执行人脸识别前的AB门检查"); 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 @Override
public void onSuccess(boolean canProceed) { public void onSuccess(boolean canProceed) {
if (canProceed) { if (canProceed) {
LogManager.logInfo(TAG, "AB门检查通过，可以进行人脸识别"); LogManager.logInfo(TAG, "AB门检查通过，可以进行人脸识别");
// 在这里继续执行人脸识别逻辑
proceedWithFaceRecognition(); proceedWithFaceRecognition();
} else { } else {
LogManager.logWarning(TAG, "AB门检查未通过，请等待门关闭或人员离开"); LogManager.logWarning(TAG, "AB门检查未通过，请等待门关闭或人员离开");
// 在这里处理检查未通过的情况
handleGateCheckFailed(); handleGateCheckFailed();
} }
} }
@ -54,7 +84,6 @@ public class ABGateUsageExample {
@Override @Override
public void onError(String errorMessage) { public void onError(String errorMessage) {
LogManager.logError(TAG, "AB门检查失败: " + errorMessage); LogManager.logError(TAG, "AB门检查失败: " + errorMessage);
// 在这里处理检查错误的情况
handleGateCheckError(errorMessage); handleGateCheckError(errorMessage);
} }
}); });

Write Preview
Loading…
Cancel
Save