refactor(更新) :

- 设备关机状态下的蓝牙连接方式修改

app/src/main/java/com/grkj/iscs/BusinessManager.kt

@@ -78,6 +78,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
+import org.slf4j.LoggerFactory
 import kotlin.coroutines.resume
 
 /**
@@ -873,8 +874,14 @@ object BusinessManager {
     /**
      * 注册连接监听
      */
-    fun registerConnectListener(mac: String, callBack: ((Boolean, BleBean?) -> Unit)? = null) {
-        BleConnectionManager.registerConnectListener(mac, callBack)
+    fun registerConnectListener(
+        mac: String,
+        connectNow: Boolean = false,
+        callBack: ((
+            Boolean, BleBean?
+        ) -> Unit)? = null
+    ) {
+        BleConnectionManager.registerConnectListener(mac, connectNow, callBack)
     }
 
     /**
@@ -909,7 +916,7 @@ object BusinessManager {
         activity: AppCompatActivity,
         isNeedLoading: Boolean = false,
     ) {
-        registerConnectListener(mac) { isDone, bleBean ->
+        registerConnectListener(mac, true) { isDone, bleBean ->
             if (!isDone) {
                 sendTicketBusiness(isLock, mac, ticketDetail, lockList, activity, isNeedLoading)
                 return@registerConnectListener
@@ -962,7 +969,7 @@ object BusinessManager {
     private fun getTicketStatusBusiness(
         mac: String, isNeedLoading: Boolean = false
     ) {
-        registerConnectListener(mac) { isDone, bleBean ->
+        registerConnectListener(mac, true) { isDone, bleBean ->
             if (isDone) {
                 Executor.delayOnMain(500) {
                     getTicketStatusWithRetry(bleBean!!.bleDevice, isNeedLoading)
@@ -1358,21 +1365,23 @@ object BusinessManager {
             val workTicketGetBO = Gson().fromJson(ticketJson, WorkTicketGetBO::class.java)
 
             // 判断workTicketGetBO里是否有未完成的
-            if (workTicketGetBO.hasFinished()) {
-                Executor.delayOnMain(500) {
-                    handleKeyReturn(bleDevice, workTicketGetBO)
-                }
-            } else {
-                // 当前策略：作业票未完成禁止归还钥匙
-                showKeyReturnDialog {
-                    sendLoadingEventMsg(null, false)
-                    ToastUtils.tip(R.string.continue_the_ticket)
-                    BleManager.getInstance().disconnect(bleDevice)
-                    // 打开卡扣，防止初始化的时候选择不处理钥匙导致无法使用
-                    val dock = ModBusController.getDockByKeyMac(bleDevice.mac)
-                    val keyBean = dock?.getKeyList()?.find { it.mac == bleDevice.mac }
-                    keyBean?.let {
-                        ModBusController.controlKeyBuckle(true, keyBean.isLeft, dock.addr)
+            ThreadUtils.runOnIO {
+                if (workTicketGetBO.hasFinished()) {
+                    Executor.delayOnMain(500) {
+                        handleKeyReturn(bleDevice, workTicketGetBO)
+                    }
+                } else {
+                    // 当前策略：作业票未完成禁止归还钥匙
+                    showKeyReturnDialog {
+                        sendLoadingEventMsg(null, false)
+                        ToastUtils.tip(R.string.continue_the_ticket)
+                        BleManager.getInstance().disconnect(bleDevice)
+                        // 打开卡扣，防止初始化的时候选择不处理钥匙导致无法使用
+                        val dock = ModBusController.getDockByKeyMac(bleDevice.mac)
+                        val keyBean = dock?.getKeyList()?.find { it.mac == bleDevice.mac }
+                        keyBean?.let {
+                            ModBusController.controlKeyBuckle(true, keyBean.isLeft, dock.addr)
+                        }
                     }
                 }
             }

app/src/main/java/com/grkj/iscs/ble/BleConnectionManager.kt

@@ -27,6 +27,7 @@ import com.grkj.iscs.util.log.LogUtil
 import com.grkj.iscs.view.base.BaseActivity
 import com.sik.sikcore.activity.ActivityTracker
 import com.sik.sikcore.thread.ThreadUtils
+import kotlinx.coroutines.delay
 import pub.devrel.easypermissions.AfterPermissionGranted
 import java.util.LinkedList
 
@@ -62,28 +63,42 @@ object BleConnectionManager {
      * - 如果 mac 已在待连接队列或正在连接，忽略重复请求
      * - 否则将 mac 添加到队列并触发连接流程
      */
-    fun registerConnectListener(mac: String, callBack: ((Boolean, BleBean?) -> Unit)? = null) {
+    fun registerConnectListener(
+        mac: String,
+        connectNow: Boolean = false,
+        callBack: ((Boolean, BleBean?) -> Unit)? = null
+    ) {
         LogUtil.i("蓝牙连接-开始连接 : $mac")
         // 已连接且已获取 token
         deviceList.find {
             it.bleDevice.mac == mac && BleManager.getInstance().isConnected(mac) && it.token != null
         }?.let { bean ->
+            LogUtil.i("蓝牙连接-设备已连接")
             callBack?.invoke(true, bean)
             return
         }
+        if (connectNow) {
+            unregisterConnectListener(mac)
+        }
         // 重复注册检查
         if (connectListeners.any { it.mac == mac } || currentConnectingMac == mac) {
             LogUtil.w("蓝牙连接-忽略重复注册 mac: $mac")
             return
         }
         // 加入队列并启动连接
-        fun checkAndConnect() {
+        fun checkAndConnect(isDisconnectAll: Boolean = false) {
             if (BleManager.getInstance().allConnectedDevice.size < maxConnectCount) {
                 connectListeners.add(ConnectListener(mac, callBack))
                 connectKey()
             } else {
-                ThreadUtils.runOnIODelayed(500) {
-                    checkAndConnect()
+                if (connectNow && !isDisconnectAll) {
+                    LogUtil.i("蓝牙连接-超过最大连接数，但是需要立即连接，断开所有连接进行连接")
+                    BleManager.getInstance().disconnectAllDevice()
+                    checkAndConnect(true)
+                } else {
+                    ThreadUtils.runOnIODelayed(500) {
+                        checkAndConnect()
+                    }
                 }
             }
         }
@@ -101,9 +116,9 @@ object BleConnectionManager {
     /**
      * 检查是否能进行蓝牙连接准备的下一步，防止未准备完但是已经取消订阅
      */
-    private fun checkProcess(mac: String?): Boolean {
+    private fun checkProcess(mac: String?, hideLoading: Boolean = true): Boolean {
         val canProcess = connectListeners.any { it.mac == mac }
-        if (!canProcess) sendLoadingEventMsg(null, false)
+        if (!canProcess&&hideLoading) sendLoadingEventMsg(null, false)
         return canProcess
     }
 
@@ -113,6 +128,7 @@ object BleConnectionManager {
     private fun connectKey() {
         if (connectListeners.isEmpty()) return
         if (isPreparing || BleManager.getInstance().allConnectedDevice.size >= maxStandbyCount) {
+            LogUtil.i("暂时不能连接:${isPreparing},${BleManager.getInstance().allConnectedDevice.size >= maxStandbyCount}")
             Executor.delayOnMain(1000) { connectKey() }
             return
         }
@@ -134,13 +150,15 @@ object BleConnectionManager {
                 if (!isDone) {
                     // 判断是否仍然待连，防止拿走；移到末尾，防止循环影响
                     if (checkProcess(listener.mac)) {
+                        listener.callBack?.invoke(false, null)
                         unregisterConnectListener(listener.mac)
-                        Executor.delayOnMain(2000) {
-                            registerConnectListener(
-                                listener.mac,
-                                listener.callBack
-                            )
-                        }
+//                        Executor.delayOnMain(2000) {
+//                            registerConnectListener(
+//                                listener.mac,
+//                                false,
+//                                listener.callBack
+//                            )
+//                        }
                     }
                     return@runOnMain
                 }
@@ -214,6 +232,7 @@ object BleConnectionManager {
         BleUtil.instance?.scan(object : CustomBleScanCallback() {
             override fun onPrompt(promptStr: String?) {
                 // 蓝牙未启动重试
+                LogUtil.i("蓝牙连接-参数:${promptStr}")
                 BleManager.getInstance().enableBluetooth()
                 doScanBle(mac, isNeedLoading, prepareDoneCallBack)
             }
@@ -231,9 +250,14 @@ object BleConnectionManager {
             }
 
             override fun onScanning(bleDevice: BleDevice?) {
-                LogUtil.i("蓝牙连接-onScanning：${bleDevice?.mac}")
-                bleDevice?.let {
-                    doConnect(it, isNeedLoading, prepareDoneCallBack)
+                val mac = bleDevice?.mac ?: return
+                LogUtil.i("蓝牙连接-onScanning：$mac")
+                if (mac.equals(mac, ignoreCase = true)) {
+                    // 找到目标设备，马上停止扫描
+                    LogUtil.i("找到目标设备 $mac，停止扫描并尝试连接")
+                    BleManager.getInstance().cancelScan()
+                    // 立刻调用 doConnect，下一步进入连接流程
+                    doConnect(bleDevice, isNeedLoading, prepareDoneCallBack)
                 }
             }
 
@@ -247,7 +271,6 @@ object BleConnectionManager {
                 // 没有扫描到
                 if (scanResultList?.none { it.mac == mac } == true) {
                     LogUtil.w("$mac is not scanned")
-                    BusinessManager.unregisterConnectListener(mac)
                     prepareDoneCallBack?.invoke(false, null)
                 }
             }
@@ -273,97 +296,105 @@ object BleConnectionManager {
                 LoadingMsg(true, CommonUtils.getStr(R.string.ble_connecting), null)
             )
         )
-        BleManager.getInstance().disconnect(bleDevice)
-        BleUtil.instance?.connectBySelect(
-            bleDevice, object : CustomBleGattCallback() {
-                override fun onPrompt(promptStr: String?) {
-                    if (isNeedLoading) sendEventMsg(
-                        MsgEvent(
-                            MSG_EVENT_LOADING, LoadingMsg(false, promptStr, null)
+        ThreadUtils.runOnIO {
+            BleManager.getInstance().disconnect(bleDevice)
+            delay(300)
+            BleUtil.instance?.connectBySelect(
+                bleDevice, object : CustomBleGattCallback() {
+                    override fun onPrompt(promptStr: String?) {
+                        if (isNeedLoading) sendEventMsg(
+                            MsgEvent(
+                                MSG_EVENT_LOADING, LoadingMsg(false, promptStr, null)
+                            )
                         )
-                    )
-                }
+                    }
 
-                override fun onStartConnect() {}
+                    override fun onStartConnect() {}
 
-                override fun onConnectFail(bleDevice: BleDevice?, exception: BleException?) {
-                    if (isNeedLoading) sendEventMsg(
-                        MsgEvent(
-                            MSG_EVENT_LOADING,
-                            LoadingMsg(false, CommonUtils.getStr(R.string.ble_connect_fail), false)
+                    override fun onConnectFail(bleDevice: BleDevice?, exception: BleException?) {
+                        if (isNeedLoading) sendEventMsg(
+                            MsgEvent(
+                                MSG_EVENT_LOADING,
+                                LoadingMsg(
+                                    false,
+                                    CommonUtils.getStr(R.string.ble_connect_fail),
+                                    false
+                                )
+                            )
                         )
-                    )
-                    LogUtil.e("蓝牙连接-onConnectFail : ${bleDevice?.mac} - ${exception?.description}")
-                    prepareDoneCallBack?.invoke(false, null)
-                }
+                        LogUtil.e("蓝牙连接-onConnectFail : ${bleDevice?.mac} - ${exception?.description}")
+                        prepareDoneCallBack?.invoke(false, null)
+                    }
 
-                override fun onConnectSuccess(
-                    bleDevice: BleDevice?, gatt: BluetoothGatt?, status: Int
-                ) {
-                    if (isNeedLoading) sendEventMsg(
-                        MsgEvent(
-                            MSG_EVENT_LOADING, LoadingMsg(false, null, null)
+                    override fun onConnectSuccess(
+                        bleDevice: BleDevice?, gatt: BluetoothGatt?, status: Int
+                    ) {
+                        if (isNeedLoading) sendEventMsg(
+                            MsgEvent(
+                                MSG_EVENT_LOADING, LoadingMsg(false, null, null)
+                            )
                         )
-                    )
-                    LogUtil.i("蓝牙连接-onConnectSuccess : ${bleDevice?.mac}")
-                    bleDevice?.let {
-                        deviceList.removeIf { it.bleDevice.mac == bleDevice.mac }
-                        val bleBean = BleBean(it)
-                        deviceList.add(bleBean)
-                        removeExceptionKey(it.mac)
-                        // 设置MTU
-                        Executor.delayOnMain(200) {
-                            if (!checkProcess(bleDevice.mac)) {
-                                LogUtil.e("Prepare is canceled : ${bleDevice.mac}")
-                                return@delayOnMain
+                        LogUtil.i("蓝牙连接-onConnectSuccess : ${bleDevice?.mac}")
+                        bleDevice?.let {
+                            deviceList.removeIf { it.bleDevice.mac == bleDevice.mac }
+                            val bleBean = BleBean(it)
+                            deviceList.add(bleBean)
+                            removeExceptionKey(it.mac)
+                            // 设置MTU
+                            Executor.delayOnMain(200) {
+                                if (!checkProcess(bleDevice.mac)) {
+                                    LogUtil.e("Prepare is canceled : ${bleDevice.mac}")
+                                    return@delayOnMain
+                                }
+                                BleUtil.instance?.setMtu(it)
+                            }
+                            // 监听
+                            Executor.delayOnMain(500) {
+                                indicate(bleBean, isNeedLoading, prepareDoneCallBack)
                             }
-                            BleUtil.instance?.setMtu(it)
-                        }
-                        // 监听
-                        Executor.delayOnMain(500) {
-                            indicate(bleBean, isNeedLoading, prepareDoneCallBack)
                         }
                     }
-                }
 
-                override fun onDisConnected(
-                    isActiveDisConnected: Boolean,
-                    device: BleDevice?,
-                    gatt: BluetoothGatt?,
-                    status: Int
-                ) {
-                    if (isNeedLoading) sendEventMsg(
-                        MsgEvent(
-                            MSG_EVENT_LOADING, LoadingMsg(false, null, false)
+                    override fun onDisConnected(
+                        isActiveDisConnected: Boolean,
+                        device: BleDevice?,
+                        gatt: BluetoothGatt?,
+                        status: Int
+                    ) {
+                        if (isNeedLoading) sendEventMsg(
+                            MsgEvent(
+                                MSG_EVENT_LOADING, LoadingMsg(false, null, false)
+                            )
                         )
-                    )
-                    LogUtil.i("蓝牙连接-onDisConnected : ${device?.mac} - $isActiveDisConnected")
-                    getBleDeviceByMac(device?.mac)?.let {
-                        deviceList.remove(it)
-                    }
-                    bleDevice.mac?.let { itMac ->
-                        unregisterConnectListener(itMac)
-                    }
-                    if (!isActiveDisConnected) {
-                        // 测试模式下不重连
-                        if (isTestMode) {
-                            return
+                        LogUtil.i("蓝牙连接-onDisConnected : ${device?.mac} - $isActiveDisConnected")
+                        getBleDeviceByMac(device?.mac)?.let {
+                            deviceList.remove(it)
+                            it.token = null
                         }
-                        // 断开和重连之间最好间隔一段时间，否则可能会出现长时间连接不上的情况
-                        Executor.delayOnMain(300) {
-                            registerConnectListener(bleDevice.mac) { isDone, bleBean ->
-                                if (isDone && bleBean != null) {
-                                    Executor.delayOnMain(300) {
-                                        getCurrentStatus(6, bleBean.bleDevice)
+                        bleDevice.mac?.let { itMac ->
+                            unregisterConnectListener(itMac)
+                        }
+                        if (!isActiveDisConnected) {
+                            // 测试模式下不重连
+                            if (isTestMode) {
+                                return
+                            }
+                            // 断开和重连之间最好间隔一段时间，否则可能会出现长时间连接不上的情况
+                            Executor.delayOnMain(300) {
+                                registerConnectListener(bleDevice.mac) { isDone, bleBean ->
+                                    if (isDone && bleBean != null) {
+                                        Executor.delayOnMain(300) {
+                                            getCurrentStatus(6, bleBean.bleDevice)
+                                        }
                                     }
                                 }
                             }
+                        } else {
+                            ModBusController.updateKeyReadyStatus(bleDevice.mac, false, 3)
                         }
-                    } else {
-                        ModBusController.updateKeyReadyStatus(bleDevice.mac, false, 3)
                     }
-                }
-            })
+                })
+        }
     }
 
     /**

app/src/main/java/com/grkj/iscs/modbus/ModBusController.kt

@@ -26,6 +26,11 @@ import com.grkj.iscs.util.NetApi
 import com.grkj.iscs.util.ToastUtils
 import com.grkj.iscs.util.log.LogUtil
 import com.sik.sikcore.thread.ThreadUtils
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.stream.Collectors
 import kotlin.coroutines.resume
@@ -232,7 +237,7 @@ object ModBusController {
                                     // 更新mac
                                     updateKeyMac(dockBean.addr, key.isLeft, keyInfo.macAddress)
                                     controlKeyCharge(true, keyInfo.macAddress) {
-                                        ThreadUtils.runOnIODelayed(1000) {
+                                        ThreadUtils.runOnIODelayed(500) {
                                             BusinessManager.registerConnectListener(
                                                 keyInfo.macAddress
                                             ) { isDone, bleBean ->
@@ -256,9 +261,7 @@ object ModBusController {
                     } else {
                         controlKeyBuckle(true, key.isLeft, dockBean.addr)
                         controlKeyCharge(
-                            false,
-                            key.isLeft,
-                            dockBean.addr
+                            false, key.isLeft, dockBean.addr
                         ) {
                             LogUtil.i("关闭充电:${it.toHexStrings()}")
                         }
@@ -510,9 +513,12 @@ object ModBusController {
         } ?: let {
             dockList.add(
                 DockBean(
-                    idx, DockBean.dockConfig.find { it.address == idx }?.row?.toInt() ?: 0,
+                    idx,
+                    DockBean.dockConfig.find { it.address == idx }?.row?.toInt() ?: 0,
                     DockBean.dockConfig.find { it.address == idx }?.column?.toInt() ?: 0,
-                    type, true, mutableListOf()
+                    type,
+                    true,
+                    mutableListOf()
                 )
             )
         }
@@ -968,54 +974,37 @@ object ModBusController {
     ): Pair<Byte, DockBean.KeyBean?>? {
         // 1. 过滤并准备钥匙列表
         val slotCols = exceptionSlots.mapNotNull { it.col?.toInt() }
-        val keyDockList = dockList
-            .filter { it.type == DOCK_TYPE_KEY || it.type == DOCK_TYPE_PORTABLE }
-            .sortedBy { it.addr }
-            .onEach { it.deviceList.sortBy { dev -> dev.idx } }
-
-        val keyList = keyDockList
-            .flatMap { it.deviceList }
-            .apply {
-                LogUtil.i("keyStatus:${this}")
-            }
-            .filterIsInstance<DockBean.KeyBean>()
-            .filterIndexed { idx, _ -> (idx + 1) !in slotCols }
-            .filter { kb ->
-                !kb.rfid.isNullOrEmpty()
-                        && kb.rfid !in exceptionKeysRfid
-                        && kb.mac !in exceptionKeysMac
-                        && !kb.mac.isNullOrEmpty()
-                        && kb.isExist
-            }
-            .shuffled()
-
+        val keyDockList =
+            dockList.filter { it.type == DOCK_TYPE_KEY || it.type == DOCK_TYPE_PORTABLE }
+                .sortedBy { it.addr }.onEach { it.deviceList.sortBy { dev -> dev.idx } }
+
+        val keyList = keyDockList.flatMap { it.deviceList }.apply {
+            LogUtil.i("keyStatus:${this}")
+        }.filterIsInstance<DockBean.KeyBean>()
+            .filterIndexed { idx, _ -> (idx + 1) !in slotCols }.filter { kb ->
+                !kb.rfid.isNullOrEmpty() && kb.rfid !in exceptionKeysRfid && kb.mac !in exceptionKeysMac && !kb.mac.isNullOrEmpty() && kb.isExist
+            }.shuffled()
+
+        LogUtil.i("蓝牙连接-获取到钥匙信息:${keyList}")
         if (keyList.isEmpty()) {
             ToastUtils.tip(R.string.no_available_key)
             return null
         }
+        keyList.sortedBy { BusinessManager.getBleDeviceByMac(it.mac)?.token != null }
 
         for (kb in keyList) {
             val mac = kb.mac ?: continue
-            val found = suspendCoroutine<DockBean.KeyBean?> { cont ->
-                controlKeyCharge(true, mac) {
-                    ///开启充电后等待500ms尝试连接
-                    ThreadUtils.runOnIODelayed(1000) {
-                        BusinessManager.registerConnectListener(mac) { isDone, _ ->
-                            if (isDone) {
-                                controlKeyCharge(false, mac) {}
-                                LogUtil.i("连接成功")
-                                cont.resume(kb)
-                            }
-                        }
-                    }
+
+            val connected = tryConnectWithOptionalCharge(mac)
+            if (connected) {
+                LogUtil.i("蓝牙连接完成 :${mac}")
+                // 找到第一个能连的：从 keyDockList 里拿同 rfid 的 addr
+                val addr =
+                    keyDockList.firstOrNull { it.getKeyList().any { it.rfid == kb.rfid } }?.addr
+                if (addr != null) {
+                    return addr to kb
                 }
             }
-            if (found != null) {
-                val addr = keyDockList
-                    .firstOrNull { it.getKeyList().any { it.rfid == found.rfid } }
-                    ?.addr
-                return if (addr != null) addr to found else null
-            }
         }
 
         // 一个都没成功
@@ -1023,6 +1012,65 @@ object ModBusController {
         return null
     }
 
+    /**
+     * 对单个 MAC 做下面两步：
+     *   1. 先尝试不充电连接，若成功就返回 true；
+     *   2. 否则开启“充电”，等 500ms，再尝试一次连接，连接成功后断电并返回 true；否则返回 false。
+     */
+    private suspend fun tryConnectWithOptionalCharge(mac: String): Boolean =
+        withContext(Dispatchers.IO) {
+            // -------- 第一次尝试 --------
+            LogUtil.i("蓝牙连接-第一次尝试")
+            val firstTry = suspendCancellableCoroutine<Boolean> { cont ->
+                // 1. 定义一个 flag，确保只 resume 一次
+                var isCalled = false
+                BusinessManager.registerConnectListener(mac, true) { isDone, _ ->
+                    if (isCalled) {
+                        return@registerConnectListener
+                    }
+                    isCalled = true
+                    if (isDone) {
+                        // 连接成功后，把电关掉（以防万一）
+                        controlKeyCharge(false, mac) { }
+                        cont.resume(true)
+                    } else {
+                        cont.resume(false)
+                    }
+                    cont.cancel()
+                }
+            }
+            LogUtil.i("蓝牙连接-第一次连接:${firstTry}")
+            if (firstTry) {
+                return@withContext true
+            }
+            // -------- 第二次尝试：先开电，再连 --------
+            // 开电，并等待回调
+            suspendCoroutine<Unit> { unitCont ->
+                controlKeyCharge(true, mac) {
+                    unitCont.resume(Unit)
+                }
+            }
+            LogUtil.i("蓝牙连接-开启充电并等待500ms")
+            // 等 500ms 保证硬件电源稳定
+            delay(500)
+
+            // 再次注册连接监听
+            val secondTry = suspendCancellableCoroutine<Boolean> { cont ->
+                var isCalled = false
+                BusinessManager.registerConnectListener(mac, true) { isDone, _ ->
+                    if (isCalled) {
+                        return@registerConnectListener
+                    }
+                    isCalled = true
+                    // 无论成功或失败，都先把电关掉
+                    controlKeyCharge(false, mac) { }
+                    cont.resume(isDone)
+                    cont.cancel()
+                }
+            }
+            return@withContext secondTry
+        }
+
     /**
      * 根据数量获取锁具(基于锁柜和便携柜不存在接一起的情况)
      *

app/src/main/java/com/grkj/iscs/model/bo/WorkTicketGetBO.kt

@@ -1,14 +1,20 @@
 package com.grkj.iscs.model.bo
 
+import com.grkj.iscs.util.NetApi
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
 class WorkTicketGetBO {
     /**
      * 权限卡号
      */
     var cardNo: String? = null
+
     /**
      * 用户密码
      */
     var password: String? = null
+
     /**
      * 工作票数组
      */
@@ -19,10 +25,12 @@ class WorkTicketGetBO {
          * 工作票号
          */
         var taskCode: String? = null
+
         /**
          * 工作票ID
          */
         var taskId: String? = null
+
         /**
          * 工作票下挂任务列表
          */
@@ -33,23 +41,28 @@ class WorkTicketGetBO {
              * 任务ID
              */
             var dataId: Int? = null
+
             /**
              * 工作点位RFID号
              */
             var equipRfidNo: String? = null
+
             /**
              * 锁RFID号
              */
             var infoRfidNo: String? = null
+
             /**
              * 任务目标 0：挂锁 1：解锁
              */
             var target: Int? = null
+
             /**
              * 任务当前状态：
              * 0—挂锁；1—解锁；2-无操作
              */
             var status: Int? = null
+
             /**
              * 任务操作状态
              * 0—待完成；1—已完成
@@ -74,13 +87,20 @@ class WorkTicketGetBO {
     }
 
     // 判断是否有closed字段为0的
-    fun hasFinished(): Boolean {
+    suspend fun hasFinished(): Boolean {
         data?.forEach {
-            it.dataList?.forEach {
-                if (it.closed == 0) {
-                    return false
+            val ticketFinish = suspendCoroutine<Boolean> { cont ->
+                NetApi.getTicketDetail(it.taskCode?.toLong() ?: 0) { res ->
+                    if (res?.ticketStatus in listOf<String>("5", "6")) {
+                        cont.resume(true)
+                    } else {
+                        cont.resume(it.dataList?.all { it.closed == 1 } == true)
+                    }
                 }
             }
+            if (ticketFinish == false) {
+                return false
+            }
         }
         return true
     }

app/src/main/java/com/grkj/iscs/view/fragment/DockTestFragment.kt

@@ -8,7 +8,6 @@ import com.grkj.iscs.databinding.FragmentDockTestBinding
 import com.grkj.iscs.extentions.removeLeadingZeros
 import com.grkj.iscs.extentions.toHexStrings
 import com.grkj.iscs.modbus.ModBusController
-import com.grkj.iscs.modbus.ModBusController.controlKeyCharge
 import com.grkj.iscs.model.DeviceConst.DOCK_TYPE_KEY
 import com.grkj.iscs.model.DeviceConst.DOCK_TYPE_LOCK
 import com.grkj.iscs.util.SPUtils
@@ -82,6 +81,7 @@ class DockTestFragment : BaseFragment<FragmentDockTestBinding>() {
                         }
                         holder.setOnClickListener(R.id.tv_turn_off) {
                             ModBusController.controlKeyBuckle(false, deviceIndex == 1, dock.address)
+                            ModBusController.controlKeyCharge(true, deviceIndex == 1, dock.address)
                         }
                         holder.setOnClickListener(R.id.tv_read) {
                             ModBusController.readKeyRfid(