refactor(更新) :

- 还钥匙的时候，如果远端作业已经被结束，则直接切换钥匙状态

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

@@ -212,7 +212,8 @@ object BusinessManager {
 
                 MSG_EVENT_SWITCH_COLLECTION_UPDATE -> {
                     ThreadUtils.runOnIO {
-                        val switchStatus = NetApi.getDictData(DictAndSystemConstants.KEY_SWITCH_STATUS)
+                        val switchStatus =
+                            NetApi.getDictData(DictAndSystemConstants.KEY_SWITCH_STATUS)
                         val switchListReqVOS = ModBusController.getSwitchData().map {
                             SwitchListReqVO(
                                 it.idx.toString(),
@@ -240,8 +241,10 @@ object BusinessManager {
             // —— 并行加载字典（或按需串行也行） ——
             val slotStatus =
                 async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_STATUS) }
-            val keyStatus = async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_KEY_STATUS) }
-            val slotType = async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_TYPE) }
+            val keyStatus =
+                async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_KEY_STATUS) }
+            val slotType =
+                async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_TYPE) }
 
             // 等待字典加载完成
             val slotStatusList = slotStatus.await()
@@ -591,7 +594,11 @@ object BusinessManager {
                                         )
                                         ThreadUtils.runOnIO {
                                             val lockStatusReq =
-                                                async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_PAD_LOCK_STATUS) }
+                                                async {
+                                                    fetchDict<CommonDictRespVO>(
+                                                        DictAndSystemConstants.KEY_PAD_LOCK_STATUS
+                                                    )
+                                                }
                                             var lockStatus = lockStatusReq.await()
                                             NetApi.getIsLockPage { lockData ->
                                                 //锁rfid未异常正常请求锁数据，关锁
@@ -790,8 +797,10 @@ object BusinessManager {
                     async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_PAD_LOCK_STATUS) }
                 val slotStatus =
                     async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_STATUS) }
-                val slotType = async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_TYPE) }
-                val keyStatus = async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_KEY_STATUS) }
+                val slotType =
+                    async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_SLOT_TYPE) }
+                val keyStatus =
+                    async { fetchDict<CommonDictRespVO>(DictAndSystemConstants.KEY_KEY_STATUS) }
 
                 // 等待字典加载完成
                 val lockStatusList = lockStatus.await()
