Update 优化读卡器服务

UI/CF.APP/chicken_farm/android/app/src/main/java/com/vber/chicken_farm/rfid/RfidManager.java

@@ -21,12 +21,12 @@ public class RfidManager {
     private static final String TAG = "RfidManager";
     private static volatile RfidManager instance;
     private final Context context;
-    
+
     // Service相关
     private RfidService rfidService;
     private boolean isBound = false;
     private RfidListener listener;
-    
+
     // 服务连接回调
     private final ServiceConnection serviceConnection = new ServiceConnection() {
         @Override
@@ -34,6 +34,7 @@ public class RfidManager {
             Log.d(TAG, "RFID服务绑定成功");
             RfidBinder binder = (RfidBinder) service;
             rfidService = binder.getService();
+            rfidService.init();
             rfidService.setListener(listener); // 设置回调监听
             isBound = true;
         }
@@ -59,7 +60,7 @@ public class RfidManager {
     /**
      * 获取单例实例
      */
-    public static RfidManager getInstance(Context context,RfidListener listener) {
+    public static RfidManager getInstance(Context context, RfidListener listener) {
         if (instance == null) {
             synchronized (RfidManager.class) {
                 if (instance == null) {
@@ -113,12 +114,12 @@ public class RfidManager {
      * 连接RFID设备（使用默认重试次数）
      */
     public boolean connect() {
-        //checkServiceBound();
-        if(!isBound){
+        // checkServiceBound();
+        if (!isBound) {
             Log.e(TAG, "RFID连接前绑定服务");
             bindService();
             int i = 0;
-            while (!isBound&&i<15) {
+            while (!isBound && i < 15) {
                 try {
                     Thread.sleep(100);
                     i++;
@@ -139,11 +140,11 @@ public class RfidManager {
      */
     public boolean connect(int retryTimes) {
         // checkServiceBound();
-        if(!isBound){
+        if (!isBound) {
             Log.e(TAG, "RFID连接前绑定服务");
             bindService();
             int i = 0;
-            while (!isBound&&i<15) {
+            while (!isBound && i < 15) {
                 try {
                     Thread.sleep(100);
                     i++;
@@ -243,7 +244,6 @@ public class RfidManager {
         return rfidService.getPower();
     }
 
-
     public boolean isConnected() {
         return isBound && rfidService != null && rfidService.isConnected();
     }
@@ -256,7 +256,7 @@ public class RfidManager {
         return isBound && rfidService != null && rfidService.isScreenOn();
     }
 
-    public boolean isMultipleTag(){
+    public boolean isMultipleTag() {
         return isBound && rfidService != null && rfidService.isMultipleTag();
     }
 

UI/CF.APP/chicken_farm/android/app/src/main/java/com/vber/chicken_farm/rfid/RfidMethodCallHandler.java

@@ -47,13 +47,13 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
      */
     public RfidMethodCallHandler(Context context, BinaryMessenger messenger) {
         this.context = context.getApplicationContext();
-        this.rfidManager = RfidManager.getInstance(this.context,this);
+        this.rfidManager = RfidManager.getInstance(this.context, this);
         this.mainHandler = new Handler(Looper.getMainLooper());
         methodChannel = new MethodChannel(messenger, METHOD_CHANNEL_NAME);
         methodChannel.setMethodCallHandler(this);
         EventChannel eventChannel = new EventChannel(messenger, EVENT_CHANNEL_NAME);
         eventChannel.setStreamHandler(this);
-        bindRfidService();
+        // bindRfidService();
         Log.d(TAG, "RFID Flutter MethodChannel初始化完成");
     }
 
@@ -62,14 +62,18 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
     public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
         Log.d(TAG, "收到Flutter方法调用: " + call.method);
         switch (call.method) {
-            case "bindService":
+            case "init":
                 handleBindService(result);
                 break;
+            case "isConnected":
+                handleIsConnected(result);
+                break;
             // case "unbindService":
-            //     handleUnbindService(result);
-            //     break;
+            // handleUnbindService(result);
+            // break;
             case "connect":
-                int retryTimes = call.argument("retryTimes") != null ? call.argument("retryTimes") : RfidConstants.DEFAULT_CONNECT_RETRY_TIMES;
+                int retryTimes = call.argument("retryTimes") != null ? call.argument("retryTimes")
+                        : RfidConstants.DEFAULT_CONNECT_RETRY_TIMES;
                 handleConnect(retryTimes, result);
                 break;
             case "disconnect":
@@ -82,7 +86,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
             case "stopScan":
                 handleStopScan(result);
                 break;
-            case "setReaderParameter": 
+            case "setReaderParameter":
                 handleSetReaderParameter(call.argument("param"), result);
                 break;
             case "setPower":
@@ -96,11 +100,13 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
                 handleGetPower(result);
                 break;
             case "setScanIdleTimeout":
-                long timeoutMs = call.argument("timeoutMs") != null ? call.argument("timeoutMs") : RfidConstants.SCAN_IDLE_TIMEOUT_MS;
+                long timeoutMs = call.argument("timeoutMs") != null ? call.argument("timeoutMs")
+                        : RfidConstants.SCAN_IDLE_TIMEOUT_MS;
                 handleSetScanIdleTimeout(timeoutMs, result);
                 break;
             case "setConnectRetryTimes":
-                int retry = call.argument("retryTimes") != null ? call.argument("retryTimes") : RfidConstants.DEFAULT_CONNECT_RETRY_TIMES;
+                int retry = call.argument("retryTimes") != null ? call.argument("retryTimes")
+                        : RfidConstants.DEFAULT_CONNECT_RETRY_TIMES;
                 handleSetConnectRetryTimes(retry, result);
                 break;
             case "setMultipleTag":
@@ -114,7 +120,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
         }
     }
 
-     /**
+    /**
      * 处理绑定服务请求
      */
     private void bindRfidService() {
@@ -141,17 +147,17 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
     }
 
     // /**
-    //  * 处理解绑服务请求
-    //  */
+    // * 处理解绑服务请求
+    // */
     // private void handleUnbindService(Result result) {
-    //     try {
-    //         rfidManager.unbindService();
-    //         result.success(null);
-    //         Log.d(TAG, "RFID服务解绑请求已处理");
-    //     } catch (Exception e) {
-    //         Log.e(TAG, "解绑服务失败", e);
-    //         result.error("UNBIND_FAILED", "解绑RFID服务失败: " + e.getMessage(), null);
-    //     }
+    // try {
+    // rfidManager.unbindService();
+    // result.success(null);
+    // Log.d(TAG, "RFID服务解绑请求已处理");
+    // } catch (Exception e) {
+    // Log.e(TAG, "解绑服务失败", e);
+    // result.error("UNBIND_FAILED", "解绑RFID服务失败: " + e.getMessage(), null);
+    // }
     // }
 
     /**
@@ -186,7 +192,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
     /**
      * 处理开始扫描请求
      */
-    private void handleStartScan(Result result,boolean isMultipleTag) {
+    private void handleStartScan(Result result, boolean isMultipleTag) {
         try {
             boolean success = rfidManager.startScan(isMultipleTag);
             result.success(success);
@@ -226,7 +232,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
         }
     }
 
-    private void handleSetMultipleTag(boolean multipleTag, Result result){
+    private void handleSetMultipleTag(boolean multipleTag, Result result) {
         try {
             rfidManager.setMultipleTag(multipleTag);
             result.success(null);
@@ -250,7 +256,35 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
             result.error("SET_POWER_FAILED", "设置功率失败: " + e.getMessage(), null);
         }
     }
-    
+
+    /**
+     * 处理获取功率请求
+     */
+    private void handleGetPower(Result result) {
+        try {
+            int power = rfidManager.getPower();
+            result.success(power);
+            Log.d(TAG, "获取功率成功: " + power);
+        } catch (Exception e) {
+            Log.e(TAG, "获取功率失败", e);
+            result.error("GET_POWER_FAILED", "获取功率失败: " + e.getMessage(), null);
+        }
+    }
+
+    /**
+     * 处理检查连接状态请求
+     */
+    private void handleIsConnected(Result result) {
+        try {
+            boolean isConnected = rfidManager.isConnected();
+            result.success(isConnected);
+            Log.d(TAG, "检查连接状态成功: " + isConnected);
+        } catch (Exception e) {
+            Log.e(TAG, "检查连接状态失败", e);
+            result.error("CHECK_CONNECTED_FAILED", "检查连接状态失败: " + e.getMessage(), null);
+        }
+    }
+
     /**
      * 处理获取阅读器参数请求
      */
@@ -278,20 +312,6 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
         }
     }
 
-    /**
-     * 处理获取功率请求
-     */
-    private void handleGetPower(Result result) {
-        try {
-            int power = rfidManager.getPower();
-            result.success(power);
-            Log.d(TAG, "获取功率成功: " + power);
-        } catch (Exception e) {
-            Log.e(TAG, "获取功率失败", e);
-            result.error("GET_POWER_FAILED", "获取功率失败: " + e.getMessage(), null);
-        }
-    }
-
     /**
      * 处理设置扫描空闲超时请求
      */
@@ -306,7 +326,6 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
         }
     }
 
-
     /**
      * 处理设置连接重试次数请求
      */
@@ -345,13 +364,13 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
     public void onTagScanned(List<InventoryTagMap> tags) {
         // 转换标签数据为Flutter可解析的格式
         List<RfidModel> rfidModelList = RfidModel.fromInventoryTagMapList(tags);
-        
+
         // 将RfidModel列表转换为Map列表以便Flutter可以解析
         List<Map<String, Object>> rfidMapList = new ArrayList<>();
         for (RfidModel model : rfidModelList) {
             rfidMapList.add(model.toMap());
         }
-        
+
         Log.d(RfidConstants.TAG, "通知扫描结果：" + rfidModelList);
         sendEvent(RfidEventType.TAG_SCANNED.ordinal(), rfidMapList, null);
     }
@@ -360,6 +379,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
     public void onScanError(String error) {
         sendEvent(RfidEventType.SCAN_ERROR.ordinal(), null, error);
     }
+
     @Override
     public void onScanInfo(String info) {
         sendEvent(RfidEventType.SCAN_INFO.ordinal(), null, info);
@@ -370,7 +390,7 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
         if (keyCode == 619) {
             // 向Flutter发送按键619事件
             sendEvent(RfidEventType.KEY_PRESS.ordinal(), "KEY_619", null);
-        } 
+        }
     }
 
     // -------------------------- EventChannel实现 --------------------------
@@ -401,9 +421,9 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
             if (data != null) {
                 event.put("data", data);
             }
-            if(type == RfidEventType.SCAN_ERROR.ordinal() ){
+            if (type == RfidEventType.SCAN_ERROR.ordinal()) {
                 event.put("error", error);
-            }else if(type == RfidEventType.SCAN_INFO.ordinal() ){
+            } else if (type == RfidEventType.SCAN_INFO.ordinal()) {
                 event.put("info", error);
             }
             eventSink.success(event);
@@ -427,11 +447,11 @@ public class RfidMethodCallHandler implements MethodCallHandler, RfidListener, E
      */
     private enum RfidEventType {
         CONNECT_SUCCESS, // 0 - 连接成功
-        CONNECT_FAILED,  // 1 - 连接失败
-        DISCONNECTED,   // 2 - 断开连接
-        TAG_SCANNED,     // 3 - 扫描到标签
-        SCAN_INFO,       // 4 - 扫描信息
-        KEY_PRESS,       // 5 - 按键事件
-        SCAN_ERROR       // 6 - 扫描错误
+        CONNECT_FAILED, // 1 - 连接失败
+        DISCONNECTED, // 2 - 断开连接
+        TAG_SCANNED, // 3 - 扫描到标签
+        SCAN_INFO, // 4 - 扫描信息
+        KEY_PRESS, // 5 - 按键事件
+        SCAN_ERROR // 6 - 扫描错误
     }
 }

UI/CF.APP/chicken_farm/android/app/src/main/java/com/vber/chicken_farm/rfid/RfidService.java

@@ -32,12 +32,13 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.logging.LogManager;
 
 /**
  * RFID核心服务（后台运行，提供API给外部调用）
  * 功能特性：
- * 1. 息屏/亮屏自动暂停/恢复扫描
- * 2. 5分钟扫描空闲自动断开连接（可配置）
+ * 1. 息屏/亮屏自动暂停/恢复读取
+ * 2. 5分钟读卡器空闲自动断开连接（可配置）
  * 3. 所有关键参数可配置（重试次数、端口、波特率等）
  * 4. 完善的异常处理和资源管理
  * 5. 线程安全的状态管理
@@ -74,9 +75,9 @@ public class RfidService extends Service {
     public static int ErrorCRC;
     public boolean isMultipleTag = false;
 
-    // 扫描空闲超时处理器
+    // 读卡器空闲超时处理器
     private Handler idleHandler;
-    // 扫描消息处理器（处理扫描结果）
+    // 读卡器消息处理器（处理读卡器结果）
     private Handler msgHandler;
     private Runnable idleDisconnectRunnable;
 
@@ -86,14 +87,14 @@ public class RfidService extends Service {
         public void onReceive(Context context, Intent intent) {
             String action = intent.getAction();
             if (Intent.ACTION_SCREEN_ON.equals(action)) {
-                // 屏幕亮屏 - 恢复扫描（如果之前正在扫描）
+                // 屏幕亮屏 - 恢复读卡（如果之前正在读卡）
                 isScreenOn = true;
-                Log.d(RfidConstants.TAG, "屏幕亮屏，尝试恢复RFID扫描");
+                Log.d(RfidConstants.TAG, "RFID屏幕亮屏，尝试恢复读卡");
                 resumeScanAfterScreenOn();
             } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
-                // 屏幕息屏 - 暂停扫描（保留连接）
+                // 屏幕息屏 - 暂停读卡（保留连接）
                 isScreenOn = false;
-                Log.d(RfidConstants.TAG, "屏幕息屏，暂停RFID扫描");
+                Log.d(RfidConstants.TAG, "RFID屏幕息屏，暂停读卡");
                 pauseScanOnScreenOff();
             }
         }
@@ -102,18 +103,28 @@ public class RfidService extends Service {
     @Override
     public void onCreate() {
         super.onCreate();
-        Log.d(RfidConstants.TAG, "RfidService created");
-        initWakeLock();
-        initIdleHandler(); // 初始化空闲超时处理器
-        executorService = Executors.newSingleThreadExecutor();
-        initReader();
-        initMsgHandler();
-        initSound();
-        registerScreenStateReceiver(); // 注册屏幕状态监听
+
+    }
+
+    public boolean init() {
+        try {
+            Log.d(RfidConstants.TAG, "RfidService created");
+            initWakeLock();
+            initIdleHandler(); // 初始化空闲超时处理器
+            executorService = Executors.newSingleThreadExecutor();
+            initReader();
+            initMsgHandler();
+            initSound();
+            registerScreenStateReceiver(); // 注册屏幕状态监听
+            return true;
+        } catch (Exception e) {
+            Log.e(RfidConstants.TAG, "读卡器初始化失败", e);
+            return false;
+        }
     }
 
     /**
-     * 初始化扫描空闲超时处理器
+     * 初始化读卡器空闲超时处理器
      */
     private void initIdleHandler() {
         // 创建后台HandlerThread避免主线程阻塞
@@ -125,10 +136,10 @@ public class RfidService extends Service {
         // 定义空闲超时断开连接任务
         idleDisconnectRunnable = () -> {
             if (isConnected && !isScanning) {
-                Log.d(RfidConstants.TAG, "扫描空闲超时（" + scanIdleTimeoutMs / 1000 + "秒），自动关闭连接");
+                Log.d(RfidConstants.TAG, "读卡器空闲超时（" + scanIdleTimeoutMs / 1000 + "秒），自动关闭连接");
                 disconnect(); // 自动断开连接
                 if (listener != null) {
-                    listener.onScanInfo("扫描空闲超时，已自动断开连接");
+                    listener.onScanInfo("读卡器空闲超时，已自动断开连接");
                 }
             }
         };
@@ -136,25 +147,25 @@ public class RfidService extends Service {
     }
 
     /**
-     * 重置空闲超时计时器（有扫描操作时调用）
+     * 重置空闲超时计时器（有读卡器操作时调用）
      */
     private void resetIdleTimeout() {
         if (idleHandler != null && idleDisconnectRunnable != null) {
             // 移除之前的任务，重新计时
             idleHandler.removeCallbacks(idleDisconnectRunnable);
             idleHandler.postDelayed(idleDisconnectRunnable, scanIdleTimeoutMs);
-            // Log.d(RfidConstants.TAG, "扫描空闲计时器已重置，超时时间：" + scanIdleTimeoutMs / 1000 +
+            // Log.d(RfidConstants.TAG, "读卡器空闲计时器已重置，超时时间：" + scanIdleTimeoutMs / 1000 +
             // "秒");
         }
     }
 
     /**
-     * 停止空闲超时计时器（断开连接/停止扫描时调用）
+     * 停止空闲超时计时器（断开连接/停止读卡时调用）
      */
     private void stopIdleTimeout() {
         if (idleHandler != null && idleDisconnectRunnable != null) {
             idleHandler.removeCallbacks(idleDisconnectRunnable);
-            Log.d(RfidConstants.TAG, "扫描空闲计时器已停止");
+            Log.d(RfidConstants.TAG, "读卡器空闲计时器已停止");
         }
     }
 
@@ -246,7 +257,7 @@ public class RfidService extends Service {
     }
 
     /**
-     * 息屏时暂停扫描（保留连接）
+     * 息屏时暂停读卡（保留连接）
      */
     private void pauseScanOnScreenOff() {
         if (isScanning) {
@@ -254,12 +265,12 @@ public class RfidService extends Service {
                 try {
                     rrlib.StopRead();
                     isScanning = false;
-                    resetIdleTimeout(); // 暂停扫描后启动空闲计时
-                    Log.d(RfidConstants.TAG, "息屏暂停扫描，保留设备连接");
+                    resetIdleTimeout(); // 暂停读卡后启动空闲计时
+                    Log.d(RfidConstants.TAG, "息屏暂停读卡，保留设备连接");
                 } catch (Exception e) {
-                    Log.e(RfidConstants.TAG, "息屏暂停扫描失败", e);
+                    Log.e(RfidConstants.TAG, "息屏暂停读卡失败", e);
                     if (listener != null) {
-                        listener.onScanError("息屏暂停扫描失败：" + e.getMessage());
+                        listener.onScanError("息屏暂停读卡失败：" + e.getMessage());
                     }
                 }
             });
@@ -267,7 +278,7 @@ public class RfidService extends Service {
     }
 
     /**
-     * 亮屏后恢复扫描（延迟重连避免硬件卡顿）
+     * 亮屏后恢复读卡（延迟重连避免硬件卡顿）
      */
     private void resumeScanAfterScreenOn() {
         if (isConnected && !isScanning) {
@@ -280,18 +291,18 @@ public class RfidService extends Service {
                     if (!isConnected) {
                         connect();
                     }
-                    // stopIdleTimeout(); // 恢复扫描后停止空闲计时
-                    // Log.d(RfidConstants.TAG, "亮屏恢复RFID扫描成功");
+                    // stopIdleTimeout(); // 恢复读卡后停止空闲计时
+                    // Log.d(RfidConstants.TAG, "亮屏恢复RFID读卡成功");
                     // if (listener != null) {
-                    // listener.onTagScanned(rrlib.getInventoryTagMapList()); // 触发一次扫描回调
+                    // listener.onTagScanned(rrlib.getInventoryTagMapList()); // 触发一次读卡回调
                     // }
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
-                    Log.e(RfidConstants.TAG, "恢复扫描线程被中断", e);
+                    Log.e(RfidConstants.TAG, "恢复读卡线程被中断", e);
                 } catch (Exception e) {
-                    Log.e(RfidConstants.TAG, "亮屏恢复扫描失败", e);
+                    Log.e(RfidConstants.TAG, "亮屏恢复读卡失败", e);
                     if (listener != null) {
-                        listener.onScanError("亮屏恢复扫描失败：" + e.getMessage());
+                        listener.onScanError("亮屏恢复读卡失败：" + e.getMessage());
                     }
                 }
             });
@@ -305,7 +316,7 @@ public class RfidService extends Service {
 
     @Override
     public boolean onUnbind(Intent intent) {
-        // 解绑时停止扫描+断开连接
+        // 解绑时停止读卡+断开连接
         stopScan();
         disconnect();
         return super.onUnbind(intent);
@@ -343,7 +354,7 @@ public class RfidService extends Service {
     @Override
     public void onTrimMemory(int level) {
         super.onTrimMemory(level);
-        // UI隐藏/内存紧张时，临时停止扫描
+        // UI隐藏/内存紧张时，临时停止读卡
         if (level >= TRIM_MEMORY_UI_HIDDEN && isScanning) {
             Log.d(RfidConstants.TAG, "UI hidden, stopping scan temporarily");
             pauseScanOnScreenOff(); // 复用息屏暂停逻辑
@@ -394,17 +405,17 @@ public class RfidService extends Service {
     }
 
     /**
-     * 设置息屏恢复扫描延迟
+     * 设置息屏恢复读卡延迟
      */
     public void setScanReconnectDelayMs(long delayMs) {
         if (delayMs >= 0) {
             this.scanReconnectDelayMs = delayMs;
-            Log.d(RfidConstants.TAG, "息屏恢复扫描延迟已设置为：" + delayMs + "ms");
+            Log.d(RfidConstants.TAG, "息屏恢复读卡延迟已设置为：" + delayMs + "ms");
         }
     }
 
     /**
-     * 设置扫描空闲超时时间（毫秒）
+     * 设置读卡空闲超时时间（毫秒）
      */
     public void setScanIdleTimeoutMs(long timeoutMs) {
         if (timeoutMs > 0) {
@@ -414,7 +425,7 @@ public class RfidService extends Service {
                 idleHandler.removeCallbacks(idleDisconnectRunnable);
                 idleHandler.postDelayed(idleDisconnectRunnable, scanIdleTimeoutMs);
             }
-            Log.d(RfidConstants.TAG, "扫描空闲超时时间已设置为：" + timeoutMs / 1000 + "秒");
+            Log.d(RfidConstants.TAG, "读卡空闲超时时间已设置为：" + timeoutMs / 1000 + "秒");
         } else {
             Log.w(RfidConstants.TAG, "空闲超时时间必须大于0，使用默认值：" + scanIdleTimeoutMs / 1000 + "秒");
         }
@@ -555,19 +566,19 @@ public class RfidService extends Service {
     }
 
     public boolean startScan(boolean multipleTag) {
-        Log.d(RfidConstants.TAG, "=====>RFID设备开始扫描");
+        Log.d(RfidConstants.TAG, "=====>RFID设备开始读卡");
         if (!isConnected) {
             connect();
         }
         if (!isConnected) {
-            Log.e(RfidConstants.TAG, "RFID设备未连接，无法开始扫描");
+            Log.e(RfidConstants.TAG, "RFID设备未连接，无法开始读卡");
             if (listener != null) {
-                listener.onScanError("设备未连接，扫描失败");
+                listener.onScanError("设备未连接，读卡失败");
             }
             return false;
         }
         if (isScanning) {
-            Log.w(RfidConstants.TAG, "RFID正在扫描中，无需重复启动");
+            Log.w(RfidConstants.TAG, "RFID正在读卡中，无需重复启动");
             stopIdleTimeout(); // 重复启动也重置计时
             return true;
         }
@@ -576,27 +587,27 @@ public class RfidService extends Service {
             setReaderParameter(null);
             setPower();
         }
-        Log.d(RfidConstants.TAG, "RFID设备扫描,功率：" + getPower() + "W");
+        Log.d(RfidConstants.TAG, "RFID设备读卡,功率：" + getPower() + "W");
         return _startScan();
     }
 
     /**
-     * 开始扫描标签
+     * 开始读卡标签
      */
     private boolean _startScan() {
         isScanning = true;
         acquireWakeLock(); // 息屏保持唤醒
-        stopIdleTimeout(); // 开始扫描，停止空闲计时
+        stopIdleTimeout(); // 开始读卡，停止空闲计时
         try {
             // 清空历史标签数据
             rrlib.getInventoryTagMapList().clear();
             rrlib.getInventoryTagResultList().clear();
             MsgCallback callback = new MsgCallback();
-            // 设置扫描回调
+            // 设置读卡回调
             rrlib.SetCallBack(callback);
             ErrorCount = 0;
             ErrorCRC = 0;
-            // 启动扫描
+            // 启动读卡器
             int result = rrlib.StartRead();
             if (result != 0) {
                 // throw new Exception("未能识别到电子标签！");
@@ -606,25 +617,25 @@ public class RfidService extends Service {
                 }
                 return false;
             }
-            Log.d(RfidConstants.TAG, "RFID扫描已启动");
-            // 1 秒后停止扫描
+            Log.d(RfidConstants.TAG, "RFID读卡已启动");
+            // 1 秒后停止读卡
             idleHandler.postDelayed(() -> {
-                Log.d(RfidConstants.TAG, "1秒RFID扫描自动停止");
+                Log.d(RfidConstants.TAG, "1秒RFID读卡自动停止");
                 if (isScanning) {
                     stopScan();
                     if (listener != null
                             && (!isMultipleTag || isMultipleTag && rrlib.getInventoryTagMapList().size() == 0)) {
-                        listener.onScanError("未扫描到电子编号");
+                        listener.onScanError("未读卡到电子编号");
                     }
                 }
             }, 1 * 1000);
         } catch (Exception e) {
-            Log.e(RfidConstants.TAG, "扫描失败：", e);
+            Log.e(RfidConstants.TAG, "读卡失败：", e);
             isScanning = false;
             releaseWakeLock();
             resetIdleTimeout(); // 启动失败，启动空闲计时
             if (listener != null) {
-                listener.onScanError("扫描失败：" + e.getMessage());
+                listener.onScanError("读卡失败：" + e.getMessage());
             }
         }
 
@@ -632,23 +643,23 @@ public class RfidService extends Service {
     }
 
     /**
-     * 停止扫描标签
+     * 停止读卡标签
      */
     public void stopScan() {
         if (!isScanning) {
-            // Log.w(RfidConstants.TAG, "RFID未在扫描中，无需停止");
+            // Log.w(RfidConstants.TAG, "RFID未在读卡中，无需停止");
             return;
         }
         try {
             rrlib.StopRead();
             isScanning = false;
             releaseWakeLock(); // 释放唤醒锁
-            resetIdleTimeout(); // 停止扫描，启动空闲计时
-            Log.d(RfidConstants.TAG, "RFID扫描已停止");
+            resetIdleTimeout(); // 停止读卡，启动空闲计时
+            Log.d(RfidConstants.TAG, "RFID读卡已停止");
         } catch (Exception e) {
             Log.e(RfidConstants.TAG, "Stop scan error", e);
             if (listener != null) {
-                listener.onScanError("停止扫描失败：" + e.getMessage());
+                listener.onScanError("停止读卡失败：" + e.getMessage());
             }
         }
     }
@@ -778,10 +789,10 @@ public class RfidService extends Service {
     private void setPower() {
         if (isMultipleTag) {
             setPower(RfidConstants.POWER_HIGH);
-            Log.d(RfidConstants.TAG, "RFID设备启动多标签扫描,功率：" + getPower() + "W");
+            Log.d(RfidConstants.TAG, "RFID设备启动多标签读卡,功率：" + getPower() + "W");
         } else {
             setPower(RfidConstants.POWER_LOW);
-            Log.d(RfidConstants.TAG, "RFID设备启动单标签扫描,功率：" + getPower() + "W");
+            Log.d(RfidConstants.TAG, "RFID设备启动单标签读卡,功率：" + getPower() + "W");
         }
     }
 
@@ -886,7 +897,7 @@ public class RfidService extends Service {
             }
             ErrorCount += 1;
 
-            // 触发扫描错误回调
+            // 触发读卡错误回调
             if (listener != null) {
                 listener.onScanError("CRC错误: reason=" + reason + ", 错误数=" + ErrorCount);
             }
@@ -895,11 +906,11 @@ public class RfidService extends Service {
 
         @Override
         public void FinishCallBack() {
-            // 停止扫描并启动空闲计时
+            // 停止读卡并启动空闲计时
             isScanning = false;
             resetIdleTimeout();
             if (listener != null) {
-                listener.onScanInfo("扫描已完成");
+                listener.onScanInfo("读卡已完成");
             }
         }
 

UI/CF.APP/chicken_farm/lib/components/vb_electronic_id_field.dart

@@ -43,26 +43,26 @@ class VberElectronicIdsField extends StatefulWidget {
 }
 
 class _VberElectronicIdsFieldState extends State<VberElectronicIdsField> {
-  late final RfidManager _rfidManager;
   bool _isScanning = false; // 内部管理识别状态
   bool _isMultiple = false; // 内部管理识别状态
 
   @override
   void initState() {
     super.initState();
-    _rfidManager = RfidManager(
+    logger.d('初始化RFID识别组件==>');
+    RfidManager.instance.registerCallbacks(
       onTagScanned: _handleRfidsScanned,
       onRFIDScanned: _handleRfidScanned,
       onKeyPress: _handleKeyPress,
       onErrorScanned: _handleScanError,
     );
     _isMultiple = widget.multipleScan ?? widget.multiple;
-    _rfidManager.initRfid();
   }
 
   @override
   void dispose() {
-    _rfidManager.disposeRfid();
+    logger.d('释放RFID识别组件==>');
+    RfidManager.instance.disposeRfid();
     super.dispose();
   }
 
@@ -103,8 +103,8 @@ class _VberElectronicIdsFieldState extends State<VberElectronicIdsField> {
     setState(() {
       _isScanning = true;
     });
-    ToastUtil.info('开始识别电子编号');
-    _rfidManager.startScan(isMultiple: _isMultiple);
+    ToastUtil.show('开始识别电子编号', duration: 1);
+    RfidManager.instance.startScan(isMultiple: _isMultiple);
   }
 
   @override

UI/CF.APP/chicken_farm/lib/core/services/pda/rfid_channel.dart

@@ -8,12 +8,12 @@ class RfidChannel {
   );
 
   /// 绑定RFID服务
-  static Future<bool> bindService() async {
+  static Future<bool> init() async {
     try {
-      final bool result = await _channel.invokeMethod('bindService');
+      final bool result = await _channel.invokeMethod('init');
       return result;
     } on PlatformException catch (e) {
-      logger.e('绑定RFID服务失败: ${e.message}');
+      logger.e('RFID读卡器初始化失败: ${e.message}');
       return false;
     }
   }
@@ -50,6 +50,17 @@ class RfidChannel {
     }
   }
 
+  /// 检查RFID设备是否已连接
+  static Future<bool> isConnected() async {
+    try {
+      final bool result = await _channel.invokeMethod('isConnected');
+      return result;
+    } on PlatformException catch (e) {
+      logger.e('检查RFID设备连接状态失败: ${e.message}');
+      return false;
+    }
+  }
+
   /// 开始扫描标签
   static Future<bool> startScan(bool isMultiple) async {
     try {
@@ -125,9 +136,14 @@ class RfidChannel {
 
   /// 监听RFID回调事件
   static Stream<RfidEvent> get rfidEvents {
-    return _eventChannel.receiveBroadcastStream().map((dynamic event) {
-      return RfidEvent.fromMap(event);
-    });
+    try {
+      return _eventChannel.receiveBroadcastStream().map((dynamic event) {
+        return RfidEvent.fromMap(event);
+      });
+    } catch (e) {
+      logger.e('监听RFID回调事件失败: ${e.toString()}');
+      return Stream<RfidEvent>.empty();
+    }
   }
 
   static const EventChannel _eventChannel = EventChannel(

UI/CF.APP/chicken_farm/lib/core/services/pda/rfid_manager.dart

@@ -1,100 +1,203 @@
+import 'package:chicken_farm/core/config/app_config.dart';
 import 'package:chicken_farm/core/utils/logger.dart';
 import 'package:chicken_farm/core/utils/toast.dart';
 import 'package:chicken_farm/modes/rfid/rfid_model.dart';
 import 'rfid_channel.dart';
+import 'dart:async';
 
-// 定义处理扫描到的标签数据的回调函数类型
 typedef TagScannedCallback = void Function(List<RfidModel> tags);
 typedef RFIDScannedCallback = void Function(String rfId);
 typedef ScannedErrorCallback = void Function(String error);
 typedef ScannOnKeyPress = void Function(String error);
 
-/// RFID 工具类（纯逻辑调用）
+/// RFID 工具类 (单例模式)
 class RfidManager {
-  static bool isConnect = false;
+  // 单例实例
+  static final RfidManager _instance = RfidManager._internal();
+
+  factory RfidManager() {
+    _instance.init();
+    return _instance;
+  }
+
+  int errorCount = 0;
   // 存储标签扫描回调函数
-  final TagScannedCallback? _onTagScanned;
-  final RFIDScannedCallback? _onRFIDScanned;
-  final ScannedErrorCallback? _onErrorScanned;
-  final ScannOnKeyPress? _onKeyPress;
+  TagScannedCallback? _onTagScanned;
+  RFIDScannedCallback? _onRFIDScanned;
+  ScannedErrorCallback? _onErrorScanned;
+  ScannOnKeyPress? _onKeyPress;
+
+  // 连接状态检查相关
+  Timer? _connectionCheckTimer;
+  bool _isConnecting = false;
+
+  // 初始化状态标志
+  bool _isInitialized = false;
+
+  // 私有构造函数
+  RfidManager._internal();
+
+  // 获取单例实例
+  static RfidManager get instance => RfidManager();
+
+  // 事件监听和初始化
+  Future<void> init() async {
+    if (_isInitialized || !AppConfig.isPda) {
+      return;
+    }
+    _isInitialized = true;
+    errorCount = 0;
+    try {
+      Timer.run(() async {
+        await RfidChannel.init();
+        //  监听RFID事件
+        RfidChannel.rfidEvents.listen((RfidEvent event) {
+          switch (event.type) {
+            case RfidEventType.connectSuccess:
+              errorCount = 0;
+              _stopConnectionChecking();
+              ToastUtil.success("电子编号读卡器连接成功");
+              logger.i("✅ 设备连接成功: ${event.data}");
+              break;
+            case RfidEventType.connectFailed:
+              _stopConnectionChecking();
+              errorCount++;
+              if (errorCount <= 3) {
+                ToastUtil.errorAlert(
+                  "读卡器连接失败，关闭其他应用后，点击确认按钮再尝试连接。",
+                  onConfirm: () async {
+                    await RfidChannel.disconnect();
+                    await connect();
+                  },
+                );
+              } else {
+                ToastUtil.errorAlert("读卡器连接失败!!!");
+              }
+              logger.e("❌ 设备连接失败[$errorCount]: ${event.error}");
+              break;
+            case RfidEventType.tagScanned:
+              logger.i("📶 扫描到标签: ${event.data}");
+              _handleScannedTags(event.data);
+              break;
+            case RfidEventType.scanError:
+              logger.e("❌ 扫描错误: ${event.error}");
+              // ToastUtil.error("扫描出错");
+              _onErrorScanned?.call(event.error ?? "未知错误");
+              break;
+            case RfidEventType.scanInfo:
+              logger.i("❌ 扫描信息: ${event.info}");
+              // if (event.info != null) {
+              //   ToastUtil.info("${event.info}");
+              // }
+              break;
+            case RfidEventType.disconnected:
+              logger.i("🔌 设备已断开连接");
+              break;
+            case RfidEventType.onKeyPress: // 处理按键事件
+              _onKeyPress?.call(event.data);
+              break;
+          }
+        });
+
+        Future.delayed(Duration(microseconds: 500), () async {
+          await connect();
+        });
+      });
+    } catch (e) {
+      logger.e("❌ RFID初始化错误: $e");
+    }
+  }
 
-  RfidManager({
+  // 注册回调函数
+  void registerCallbacks({
     TagScannedCallback? onTagScanned,
     RFIDScannedCallback? onRFIDScanned,
     ScannedErrorCallback? onErrorScanned,
     ScannOnKeyPress? onKeyPress,
-  }) : _onTagScanned = onTagScanned,
-       _onRFIDScanned = onRFIDScanned,
-       _onErrorScanned = onErrorScanned,
-       _onKeyPress = onKeyPress;
-  // 事件监听
-  void initRfid() async {
-    // // 1. 绑定服务
-    // final bool isBound = await RfidChannel.bindService();
-    // if (!isBound) {
-    //   logger.d("❌ RFID服务绑定失败");
-    //   return;
-    // }
-    // logger.i("✅ RFID服务绑定成功");
-
-    // 2. 设置配置项
-    // await RfidChannel.setConnectRetryTimes(5); // 连接重试5次
-    // await RfidChannel.setScanIdleTimeout(5 * 60 * 1000); // 5分钟空闲超时
-    if (!isConnect) {
-      ToastUtil.show("读卡器正在连接中...", duration: 10);
+  }) {
+    _onTagScanned = onTagScanned;
+    _onRFIDScanned = onRFIDScanned;
+    _onErrorScanned = onErrorScanned;
+    _onKeyPress = onKeyPress;
+  }
+
+  void clearCallbacks() {
+    _onTagScanned = null;
+    _onRFIDScanned = null;
+    _onErrorScanned = null;
+    _onKeyPress = null;
+  }
+
+  Future<void> connect() async {
+    if (!(await RfidChannel.isConnected())) {
+      _startConnectionChecking();
     }
+    // 在新线程中执行初始化
+    Timer.run(() async {
+      await RfidChannel.connect(retryTimes: 2);
+    });
+  }
 
-    // 3. 监听RFID事件
-    RfidChannel.rfidEvents.listen((RfidEvent event) {
-      switch (event.type) {
-        case RfidEventType.connectSuccess:
-          ToastUtil.success("电子编号读卡器连接成功");
-          isConnect = true;
-          logger.i("✅ 设备连接成功: ${event.data}");
-          break;
-        case RfidEventType.connectFailed:
-          isConnect = false;
-          ToastUtil.errorAlert("电子编号读卡器连接失败");
-          logger.e("❌ 设备连接失败: ${event.error}");
-          break;
-        case RfidEventType.tagScanned:
-          logger.i("📶 扫描到标签: ${event.data}");
-          _handleScannedTags(event.data);
-          break;
-        case RfidEventType.scanError:
-          logger.e("❌ 扫描错误: ${event.error}");
-          // ToastUtil.error("扫描出错");
-          _onErrorScanned?.call(event.error ?? "未知错误");
-          break;
-        case RfidEventType.scanInfo:
-          logger.i("❌ 扫描信息: ${event.info}");
-          // if (event.info != null) {
-          //   ToastUtil.info("${event.info}");
-          // }
-          break;
-        case RfidEventType.disconnected:
-          isConnect = false;
-          logger.i("🔌 设备已断开连接");
-          break;
-        case RfidEventType.onKeyPress: // 处理按键事件
-          if (_onKeyPress != null) {
-            _onKeyPress(event.data);
-          } else {
-            logger.d("前端扫码按键：${event.data}");
-            if (event.data == 'KEY_619') {
-              startScan();
-            }
-          }
-          break;
+  /// 开始连接状态检查
+  void _startConnectionChecking() {
+    if (_isConnecting) return;
+
+    _isConnecting = true;
+    ToastUtil.show("读卡器正在连接中...", duration: 0); // duration为0表示不自动消失
+
+    _connectionCheckTimer?.cancel();
+    _connectionCheckTimer = Timer.periodic(Duration(seconds: 1), (_) async {
+      bool isConnected = await RfidChannel.isConnected();
+      if (isConnected) {
+        _stopConnectionChecking();
       }
     });
+  }
+
+  /// 停止连接状态检查
+  void _stopConnectionChecking() {
+    _isConnecting = false;
+    _connectionCheckTimer?.cancel();
+    _connectionCheckTimer = null;
+    // 清除连接提示
+    ToastUtil.clear(); // 使用ToastUtil中的清除方法
+  }
+
+  /// 检查连接状态，如果未连接则尝试重新连接
+  Future<bool> _ensureConnected() async {
+    bool isConnected = await RfidChannel.isConnected();
+    if (!isConnected) {
+      ToastUtil.show("读卡器未连接，正在重新连接...", duration: 5);
+      logger.i("🔁 尝试重新连接RFID读卡器");
 
-    // 4. 连接设备
-    await RfidChannel.connect(retryTimes: 3);
+      try {
+        final bool connected = await RfidChannel.connect(retryTimes: 3);
+        // if (connected) {
+        //   ToastUtil.success("读卡器连接成功");
+        //   logger.i("✅ RFID读卡器重新连接成功");
+        // } else {
+        //   ToastUtil.errorAlert("读卡器连接失败，关闭其他应用后，点击确认按钮再尝试连接。",on);
+        //   logger.e("❌ RFID读卡器重新连接失败");
+        // }
+        return connected;
+      } catch (e) {
+        ToastUtil.errorAlert("读卡器连接异常");
+        logger.e("❌ RFID读卡器连接异常: $e");
+        return false;
+      }
+    }
+    return true;
   }
 
   /// 开始扫描
   Future<void> startScan({bool isMultiple = false}) async {
+    // 检查连接状态
+    final bool isConnected = await _ensureConnected();
+    if (!isConnected) {
+      logger.e("❌ 无法启动扫描，读卡器未连接");
+      return;
+    }
+
     final bool isStarted = await RfidChannel.startScan(isMultiple);
     if (isStarted) {
       logger.i("▶️ 扫描已启动");
@@ -111,6 +214,8 @@ class RfidManager {
 
   /// 断开连接并解绑服务
   Future<void> disposeRfid() async {
+    _stopConnectionChecking();
+    clearCallbacks();
     await RfidChannel.stopScan();
     // await RfidChannel.disconnect();
     logger.i("🔚 RFID资源已释放");

UI/CF.APP/chicken_farm/lib/core/utils/toast.dart

@@ -32,6 +32,7 @@ class ToastUtil {
     Color? textColor = Colors.white,
     double? fontSize = 16.0,
   }) {
+    clear();
     final BuildContext? context = NavigationService.navigatorKey.currentContext;
     if (context == null) return;
     try {
@@ -89,6 +90,19 @@ class ToastUtil {
     }
   }
 
+  /// 清除所有Snackbar提示
+  static void clear() {
+    final BuildContext? context = NavigationService.navigatorKey.currentContext;
+    if (context == null) return;
+    try {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        ScaffoldMessenger.of(context).clearSnackBars();
+      });
+    } catch (e) {
+      logger.e("清除弹窗出错：", e);
+    }
+  }
+
   /// 计算center位置的margin
   static EdgeInsetsGeometry _calculateCenterMargin(
     String message,

UI/CF.APP/chicken_farm/lib/main.dart

@@ -1,4 +1,5 @@
 import 'package:chicken_farm/core/db/sqlite_manager.dart';
+import 'package:chicken_farm/core/services/pda/rfid_manager.dart';
 import 'package:chicken_farm/vb_app.dart';
 import 'package:chicken_farm/core/config/app_config.dart';
 import 'package:chicken_farm/core/utils/loading.dart';
@@ -10,6 +11,9 @@ void main() async {
   await AppConfig.init(); // 初始化配置
 
   await SqliteManager().init(dbName: 'breeding.db');
+  if (AppConfig.isPda) {
+    await RfidManager.instance.init();
+  }
 
   final container = ProviderContainer();
   // 初始化LoadingUtil

UI/CF.APP/chicken_farm/lib/pages/home/_profile/upload_data_button.dart

@@ -48,7 +48,7 @@ class _UploadDataButtonState extends State<UploadDataButton> {
       future: BreedingDataService().queryTotalCount(),
       builder: (context, snapshot) {
         final count = snapshot.data ?? 0;
-        logger.d('带上传数据数量: $count');
+        // logger.d('待上传数据数量: $count');
         // 数据加载成功时显示正常的上传按钮
         return SizedBox(
           width: double.infinity,