package com.example.card.utils;
import andro
id.os.Handler;
import andro
id.os.Looper;
import andro
id.util.Log;
import com.vi.vioserial.COMSerial;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 基于队列管理和状态机实现异步非阻塞处理，确保指令顺序执行且避免阻塞：
* <p>
* 任务队列：使用ConcurrentLinkedQueue存储开锁请求
* <p>
* 状态机：定义
IDLE/SENDING/WAITING_RESPONSE三种状态
* <p>
* 超时机制：Handler实现超时检测防止阻塞
* <p>
* 结果解析：通过
正则匹配处理串口返回数据
* <p>
* 线程安全：AtomicBoolean保证状态变更原子性
*/
public
class LockManager {
private static String mSeialPort;//串口
// 状态定义
private enum State {
IDLE, SENDING, WAITING_RESPONSE}
// 超时时间（毫秒）
private static final long RESPONSE_TIMEOUT = 3000;
// 状态机控制
private State currentState = State.
IDLE;
private final AtomicBoolean isProcessing = new AtomicBoolean(false);
private final Handler mainHandler = new Handler(Looper.getMainLooper());
// 超时任务引用
private Runnable timeoutRunnable;
// 响应状态标志 (volatile保证多线程可见性)
private volatile boolean responseReceived = false;
// 任务队列
private final ConcurrentLinkedQueue<LockTask> taskQueue = new ConcurrentLinkedQueue<>();
// 结果解析
正则（匹配示例：0D241900500001A0313233...）
private static final Pattern RESPONSE_PATTERN =
Pattern.compile("^0D241900500001([A-F0-9]{2}).*ED0D0A$");
// 单例模式
private static volatile LockManager instance;
// 当前处理的任务对象
private LockTask currentTask;
// 获取当前任务
private LockTask getCurrentTask() {
return currentTask;
}
public static LockManager getInstance(String seialPort) {
mSeialPort = seialPort;
if (instance == null) {
synchronized (LockManager.
class) {
if (instance == null) {
instance = new LockManager();
}
}
}
return instance;
}
// 开锁任务封装
private static
class LockTask {
final String lock
Id;
final String hexCommand;
final LockCallback callback;
LockTask(String lock
Id, String hexCommand, LockCallback callback) {
this.lock
Id = lock
Id;
this.hexCommand = hexCommand;
this.callback = callback;
}
}
// 回调接口
public interface LockCallback {
vo
id onOpened(String lock
Id);
vo
id onFailure(String lock
Id, String error);
vo
id onClosed(String lock
Id );
vo
id onTimeout(String lock
Id);
}
// 添加开锁任务
public vo
id unlock(String lock
Id, String hexCommand, LockCallback callback) {
taskQueue.offer(new LockTask(lock
Id, hexCommand, callback));
processNextTask();
}
// 任务处理器
private vo
id processNextTask() {
if (!isProcessing.compareAndSet(false, true)) return;
LockTask task = taskQueue.poll();
if (task == null) {
isProcessing.set(false);
return;
}
currentState = State.SENDING;
sendLockCommand(task);
}
// 发送开锁指令（修改后）
private vo
id sendLockCommand(LockTask task) {
this.currentTask = task;
try {
// 重置状态标志
responseReceived = false;
// 取消之前的超时任务（如果有）
cancelTimeout();
// 发送指令
COMSerial.instance().sendHex(mSeialPort, task.hexCommand);
currentState = State.WAITING_RESPONSE;
// 创建并保存超时任务
timeoutRunnable = () -> {
// 双重检查：1.检查状态 2.检查响应标志
if (currentState == State.WAITING_RESPONSE && !responseReceived) {
handleTimeout(task);
}
};
// 提交超时检测
mainHandler.postDelayed(timeoutRunnable, RESPONSE_TIMEOUT);
} catch (Exception e) {
task.callback.onFailure(task.lock
Id, "Send error: " + e.getMessage());
completeTask();
}
}
// 处理串口响应（修改后）
public vo
id handleSerialResponse(String response) {
if (currentState != State.WAITING_RESPONSE) return;
LockTask task = getCurrentTask();
if (task == null) return;
// 关键步骤1：立即设置响应标志
responseReceived = true;
// 关键步骤2：立即取消超时任务
cancelTimeout();
// 关键步骤3：处理响应（状态机不变）
Matcher matcher = RESPONSE_PATTERN.matcher(response);
if (!matcher.find()) return;
String statusCode = matcher.group(1);
if ("A0".equals(statusCode)) {
task.callback.onOpened(task.lock
Id);
} else if ("F0".equals(statusCode)) {
task.callback.onClosed(task.lock
Id );
} else {
task.callback.onFailure(task.lock
Id, "Unknown status: " + statusCode);
}
completeTask();
}
// 新增：超时取消方法
private vo
id cancelTimeout() {
if (timeoutRunnable != null) {
mainHandler.removeCallbacks(timeoutRunnable);
timeoutRunnable = null;
}
}
// 超时处理
private vo
id handleTimeout(LockTask task) {
if (currentState == State.WAITING_RESPONSE) {
task.callback.onTimeout(task.lock
Id);
completeTask();
}
}
// 完成任务（修改后）
private vo
id completeTask() {
// 确保清理超时任务
cancelTimeout();
// 重置状态
responseReceived = false;
this.currentTask = null;
currentState = State.
IDLE;
isProcessing.set(false);
// 处理下一个任务
processNextTask();
}
// 资源释放（修改后）
public vo
id release() {
// 清理所有待处理任务
cancelTimeout();
mainHandler.removeCallbacksAndMessages(null);
taskQueue.clear();
}
// 在任务处理过程中获取当前任务信息
public vo
id logTaskStatus() {
LockTask task = getCurrentTask();
if (task != null) {
Log.d("LockManager", "处理中的任务: " + task.lock
Id);
}
}
// 紧急停止当前任务
public vo
id emergencyStop() {
LockTask task = getCurrentTask();
if (task != null) {
task.callback.onFailure(task.lock
Id, "操作被强制中断");
completeTask();
}
}
}
// 批量开锁请求
String[] locks = {"LOCK_001", "LOCK_002", "LOCK_003"};
for (String lock
Id : locks) {
lockManager.unlock(lock
Id, generateHexCommand(lock
Id), new LockManager.LockCallback() {
@Overr
ide
public vo
id onOpened(String lock
Id) {
runOnUiThread(() -> PopTip.show(lock
Id + " 已开锁"));
}
@Overr
ide
public vo
id onClosed(String lock
Id) {
runOnUiThread(() -> PopTip.show(lock
Id + " 已关门"));
}
@Overr
ide
public vo
id onFailure(String lock
Id, String error) {
runOnUiThread(() -> PopTip.show(lock
Id + " 异常" + error));
}
@Overr
ide
public vo
id onTimeout(String lock
Id) {
runOnUiThread(() -> PopTip.show(lock
Id + " 超时"));
}
});
}
批量执行3次开锁，但实际只完成了两次，而且再点击按钮重新执行时就无效了
本文介绍了一种使用正则表达式从HTML内容中提取指定class或id属性值的方法。该方法支持不同大小写的class/id名称及引号类型，并能处理转义字符。适用于快速解析简单的HTML结构。
扫一扫
1272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