@@ -1371,9 +1380,11 @@ object BusinessManager {
 
             // 判断workTicketGetBO里是否有未完成的
             ThreadUtils.runOnIO {
-                if (workTicketGetBO.hasFinished()) {
+                val finishedStatus = workTicketGetBO.hasFinished()
+                LogUtil.i("作业票结束情况:${finishedStatus}")
+                if (finishedStatus.first) {
                     Executor.delayOnMain(500) {
-                        handleKeyReturn(bleDevice, workTicketGetBO)
+                        handleKeyReturn(bleDevice, workTicketGetBO, finishedStatus.second)
                     }
                 } else {
                     // 当前策略：作业票未完成禁止归还钥匙
@@ -1395,86 +1406,99 @@ object BusinessManager {
         }
     }
 
-    private fun handleKeyReturn(bleDevice: BleDevice, workTicketGetBO: WorkTicketGetBO?) {
+    /**
+     * ticketFinished主要是后端的作业票是否已经结束，结束了，就直接修改状态就好了
+     */
+    private fun handleKeyReturn(
+        bleDevice: BleDevice,
+        workTicketGetBO: WorkTicketGetBO?,
+        ticketFinished: Boolean
+    ) {
         val dock = ModBusController.getDockByKeyMac(bleDevice.mac)
         val keyBean = dock?.getKeyList()?.find { it.mac == bleDevice.mac }
         keyBean?.let {
             ModBusController.controlKeyBuckle(false, keyBean.isLeft, dock.addr)
         }
-        // 上报隔离点状态
-        val keyNfc = ModBusController.getKeyByMac(bleDevice.mac)?.rfid
-        workTicketGetBO?.data?.forEach { data ->
-            val updateList = mutableListOf<LockPointUpdateReqVO>()
-            data.dataList?.forEach { dataListDTO ->
-                data.taskCode?.toLong()?.let {
-                    SPUtils.returnKey(it)
+        if (ticketFinished) {
+            switchReadyMode(bleDevice)
+        } else {
+            // 上报隔离点状态
+            val keyNfc = ModBusController.getKeyByMac(bleDevice.mac)?.rfid
+            workTicketGetBO?.data?.forEach { data ->
+                val updateList = mutableListOf<LockPointUpdateReqVO>()
+                data.dataList?.forEach { dataListDTO ->
+                    data.taskCode?.toLong()?.let {
+                        SPUtils.returnKey(it)
+                    }
+                    val updateVO = LockPointUpdateReqVO(
+                        data.taskCode?.toLong(),
+                        dataListDTO.infoRfidNo,
+                        dataListDTO.equipRfidNo,
+                        keyNfc!!,
+                        dataListDTO.target,
+                        dataListDTO.status
+                    )
+                    updateList.add(updateVO)
                 }
-                val updateVO = LockPointUpdateReqVO(
-                    data.taskCode?.toLong(),
-                    dataListDTO.infoRfidNo,
-                    dataListDTO.equipRfidNo,
-                    keyNfc!!,
-                    dataListDTO.target,
-                    dataListDTO.status
-                )
-                updateList.add(updateVO)
-            }
 
-            sendLoadingEventMsg(null, false)
-            ToastUtils.tip(R.string.key_return_success)
-            if (CAN_RETURN) {
-                // 上报点位钥匙绑定
-                NetApi.updateLockPointBatch(updateList) { isSuccess, msg ->
-                    if (isSuccess || msg == MyApplication.instance?.applicationContext!!.getString(
-                            R.string.lock_nfc_lost
-                        )
-                    ) {
-                        data.taskCode?.toLong()?.let {
-                            sendEventMsg(
-                                MsgEvent(
-                                    MSG_EVENT_UPDATE_TICKET_PROGRESS, UpdateTicketProgressMsg(it)
-                                )
+                sendLoadingEventMsg(null, false)
+                ToastUtils.tip(R.string.key_return_success)
+                if (CAN_RETURN) {
+                    // 上报点位钥匙绑定
+                    NetApi.updateLockPointBatch(updateList) { isSuccess, msg ->
+                        if (isSuccess || msg == MyApplication.instance?.applicationContext!!.getString(
+                                R.string.lock_nfc_lost
                             )
+                        ) {
+                            data.taskCode?.toLong()?.let {
+                                sendEventMsg(
+                                    MsgEvent(
+                                        MSG_EVENT_UPDATE_TICKET_PROGRESS,
+                                        UpdateTicketProgressMsg(it)
+                                    )
+                                )
+                            }
+                            // 确认归还，切换为待机模式
+                            switchReadyMode(bleDevice)
+                        } else if (msg != MyApplication.instance?.applicationContext!!.getString(R.string.lock_nfc_lost)) {
+                            SPUtils.saveUpdateLockPoint(MyApplication.instance!!, updateList)
                         }
-                        // 确认归还，切换为待机模式
-                        switchReadyMode(bleDevice)
-                    } else if (msg != MyApplication.instance?.applicationContext!!.getString(R.string.lock_nfc_lost)) {
-                        SPUtils.saveUpdateLockPoint(MyApplication.instance!!, updateList)
                     }
-                }
 
-                // 上报钥匙归还
-                NetApi.updateKeyReturn(
-                    data.taskCode?.toLong()!!, keyNfc!!, MyApplication.instance!!.serialNo()
-                ) { isSuccess, msg ->
-                    if (!isSuccess && msg != MyApplication.instance?.applicationContext!!.getString(
-                            R.string.ticket_lost
-                        )
-                    ) {
-                        SPUtils.saveUpdateKeyReturn(
-                            MyApplication.instance!!,
-                            UpdateKeyReturnBO(data.taskCode?.toLong()!!, keyNfc!!)
-                        )
-                        if (msg == MyApplication.instance?.applicationContext!!.getString(
+                    // 上报钥匙归还
+                    NetApi.updateKeyReturn(
+                        data.taskCode?.toLong()!!, keyNfc!!, MyApplication.instance!!.serialNo()
+                    ) { isSuccess, msg ->
+                        if (!isSuccess && msg != MyApplication.instance?.applicationContext!!.getString(
                                 R.string.ticket_lost
                             )
                         ) {
-                            sendEventMsg(
-                                MsgEvent(
-                                    MsgEventConstants.MSG_EVENT_TICKET_FINISHED,
-                                    null
-                                )
+                            SPUtils.saveUpdateKeyReturn(
+                                MyApplication.instance!!,
+                                UpdateKeyReturnBO(data.taskCode?.toLong()!!, keyNfc!!)
                             )
+                            if (msg == MyApplication.instance?.applicationContext!!.getString(
+                                    R.string.ticket_lost
+                                )
+                            ) {
+                                sendEventMsg(
+                                    MsgEvent(
+                                        MsgEventConstants.MSG_EVENT_TICKET_FINISHED,
+                                        null
+                                    )
+                                )
+                            }
                         }
                     }
+                } else {
+                    SPUtils.saveUpdateLockPoint(MyApplication.instance!!, updateList)
+                    SPUtils.saveUpdateKeyReturn(
+                        MyApplication.instance!!,
+                        UpdateKeyReturnBO(data.taskCode?.toLong()!!, keyNfc!!)
+                    )
+                    // 保存待发数据，切换为待机模式
+                    switchReadyMode(bleDevice)
                 }
-            } else {
-                SPUtils.saveUpdateLockPoint(MyApplication.instance!!, updateList)
-                SPUtils.saveUpdateKeyReturn(
-                    MyApplication.instance!!, UpdateKeyReturnBO(data.taskCode?.toLong()!!, keyNfc!!)
-                )
-                // 保存待发数据，切换为待机模式
-                switchReadyMode(bleDevice)
             }
         }
     }

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

@@ -1,6 +1,7 @@
 package com.grkj.iscs.model.bo
 
 import com.grkj.iscs.util.NetApi
+import com.grkj.iscs.util.log.LogUtil
 import kotlin.coroutines.resume
 import kotlin.coroutines.suspendCoroutine
 
@@ -87,21 +88,41 @@ class WorkTicketGetBO {
     }
 
     // 判断是否有closed字段为0的
-    suspend fun hasFinished(): Boolean {
-        data?.forEach {
-            val ticketFinish = suspendCoroutine<Boolean> { cont ->
-                NetApi.getTicketDetail(it.taskCode?.toLong() ?: 0) { res ->
-                    if (res?.ticketStatus in listOf<String>("5", "6")) {
-                        cont.resume(true)
+    suspend fun hasFinished(): Pair<Boolean, Boolean> {
+        // 如果没有数据，默认本地完成且远程未完成
+        if (data.isNullOrEmpty()) return true to false
+
+        var anyRemoteFinished = false
+
+        for (item in data) {
+            // 1. 调用回调接口获取远程的 ticketStatus，并根据情况设置两个标志
+            val (localTicketFinish, remoteTicketFinished) = suspendCoroutine<Pair<Boolean, Boolean>> { cont ->
+                NetApi.getTicketDetail(item.taskCode?.toLong() ?: 0) { res ->
+                    LogUtil.i("作业票状态: ${res?.ticketStatus}")
+                    if (res?.ticketStatus in listOf("5", "6")) {
+                        // 只要远程状态是 5 或 6，就认为 remoteTicketFinished = true
+                        cont.resume(true to true)
                     } else {
-                        cont.resume(it.dataList?.all { it.closed == 1 } == true)
+                        // 否则，用本地 dataList 的所有 closed 字段判断 localTicketFinish，本地没完成就返回 false
+                        val allClosed = item.dataList?.all { it.closed == 1 } == true
+                        cont.resume(allClosed to false)
                     }
                 }
             }
-            if (ticketFinish == false) {
-                return false
+
+            // 如果这一次远程已经为 true，就标记下来
+            if (remoteTicketFinished) {
+                anyRemoteFinished = true
+            }
+
+            // 如果本地没走完，就可以立刻返回：本地 false + 这时 anyRemoteFinished 的值
+            if (!localTicketFinish) {
+                return false to anyRemoteFinished
             }
+            // 本地都走完才继续下一轮
         }
-        return true
+
+        // 如果所有项本地都完成，就返回 true；远程是否有一次命中，就看 anyRemoteFinished
+        return true to anyRemoteFinished
     }
 }

app/src/main/java/com/grkj/iscs/view/presenter/FaceConfigPresetner.kt

@@ -48,7 +48,9 @@ class FaceConfigPresenter : BasePresenter<IFaceConfigView>() {
      */
     fun getFaceLimit(callBack: (Int) -> Unit) {
         NetApi.getIsSystemAttributeByKey(DictAndSystemConstants.KEY_SYS_FACE_LIMIT) {
-            callBack(it?.sysAttrValue?.toInt() ?: 5)
+            Executor.runOnMain {
+                callBack(it?.sysAttrValue?.toInt() ?: 5)
+            }
         }
     }
 }

app/src/main/java/com/grkj/iscs/view/presenter/FingerprintConfigPresenter.kt

@@ -48,7 +48,9 @@ class FingerprintConfigPresenter : BasePresenter<IFingerprintConfigView>() {
      */
     fun getFingerprintLimit(callBack: (Int) -> Unit) {
         NetApi.getIsSystemAttributeByKey(DictAndSystemConstants.KEY_SYS_FINGERPRINT_LIMIT) {
-            callBack(it?.sysAttrValue?.toInt() ?: 5)
+            Executor.runOnMain {
+                callBack(it?.sysAttrValue?.toInt() ?: 5)
+            }
         }
     }
 }

app/src/main/java/com/grkj/iscs/view/presenter/StepPresenter.kt

@@ -2,6 +2,7 @@ package com.grkj.iscs.view.presenter
 
 import android.content.Context
 import com.grkj.iscs.R
+import com.grkj.iscs.modbus.DockBean
 import com.grkj.iscs.modbus.ModBusController
 import com.grkj.iscs.modbus.ModBusController.dockList
 import com.grkj.iscs.model.DeviceConst.DOCK_TYPE_KEY
@@ -163,14 +164,15 @@ class StepPresenter : BasePresenter<IStepView>() {
                 val keyDockList =
                     dockList.filter { it.type == DOCK_TYPE_KEY || it.type == DOCK_TYPE_PORTABLE }
                 keyDockList.forEach { dock ->
-                    dock.deviceList.filter { it.isExist }.forEach { key ->
-                        ModBusController.controlKeyCharge(false, key.idx == 1, dock.addr) {
-                            ThreadUtils.runOnIO {
-                                delay(500)
-                                ModBusController.controlKeyCharge(true, key.idx == 1, dock.addr)
+                    dock.deviceList.filter { it.isExist }.filterIsInstance<DockBean.KeyBean>()
+                        .forEach { key ->
+                            ModBusController.controlKeyCharge(false, key.isLeft, dock.addr) {
+                                ThreadUtils.runOnIO {
+                                    delay(500)
+                                    ModBusController.controlKeyCharge(true, key.isLeft, dock.addr)
+                                }
                             }
                         }
-                    }
                 }
             }
         }

app/src/main/java/com/grkj/iscs/view/presenter/WorkerPresenter.kt

@@ -2,6 +2,7 @@ package com.grkj.iscs.view.presenter
 
 import android.content.Context
 import com.grkj.iscs.R
+import com.grkj.iscs.modbus.DockBean
 import com.grkj.iscs.modbus.ModBusController
 import com.grkj.iscs.modbus.ModBusController.dockList
 import com.grkj.iscs.model.Constants.USER_ROLE_LOCKER
@@ -135,16 +136,16 @@ class WorkerPresenter : BasePresenter<IWorkerView>() {
         ThreadUtils.runOnIO {
             val keyDockList =
                 dockList.filter { it.type == DOCK_TYPE_KEY || it.type == DOCK_TYPE_PORTABLE }
-                    .sortedBy { it.addr }.onEach { it.deviceList.sortBy { dev -> dev.idx } }
             keyDockList.forEach { dock ->
-                dock.deviceList.filter { it.isExist }.forEach { key ->
-                    ModBusController.controlKeyCharge(false, key.idx == 1, dock.addr) {
-                        ThreadUtils.runOnIO {
-                            delay(500)
-                            ModBusController.controlKeyCharge(true, key.idx == 1, dock.addr)
+                dock.deviceList.filter { it.isExist }.filterIsInstance<DockBean.KeyBean>()
+                    .forEach { key ->
+                        ModBusController.controlKeyCharge(false, key.isLeft, dock.addr) {
+                            ThreadUtils.runOnIO {
+                                delay(500)
+                                ModBusController.controlKeyCharge(true, key.isLeft, dock.addr)
+                            }
                         }
                     }
-                }
             }
         }
     }