huaxuepin/app/src/main/java/com/example/chemical/ui/newly/AddedChemicalsActivity.kt

package com.example.chemical.ui.newly


import android.app.Activity
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.graphics.Rect
import android.hardware.usb.UsbManager
import android.os.Bundle
import android.os.CountDownTimer
import android.os.Handler
import android.os.Looper
import android.view.KeyEvent
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.ViewTreeObserver
import android.view.inputmethod.InputMethodManager
import android.widget.ArrayAdapter
import android.widget.EditText
import android.widget.TextView
import android.widget.Toast
import androidx.lifecycle.lifecycleScope
import androidx.recyclerview.widget.LinearLayoutManager
import com.bumptech.glide.Glide
import com.bumptech.glide.load.engine.DiskCacheStrategy
import com.bumptech.glide.request.RequestOptions
import com.caysn.autoreplyprint.AutoReplyPrint
import com.example.chemical.ChemicalApp
import com.example.chemical.R
import com.example.chemical.blu.BluetoothConnectionManager
import com.example.chemical.comm.Constants
import com.example.chemical.databinding.ActivityAddedChemicalsBinding
import com.example.chemical.receiver.OnSerialScanListener
import com.example.chemical.receiver.PortScanHelper
import com.example.chemical.receiver.UsbReceiver
import com.example.chemical.ui.PrintBean
import com.example.chemical.ui.SplashActivity
import com.example.chemical.ui.adapter.ChemicalsAdapter
import com.example.chemical.ui.common.BaseCountDownActivity
import com.example.chemical.ui.verify.TwoVerificationActivity
import com.example.chemical.utils.BitmapUtils
import com.example.chemical.utils.ButtonDebouncer
import com.example.chemical.utils.ConversionUtils
import com.example.chemical.utils.HandlerUtil
import com.example.chemical.utils.MediaPlayerHelper
import com.example.chemical.utils.SharedPreferencesHelper
import com.example.chemical.utils.TimeUpdater
import com.example.chemical.utils.UiManager
import com.example.chemical.weidith.BelongingPersonDialog
import com.example.chemical.weidith.ChemicalTypeDialog
import com.example.chemical.weidith.CustomDialog
import com.example.chemical.weidith.DcaeDialog
import com.example.chemical.weidith.LabelDialog
import com.example.chemical.weidith.PackingDialog
import com.example.chemical.weidith.SelectTopicDialog
import com.example.chemical.weidith.StorageDialog
import com.example.chemical.weidith.WeighDialog
import com.rc.core.log.RcLog
import com.rc.httpcore.HttpConfig
import com.rc.httpcore.bean.BelongingPersonBean
import com.rc.httpcore.bean.ChemicalABean
import com.rc.httpcore.bean.ChemicalConfsBean
import com.rc.httpcore.bean.ChemicalInfoBean
import com.rc.httpcore.bean.ChemicalSearchBean
import com.rc.httpcore.bean.ChemicalTypeBean
import com.rc.httpcore.bean.LockVoListBean
import com.rc.httpcore.bean.RuleBean
import com.rc.httpcore.bean.StockDetailsModel
import com.rc.httpcore.bean.StockModeBean
import com.rc.httpcore.bean.StockModel
import com.rc.httpcore.bean.TopicDataBean
import com.rc.httpcore.client.ApiRepository
import com.rc.httpcore.exception.NetException
import com.sun.jna.Pointer
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode
import retrofit2.HttpException
import java.math.BigDecimal
import java.net.ConnectException
import java.net.SocketTimeoutException
import java.nio.charset.StandardCharsets

/**
 * 新增入库 全新  包装0  已开封  可输入包装值
 * AutoCompleteTextView
 */
class AddedChemicalsActivity : BaseCountDownActivity<ActivityAddedChemicalsBinding>() {

    private lateinit var timeUpdater: TimeUpdater
    private val mAdapter by lazy { ChemicalsAdapter(this) }
    private lateinit var modelA: ChemicalABean //新增-点击确定 需要的参数

    private var mLabelDialog: LabelDialog? = null
    private var mWeighDialog: WeighDialog? = null

    private var mChemicalInfoBean: ChemicalInfoBean? = null
    private var mListData: List<RuleBean>? = null  //柜子信息
    private var mPrintTag = 0  //需要打印得内容条数
    private var mStockDetailsModel: MutableList<StockDetailsModel>? = null

    //刷卡
    private var mUsbReceiver: UsbReceiver? = null  // 刷卡广播注册
    private var mHandleScanEvent = false //当前是否已经获取过 usb返回的参数
    private var mUserId: String? = null   //归属人id

    //    private val REQUEST_CODE = 6
    private var mCabinetId = ""   //柜子id
    private var mCabinetName = "" //柜子名称

    //    private var mUnlockingMethod = 1         //1无锁，2是智能锁，3是钥匙柜
    private var mLayers = 1  //柜子一共层数
    private var mLayersTow = 1  //柜子选择层数
    private var mDoorId: String = ""
    private var mDoorName = ""    //柜门名称
    private var mLockNum: String = ""
    private var mChemicalId: String? = null
    private var chemTypeIsBoo = true
    private var mWeighingValue: EditText? = null
    private var mStockModeBean = StockModeBean(mutableListOf())
    private var mStockModelList = mutableListOf<StockModel>()
    private var mCabinetLockVoList: List<LockVoListBean>? = null  //柜锁会又多个
    private var mLockStr = ArrayList<String>()  // 需要打开得柜锁数量
    private val handlerUtil = HandlerUtil.getInstance()

    private val handlerPrint = HandlerUtil.getInstance()
    private var mJoinType = 1   //称重方式 1 称重，2 录入  提交
    private lateinit var mChemicalConfsBean: ChemicalConfsBean  //获取化学品的称重超过比例or
    private var h = Pointer.NULL
    private var pritBot = false
    private var mWeighing: String? = null  //记录上次数
    private var isClisLit = false  //是否点击称重关闭按钮

    //厂家信息
    private var mOptionsList = mutableListOf<String>()

    override fun createViewBinding() =
            ActivityAddedChemicalsBinding.inflate(LayoutInflater.from(this))

    override fun initViews(savedInstanceState: Bundle?) {
        super.initViews(savedInstanceState)
        initTitle()
        inAdapter()//初始化适配器
        EventBus.getDefault().register(this)

        searchProducer()
        viewBinding.edName.setText("${ChemicalApp.userData!!.userName}-${ChemicalApp.userData!!.account}")
        viewBinding.tvReturn.text = "返回${ChemicalApp.confs!!.backTime}s"
        mUserId = ChemicalApp.userData!!.userId
        viewBinding.tvOutLogin.setOnClickListener {
            callLogoutApi {
                ChemicalApp.userData = null
//                HttpClient.token = null
                ChemicalApp.subjectId = null
                UiManager.switcherCashier(this, SplashActivity::class.java)
            }
        }
        // 责任人   校院管理员
        RcLog.info("==当前人员权限===${ChemicalApp.responsibles}  ${ChemicalApp.administrators}")
        if (!ChemicalApp.administrators) {  //不是校级院级管理员
            viewBinding.butUnregulated.isChecked = true
            viewBinding.butControl.isChecked = false   //取消默认选中
            viewBinding.butControl.isEnabled = false   //禁止点击
        }

        viewBinding.tvReturn.setOnClickListener {
            finish()
        }

        //品名搜索
        viewBinding.butPSearch.setOnClickListener {
            viewBinding.packNum.setText("")
            if (viewBinding.chemicalName.text.toString().isNotEmpty()) {
                //  chemicalLevel    //管控 1     非管控  2
                if (ChemicalApp.responsibles) {  //非管控 类型查询
                    searchChemica(viewBinding.chemicalName.text.toString(), "2")
                } else {
                    searchChemica(viewBinding.chemicalName.text.toString(), null)
                }
            } else {
                showToast("请输入化学品名称")
            }
        }

        viewBinding.imgPosition.setOnClickListener {
            //更换柜子信息
            storageDialogView()
        }

        viewBinding.butOpen.setOnClickListener {
            //再次打开柜门
            if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                mLockStr.clear()
                mCabinetLockVoList!!.forEach { it ->
                    when (it.unlockingMethod) {
                        2 -> { //智能锁
                            mLockStr.add("${it.lockNum}")
                        }
                    }
                }
                if (mLockStr != null && mLockStr.size > 0) {
                    openLock(mLockStr)
                } else {
                    subAddData(0)
                }
            } else {
                subAddData(0)
            }
        }

        //CAS号 搜索
        viewBinding.butCSearch.setOnClickListener {
            viewBinding.packNum.setText("")
            if (viewBinding.casNum.text.toString().isNotEmpty()) {
                RcLog.info("==当前人员权限=2==${ChemicalApp.responsibles}  ${ChemicalApp.administrators}")
                if (ChemicalApp.responsibles) {
                    searchChemica(viewBinding.casNum.text.toString(), "2")
                } else {
                    searchChemica(viewBinding.casNum.text.toString(), null)
                }
            } else {
                showToast("请输入CAS号")
            }
        }

        //类别
        viewBinding.chemType.setOnClickListener {
            if (chemTypeIsBoo == false) {
                return@setOnClickListener
            }
            showLoading("查询中...")
            val disposable = ApiRepository.getOptions("chemicals_category")
                    .subscribe({ data ->
                        dismissLoading()
                        val chemDialog = ChemicalTypeDialog(
                                this,
                                data.toMutableList(),
                                object : ChemicalTypeDialog.IonClickListener {
                                    override fun onClick(data: ChemicalTypeBean) {
//                                showToast("${data.label}  ${data.itemId}")
                                        viewBinding.chemType.text = "${data.label}"
                                        viewBinding.chemType.tag = "${data.value}"
                                    }
                                })

                        if (!chemDialog.isShowing) {
                            chemDialog.show()
                        }
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }

        //通过 姓名or工号 搜索 归属人信息
        viewBinding.butName.setOnClickListener {
            val edName = viewBinding.edName.text.toString()
            if (edName.isNotBlank()) {
                showLoading("查询中...")
                val disposable = ApiRepository.getSelects(edName)
                        .subscribe({ data ->
                            dismissLoading()
                            val dialogs =
                                    BelongingPersonDialog(
                                            this,
                                            data,
                                            object : BelongingPersonDialog.IClickLit {
                                                override fun onClickUserId(dataBean: BelongingPersonBean) {
                                                    //归属人 id  用于查询课题组信息
                                                    mUserId = dataBean.userId
                                                    viewBinding.edName.setText("${dataBean.userName}-${dataBean.account}")
//                                        viewBinding.topicName.tag = "${dataBean.userId}"

                                                }
                                            })
                            dialogs.show()
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)

                        })
                addDisposable(disposable)
            } else {
                showToast("姓名或工号不能为空")
            }
        }
        //课题组信息查询
        viewBinding.topic.setOnClickListener {

            if (mUserId == null) {
                showToast("未选择归属人")
                return@setOnClickListener
            }
            showLoading("查询中...")
            val disposable = ApiRepository.getTopicList(mUserId!!)
                    .subscribe({ data ->
                        dismissLoading()
                        var dialog =
                                SelectTopicDialog(this, data, object : SelectTopicDialog.IonItemLint {
                                    override fun onItem(topicDataBean: TopicDataBean) {
                                        viewBinding.topicName.text = "${topicDataBean.topicName}"
                                        viewBinding.topicName.tag = "${topicDataBean.topicId}"
                                    }
                                })
                        dialog.show()
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }

        //包装类型
        viewBinding.specType.setOnClickListener {
            showLoading("查询中...")
            val disposable = ApiRepository.getOptions("chemical_pack_utils")
                    .subscribe({ data ->
                        dismissLoading()
                        val packingDialog =
                                PackingDialog(this, data, object : PackingDialog.IonClickListener {
                                    override fun onClick(model: ChemicalTypeBean) {
                                        viewBinding.packUnit.text = model.label
                                    }
                                })
                        packingDialog.show()
                    }, { throwable ->
                        dismissLoading()
                        showNetError(throwable)

                    })
            addDisposable(disposable)
        }
        viewBinding.butResetting.setOnClickListener {
            //重置
            emptyViews()
        }
        val rootView = viewBinding.contents
        // 设置全局布局监听器
        rootView.viewTreeObserver.addOnGlobalLayoutListener(object :
                ViewTreeObserver.OnGlobalLayoutListener {
            private val visibleThreshold = 100 // 软键盘显示的阈值，可以根据需要调整

            override fun onGlobalLayout() {
                val rect = Rect()
                rootView.getWindowVisibleDisplayFrame(rect)

                // 获取屏幕高度
                val screenHeight = rootView.height

                // 计算键盘高度
                val keypadHeight = screenHeight - rect.bottom

                // 如果键盘高度大于一个阈值，判断为键盘显示
                val isKeyboardVisible = keypadHeight > visibleThreshold

                if (isKeyboardVisible) {
                    // 键盘显示时，可以进一步判断焦点是否在EditText上
                    val focusedView = currentFocus
                    if (focusedView is EditText) {
                        mHandleScanEvent = true
                    }
                } else {
                    //软键盘 隐藏
                }
            }
        })


//        //选择柜子信息
//        viewBinding.cabinet.setOnClickListener {
//            storageDialogView()
//        }

        //全新
        viewBinding.tvThe.setOnClickListener {
            viewBinding.tvTwo.isChecked = false
            viewBinding.packNum.isEnabled = false
            viewBinding.packNum.setText("")
        }

        //已开封
        viewBinding.tvTwo.setOnClickListener {
            viewBinding.tvThe.isChecked = false
            viewBinding.packNum.isEnabled = true
        }

        //====规格  g
        viewBinding.bugCationsLeft.setOnClickListener {
            viewBinding.bugCationsRight.isChecked = false
            viewBinding.packUnit.text = "件"
        }
        //====规格 ml
        viewBinding.bugCationsRight.setOnClickListener {
            viewBinding.bugCationsLeft.isChecked = false
            viewBinding.packUnit.text = "瓶"
        }
        //管控
        viewBinding.butControl.setOnClickListener {
            viewBinding.butUnregulated.isChecked = false
        }

        //非管控
        viewBinding.butUnregulated.setOnClickListener {
            viewBinding.butControl.isChecked = false
        }

        //根据规格值 查询最近一个包装值
        viewBinding.packNum.setOnFocusChangeListener { view, hasFocus ->
            if (hasFocus) {
                RcLog.info("=======1")
                val checked = viewBinding.tvTwo.isChecked
                if (checked) {
                    //已开封
                    val toString = viewBinding.specNum.text.toString()
                    if (toString.isNotEmpty()) {
                        RcLog.info("=======2")
                        searchSpecView(toString)
                    }
                }
            }
        }

        ButtonDebouncer.setDebouncedOnClickListener(viewBinding.butDetermine, 500L) {
            var isNew = true
            val checkedB = viewBinding.tvTwo.isChecked  //已开封
            if (checkedB) {
                isNew = false
            }
            val chemicalName = viewBinding.chemicalName.text.toString().trim()
            if (chemicalName.isEmpty()) {
                showToast("化学品名称不能为空")
                return@setDebouncedOnClickListener
            }
            var casNum: String? = null
            if (viewBinding.casNum.text.toString().trim().isNotEmpty()) {
                casNum = viewBinding.casNum.text.toString().trim()
            }
            val chemicalCategory = try {
                viewBinding.chemType.tag.toString()
            } catch (e: Exception) {
                showToast("类别不能为空")
                return@setDebouncedOnClickListener
            }
            var chemicalPurity: String? = null
//            val chemicalPurity = viewBinding.chemicalPurity.text.toString().trim()  //纯度
            val chemicalDensity = viewBinding.chemicalDensity.text.toString().trim()//密度
            if (viewBinding.chemicalPurity.text.toString().trim().isNotEmpty()) {
                chemicalPurity = viewBinding.chemicalPurity.text.toString().trim()
            }
            if (chemicalDensity.isEmpty()) {
                showToast("密度不能为空")
                return@setDebouncedOnClickListener
            }
            var chemicalLevel = 1  //管控

            //非管控
            if (viewBinding.butUnregulated.isChecked) {
                chemicalLevel = 2
            }
            var belongName = viewBinding.edName.text.toString().trim() //归属人
            var belongId: String? = null

            if (belongName.isEmpty()) {
                showToast("归属人不能为空")
                return@setDebouncedOnClickListener
            }
            belongId = mUserId //归属人id
            val topicName = viewBinding.topicName.text.toString().trim() //课题组 名称

            if (topicName.isNotBlank()) {
                belongName = topicName
                belongId = viewBinding.topicName.tag.toString() //课题组id
            }

            val chemicalNumber = viewBinding.number.text.toString().trim()//数量
            if (chemicalNumber.isEmpty()) {
                showToast("数量不能为空")
                return@setDebouncedOnClickListener
            }


            val factory = viewBinding.edManufacturer.text.toString().trim() //生产厂家

            var packNum = viewBinding.packNum.text.toString().trim() //包装值
            if (viewBinding.packNum.isEnabled) {
                if (packNum.isEmpty()) {
                    showToast("包装不能为空")
                    return@setDebouncedOnClickListener
                }
            } else {
                packNum = "0"
            }

            val packUnit = viewBinding.packUnit.text.toString().trim() //包装单位
            val specNum = viewBinding.specNum.text.toString().trim() //规格值
            if (specNum.isEmpty()) {
                showToast("规格不能为空")
                return@setDebouncedOnClickListener
            }

            var specUnit = "g"
            if (viewBinding.bugCationsRight.isChecked) {
                specUnit = "ml"
            }
            modelA = ChemicalABean(
                    belongId = belongId,
                    belongName = belongName,
                    casNum = casNum,
                    chemicalCategory = chemicalCategory,
                    chemicalDensity = chemicalDensity.toDouble(),
                    chemicalLevel = chemicalLevel,
                    chemicalName = chemicalName,
                    chemicalNumber = chemicalNumber.toInt(),
                    chemicalPurity = chemicalPurity,
                    factory = factory,
                    isNew = isNew,
                    packNum = BigDecimal(packNum),
                    packUnit = packUnit,
                    specNum = BigDecimal(specNum),
                    specUnit = specUnit,
                    chemicalId = mChemicalId
            )
            getControlConfigs(chemicalNumber)
        }

        ButtonDebouncer.setDebouncedOnClickListener(viewBinding.subAdd, 500L) {
            // 处理按钮点击事件的逻辑代码

            if (mAdapter.data.size > 0) {
                if (modelA.status == 2) {
                    //不需要双人认证
                    if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                        mLockStr.clear()
                        mCabinetLockVoList!!.forEach { it ->
                            when (it.unlockingMethod) {
                                2 -> { //智能锁
                                    mLockStr.add("${it.lockNum}")
                                }
                            }
                        }
                        if (mLockStr != null && mLockStr.size > 0) {
                            openLock(mLockStr)
                        } else {
                            subAddData(0)
                        }
                    } else {
                        subAddData(0)
                    }
                } else {
                    //需要双人认证   1人脸 2刷卡 3扫码
                    if (ChemicalApp.confs!!.verifyType.length == 1) {
                        val map = mutableMapOf<String, Any>()
                        //当前 管控类型
                        map["chemicalLevel"] = modelA.chemicalLevel  //管控类型
                        map["doorId"] = "${viewBinding.cabinet.tag}"  //柜子id
                        map["mTag"] = 0
                        when (ChemicalApp.confs!!.verifyType) {
                            "1" -> {//人脸
                                map["mVerTyps"] = 1

                            }

                            "2" -> {//刷卡
                                map["mVerTyps"] = 2


                            }
                            "3" -> {//扫码
                                map["mVerTyps"] = 3

                            }
                        }

                        UiManager.switcher(
                                this,
                                map,
                                TwoVerificationActivity::class.java
                        )
//                        map["hides"] = 4   //隐藏扫码
//                        when (ChemicalApp.confs!!.verifyType) {
//                            "1" -> {//人脸
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    TwoPersonActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                            "2" -> {//刷卡
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    SwipeCodeTwoActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                            "3" -> {//扫码
//                                UiManager.switcher(
//                                    this,
//                                    map,
//                                    ScanCodeTwoActivity::class.java,
//                                    Constants.REQUEST_CODE
//                                )
//                            }
//                        }
                    } else {
                        verifyChecking()
                    }
                }
            } else {
                showToast("缺少录入信息")
            }
        }
    }

    private fun getControlConfigs(chemicalNumber: String) {

        showLoading("提交中...")
        val disposable = ApiRepository.controlConfigs(modelA.chemicalLevel)
                .subscribe({ data ->
                    dismissLoading()
                    mChemicalConfsBean = data
                    //                searchProducer()
                    certitude(chemicalNumber)
                }, { throwable ->
                    showNetError(throwable)
                    dismissLoading()
                })
        addDisposable(disposable)

    }

    private fun getCheckRfids(rfid: String, tagCode: String, wxCode: String, position: Int) {
        showLoading("查询标签...")
        val disposable = ApiRepository.checkRfids(rfid)
                .subscribe({ data ->
                    dismissLoading()
                    if (data) {
                        customDialogView(2, "rfid标签不能重复,请重新扫描")
                        mLabelDialog!!.getRfidTag(position)
                    } else {
                        if (mChemicalConfsBean.qrCodePrint) {
                            //需要打印
                            val print = PrintBean()
                            print.tag = tagCode  //化学品编码
                            print.wxCode = wxCode
                            print.name = modelA.chemicalName!! //化学品名称
                            if (modelA.casNum != null) {
                                print.casNo = modelA.casNum!!  //cas号
                            } else {
                                print.casNo = ""
                            }
                            print.person = modelA.belongName!! //归属人
                            //管控 1     非管控  2
                            if (modelA.chemicalLevel == 1) {
                                print.level = "管控"
                            } else {
                                print.level = "非管控"
                            }
                            print.types = "${viewBinding.chemType.text}"
                            labelPrint(print)
                        }
                    }
                }, { throwable ->
                    showNetError(throwable)
                    mLabelDialog!!.getRfidTag(position)
                    dismissLoading()
                })
        addDisposable(disposable)
    }

    private fun storageDialogView() {
        val storageDialog =
                StorageDialog(
                        ct = this,
                        listData = mListData!!,
                        lint = object : StorageDialog.IonClickListener {
                            override fun onClick(
                                    cabinetId: String,
                                    cabinetName: String,
                                    doorName: String,
                                    doorId: String,
                                    cabinetLockVoList: List<LockVoListBean>,
                                    layers: Int,
                                    lockNum: String,
                            ) {
                                mCabinetId = cabinetId
                                mCabinetName = cabinetName
                                mDoorId = doorId
                                mDoorName = doorName
                                mLockNum = lockNum
                                mCabinetLockVoList = cabinetLockVoList
                                viewBinding.cabinet.text = "存储位置:${cabinetName}-${doorName}"
                                viewBinding.cabinet.tag = "$doorId"
                                mLayers = layers  //当前需要显示得层数

                                if (mStockModelList != null && mStockModelList.size > 0) {
                                    mStockModelList.forEach {
                                        it.cabinetId = mCabinetId
                                        it.cabinetName = mCabinetName
                                        it.doorId = mDoorId
                                        it.doorName = mDoorName
                                        it.layers = mLayers
                                    }
                                }
                                mAdapter.updateData(mLayers)
                            }

                            override fun onClose() {

                            }
                        })
        storageDialog.show()
    }

    //验证方式
    private fun verifyChecking() {
        val map = mutableMapOf<String, Any>()
        map["chemicalLevel"] = modelA.chemicalLevel  //管控类型
        map["doorId"] = "${viewBinding.cabinet.tag}"  //柜子id
        map["mTag"] = 0
        map["mVerTyps"] = 0
        if (ChemicalApp.confs!!.verifyType == "1,2" || ChemicalApp.confs!!.verifyType == "2,1") {
            //人脸+刷卡
            map["hides"] = 1   //隐藏扫码
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        } else if (ChemicalApp.confs!!.verifyType == "1,3" || ChemicalApp.confs!!.verifyType == "3,1") {
            //人脸+扫码
            map["hides"] = 2   //隐藏刷卡
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        } else if (ChemicalApp.confs!!.verifyType == "2,3" || ChemicalApp.confs!!.verifyType == "3,2") {
            map["hides"] = 3   //隐藏扫码
//            UiManager.switcher(
//                this,
//                map,
//                SwipeCodeTwoActivity::class.java,
//                Constants.REQUEST_CODE
//            )
        } else {
            //人脸+刷卡+扫码
            map["hides"] = 4
//            UiManager.switcher(this, map, TwoPersonActivity::class.java, Constants.REQUEST_CODE)
        }
        UiManager.switcher(
                this,
                map,
                TwoVerificationActivity::class.java,
                Constants.REQUEST_CODE
        )

    }


    private fun initTitle() {
        viewBinding.tvName.text = ChemicalApp.userData!!.userName
        val imageView = viewBinding.imageName
        // 使用 Glide 加载网络图片
        Glide.with(this)
                .load("${HttpConfig.API_BASE_IMG_URL}${ChemicalApp.userData!!.avatar}")
                .apply(RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.AUTOMATIC))
                .into(imageView)
        // 使用 Glide 加载网络图片

        viewBinding.deptName.text = "${ChemicalApp.confs!!.deptName}-${ChemicalApp.confs!!.roomNum}"

        Glide.with(this)
                .load("${HttpConfig.API_BASE_IMG_URL}${ChemicalApp.confs!!.circularLogo}")
                .apply(RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.AUTOMATIC))
                .into(viewBinding.image)

    }

    //确定提交的信息
    private fun certitude(number: String) {
        showLoading("提交中...")
        val disposable = ApiRepository.certitude(modelA)
                .subscribe({ data ->
                    dismissLoading()
                    modelA.chemicalId = data.chemicalId  //化学品id
                    modelA.status = data.status  //是否需要认证
//                val netContent = modelA.chemicalDensity * modelA.specNum  // 净量 = 密度*规格
                    var density = "${modelA.specNum}${modelA.specUnit}/${modelA.packUnit}"
                    mLabelDialog = LabelDialog(this, number, mLayers, density,
                            modelA.chemicalName!!, object : LabelDialog.IRfidClick {

                        override fun onItemClick(
                                modelList: MutableList<StockDetailsModel>?,
                                layer: Int
                        ) {
                            RcLog.info("=======当前7选择 $layer")
                            if (modelList == null) {
                                //取消
                            } else {
                                mStockDetailsModel = modelList
                                mLayersTow = layer
                                RcLog.info("====选择层数的回显 $mLayers")
                                //确定  链接蓝牙
                                mWeighDialog = WeighDialog(
                                        this@AddedChemicalsActivity,
                                        density,
                                        object : WeighDialog.IViewLint {
                                            override fun weighingView(weighingValue: EditText) {
//                                        showLoading("蓝牙连接中...")
                                                mWeighingValue = weighingValue
                                                if (mWeighingValue!!.isEnabled) {
                                                    // EditText允许输入
                                                    // 在这里执行相应的操作
                                                    showToast("请手动输入")
                                                    weiView()
                                                } else {
                                                    // EditText禁止输入
                                                    // 在这里执行相应的操作
                                                    isClisLit = false
                                                    lifecycleScope.launch {
                                                        connectToDeviceWithTimeout()
                                                    }
                                                }

                                                mWeighingValue!!.setOnEditorActionListener { v, actionId, event ->
                                                    if (event?.action == KeyEvent.ACTION_DOWN && event.keyCode == KeyEvent.KEYCODE_ENTER) {
                                                        // 确认是否触发了"actionDone"
                                                        RcLog.info("====键盘测试==1")
                                                        true
                                                    } else {
                                                        RcLog.info("====键盘测试==2  ${mWeighingValue!!.text.toString()}")
                                                        closEnd()
                                                        false
                                                    }
                                                }

                                            }

                                            //确定 关闭  获取文本值 跳转新的页面
                                            override fun viewCloses() {
                                                mHandleScanEvent = false
                                                isClisLit = true
                                                closEndTwo()

                                            }

                                            override fun onMovement() {
                                                showToast("请手动输入")
                                                weiView()
                                            }

                                            override fun onTimerReply() {
                                                stopCountDown()
                                            }
                                        })
                                mWeighDialog!!.show()
                            }
                        }

                        override fun onPrint(
                                tagCode: String,
                                wxCode: String,
                                rfidCode: String,
                                position: Int
                        ) {
                            getCheckRfids(rfidCode, tagCode, wxCode, position)
                        }

                        //根据后台配置进行打印
                        override fun opTageCode(
                                modelList: MutableList<StockDetailsModel>,
                                layer: Int
                        ) {
                            RcLog.info("=======当前6选择 $layer")
                            if (mChemicalConfsBean.qrCodePrint) {
                                showLoading("打印中，请稍等")
                                mStockDetailsModel = modelList
                                mLayersTow = layer
                                mPrintTag = mStockDetailsModel!!.size
                                handlerPrint.startTask(taskPrint, 3000)
                            } else {
                                //打印完成
                                mLabelDialog!!.printingCom()
                            }
                        }
                    })
                    mLabelDialog!!.show()
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)

    }

    private fun weiView() {
        mJoinType = 2
//        try {
//            jobTow?.cancel()
//        } catch (e: Exception) {
//        }
        mWeighingValue!!.isEnabled = true
        mWeighingValue!!.requestFocus()
    }

    private val taskPrint = Runnable {

        if (mPrintTag == 0) {
            //全部打印完成  关闭 并且调用下一步业务
            dismissLoading()
            handlerPrint.stopAllTasks()
            //打印完成
            mLabelDialog!!.printingCom()
        } else {
            // 输出当前循环的值
            val print = PrintBean()
            print.tag = mStockDetailsModel!![mPrintTag - 1].tagCode!!  //化学品编码
            print.wxCode = mStockDetailsModel!![mPrintTag - 1].wxCode!!  //化学品编码
            print.name = modelA.chemicalName!! //化学品名称
            if (modelA.casNum != null) {
                print.casNo = modelA.casNum!!  //cas号
            } else {
                print.casNo = ""
            }

            print.person = modelA.belongName!! //归属人
            //管控 1     非管控  2
            if (modelA.chemicalLevel == 1) {
                print.level = "管控"
            } else {
                print.level = "非管控"
            }
            print.types = "${viewBinding.chemType.text}"
            labelPrint(print)
        }
        mPrintTag--

    }

    //校验当前数据是否合理
    private fun verificationData(model: StockModel) {
        showLoading("查询中...")
        val disposable = ApiRepository.addStockCheck(model)
                .subscribe({ data ->
                    dismissLoading()
                    mStockModelList.add(model)
                    mStockModeBean = StockModeBean(mStockModelList)
                    mAdapter.updateData(mLayers)
                    //创建需要提交的数据源
                    if (mAdapter.data != null && mAdapter.data.size > 0) {
                        mAdapter.setList(mStockModelList)
                    } else {
                        viewBinding.labelView.visibility = View.GONE
                        mAdapter.setNewInstance(mStockModelList.toMutableList())
                    }
                    viewBinding.imgPosition.visibility = View.GONE
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    //types 0  请将化学品放入化学品柜    1 柜门已开，请将化学品放入化学品柜
    private fun subAddData(types: Int) {
        try {// 从 SharedPreferences 中取出集合
            val retrievedList =
                    SharedPreferencesHelper.getList(this@AddedChemicalsActivity)
            if (retrievedList != null && retrievedList.size > 0) {
                SharedPreferencesHelper.clearList(this@AddedChemicalsActivity)
            }
        } catch (e: Exception) {

        }
        showLoading("入库中...")
        val disposable = ApiRepository.stockWaitAdd(mStockModeBean)
                .subscribe({ data ->
                    dismissLoading()
                    mStockModelList.clear()
                    mAdapter.data.clear()
                    mAdapter.notifyDataSetChanged()
                    viewBinding.imgPosition.visibility = View.VISIBLE
                    viewBinding.labelView.visibility = View.VISIBLE
                    if (types == 0) {
                        MediaPlayerHelper.playRawMp3(
                                this,
                                R.raw.qingjianghuaxuekaimen
                        )
                        customDialogView(1, "请将化学品放入化学品柜")
                    } else {
                        MediaPlayerHelper.playRawMp3(this, R.raw.guimenyikai)
                        customDialogView(1, "柜门已开，请将化学品放入化学品柜")
                    }
                    mHandleScanEvent = false
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }


    /**
     * 标签打印
     * 化学品信息
     */
    private fun labelPrint(printDate: PrintBean) {
        if (!pritBot) {
            h = try {//关闭打印
                AutoReplyPrint.INSTANCE.CP_Port_OpenUsb(
                        "VID:0x0FE6,PID:0x811E",
                        1
                )
            } catch (e: Exception) {
                AutoReplyPrint.INSTANCE.CP_Port_OpenUsb(
                        "VID:0x0FE6,PID:0x811E",
                        1
                )
            }
        }

        pritBot = true
        val bitmap = BitmapUtils.generateBitmap(printDate)  //图片信息
        AutoReplyPrint.INSTANCE.CP_Label_BackPaperToPrintPosition(h)
        AutoReplyPrint.CP_Pos_PrintRasterImageFromData_Helper.PrintRasterImageFromBitmap(
                h,
                bitmap!!.width,
                bitmap.height,
                bitmap,
                AutoReplyPrint.CP_ImageBinarizationMethod_Thresholding,
                AutoReplyPrint.CP_ImageCompressionMethod_None
        )
        AutoReplyPrint.INSTANCE.CP_Label_PagePrint(h, 1)
        val result = AutoReplyPrint.INSTANCE.CP_Pos_HalfCutPaper(h) //全切
        if (result) {
            //打印成功
            MediaPlayerHelper.playRawMp3(this, R.raw.huaxuepinbiaoqian)
        }


    }

    private fun closePort() {
        if (h !== Pointer.NULL) {
            AutoReplyPrint.INSTANCE.CP_Port_Close(h)
            h = Pointer.NULL
        }
    }

    var taskStarted = false

    // 声明一个全局的 Handler 变量
    private var mHandlerTime: Handler? = null

    // 在需要执行任务的地方调用这个函数
    private fun delayedTaskToUpdateUI() {
        // 初始化 Handler，并关联到主线程 Looper
        if (isClisLit == false) {
            mHandlerTime = Handler(Looper.getMainLooper())

            // 定义一个延迟执行的任务
            val updateUITask = Runnable {
                RcLog.info("=====执行了")
                // 在这里执行更新 UI 的操作
                // 例如，更新 TextView 的文本
                // textView.text = "Updated text"
                closEnd()
                taskStarted = false
                // 执行完更新操作后，可以关闭 Handler
                mHandlerTime?.removeCallbacksAndMessages(null)
                mHandlerTime = null

            }

            // 延迟 3 秒执行任务
            mHandlerTime?.postDelayed(updateUITask, 3300)
        }
    }


    private suspend fun connectToDeviceWithTimeout() {
        showToast("连接中...", Toast.LENGTH_SHORT)
//        lifecycleScope.launch {

        val deviceAddress = withContext(Dispatchers.IO) {
            BluetoothConnectionManager.getDeviceAddress()
        }
        if (deviceAddress != null) {
            val socket = withContext(Dispatchers.IO) {
                BluetoothConnectionManager.connectToDevice(deviceAddress)
            }
            if (socket != null) {
                // 连接成功后的处理逻辑
                // 在这里使用返回的 BluetoothSocket 对象进行后续操作
                MediaPlayerHelper.playRawMp3(
                        this@AddedChemicalsActivity,
                        R.raw.qing_zheng_zhong
                )
//                    showToast("连接成功", Toast.LENGTH_SHORT)
                // 连接成功后的处理逻辑
                // 切换回主线程更新 UI
                withContext(Dispatchers.Main) {
                    do {
                        val inputStream = socket!!.inputStream
                        val bt = ByteArray(1024)
                        val content = inputStream!!.read(bt)
                        if (content != null && content > 0) {
                            val contents = String(
                                    bt,
                                    0,
                                    content,
                                    StandardCharsets.UTF_8
                            )
                            val split = contents.split("\n")
                            val weight = split[0].trim()
                            RcLog.info("===================称重未处理之前=======$contents")
                            RcLog.info("===================weight=======$weight")
                            RcLog.info("=====称重数据$weight $taskStarted  ${mWeighingValue!!.text.toString()}")
                            if (weight.toDouble() > 2999) {
                                turnOffWeighing()
                            } else {
                                if (weight.toDouble() > 0) {
                                    if (mWeighingValue!!.text.toString().trim()
                                                    .isNotEmpty()
                                    ) {
                                        if (weight.toDouble() == mWeighingValue!!.text.toString()
                                                        .trim().toDouble()
                                        ) {
                                            if (taskStarted == false) {
                                                taskStarted = true
                                                RcLog.info("=====执行了")
                                                socket.close()
                                                delayedTaskToUpdateUI()
                                                break
                                            }
                                        }
                                    }
                                    mWeighingValue!!.setText("$weight")
                                } else {
                                    mWeighingValue!!.setText("")
                                }
                            }
                            RcLog.info("==========蓝牙称 内存测试")
                            delay(200)
                        } else {
                            showToast("请手动输入")
                            weiView()
                            break
                        }
                    } while (true)
                }

            } else {
                // 连接失败的处理逻辑
                showToast("连接失败或超时", Toast.LENGTH_SHORT)
                weiView()
            }
        } else {
            // 根据设备名称获取的设备地址为空，处理无法找到设备的情况
            showToast("找不到设备", Toast.LENGTH_SHORT)
            weiView()
        }
//        }

    }

    private fun showToast(message: String, duration: Int) {
        Toast.makeText(this, message, duration).show()
    }

    //超过量程
    private fun turnOffWeighing() {
        showToast("超过量程,手动输入")
        mJoinType = 2
        mWeighingValue!!.isEnabled = true
//        jobTow?.cancel()
    }

    private fun closEndTwo() {
//        jobTow?.cancel()
        mWeighDialog!!.dismiss()
        emptyViewsTwo()
    }

    private fun closEnd() {
        dismissLoading()
//        jobTow?.cancel()
        mWeighDialog!!.dismiss()
        emptyViewsTwo()
        taskStarted = false
        val weigh =
                mWeighingValue!!.text.toString().trim()  //称重后的重量
        if (weigh.isEmpty()) {
            showToast("未称重")
            return
        }
        if (weigh.toDouble() <= 0) {
            showToast("当前重量有误")
            return
        }
        val topicName = viewBinding.topicName.text.toString()
                .trim() //课题组 名称
        var belongType = 2
        if (topicName.isNotBlank()) {
            belongType = 1
        }

//        val netContent =
//            modelA.chemicalDensity * modelA.specNum  // 净含量 = 密度*规格

        var netContent = BigDecimal(0.0)
        when {
            modelA.specUnit.equals("g") -> {
                netContent = BigDecimal(weigh).subtract(modelA.packNum)
            }
            modelA.specUnit.equals("ml") -> {
                val subtract = BigDecimal(weigh).subtract(modelA.packNum)
                netContent =
                        ConversionUtils.gramsToMilliliters(
                                subtract,
                                BigDecimal(modelA!!.chemicalDensity)
                        )
            }
        }

        RcLog.info("=======当前3选择 $mLayers")
        var model = StockModel(
                "${modelA.belongId}",
                "${modelA.belongName}",
                belongType,
                mChemicalInfoBean!!.buildId,
                mChemicalInfoBean!!.buildName,
                mCabinetId,
                mCabinetName,
                modelA.casNum,
                modelA.chemicalCategory!!.toInt(),
                modelA.chemicalId!!,
                modelA.chemicalLevel,
                modelA.chemicalName!!,
                "${mStockDetailsModel!!.size}",
                modelA.chemicalPurity,
                mChemicalInfoBean!!.deptId,
                mChemicalInfoBean!!.deptName,
                viewBinding.cabinet.tag.toString(),
                mDoorName,
                modelA.factory!!,
                mChemicalInfoBean!!.floorId,
                mChemicalInfoBean!!.floorName,
                modelA.isNew,
                mJoinType,   //入库方式1 称重，2 录入
                "", //视频地址
                mLayersTow,     //当前选择得
                mLayers,     //一共几层
                modelA.packNum,
                modelA.packUnit!!,
                modelA.specNum.toDouble(),
                modelA.specUnit!!,
                mStockDetailsModel,
                6,
                mChemicalInfoBean!!.subId,
                mChemicalInfoBean!!.subName,
                mChemicalInfoBean!!.roomNum,
                null,
                mWeighingValue!!.text.toString().toDouble(),
                netContent.toDouble(),
                expireTime = null
        )
        verificationData(model)
    }


    private fun inAdapter() {
        viewBinding.recyclerViewList?.layoutManager =
                LinearLayoutManager(this)
        viewBinding.recyclerViewList?.adapter = mAdapter
        mAdapter.setOnItemChildClickListener { adapter, view, position ->
            // 在这里处理子View的点击事件
            when (view.id) {
                R.id.imgDelete -> {
                    mAdapter.data.removeAt(position)
                    mStockModelList = mAdapter.data
                    mAdapter.notifyItemRemoved(position)
                    RcLog.info("=======当前条数 ${mStockModelList!!.size}")
                    if (mStockModelList!!.size == 0) {
                        RcLog.info("=======当前条数 ${mStockModelList!!.size}")
                        viewBinding.imgPosition.visibility = View.VISIBLE
                    }
                }
            }
        }
    }

    override fun initData() {
        super.initData()
        val handler = Handler(Looper.getMainLooper())
        timeUpdater = TimeUpdater(handler) { currentTime ->
            viewBinding.nowTime.text = "$currentTime"
        }
        // 启动定时更新
        timeUpdater.startUpdating()

        getRelList(ChemicalApp.subjectId!!)

    }


    //查询存储位置  默认第一个
    private fun getCabinet(subId: String) {
        showLoading("查询中...")
        val disposable = ApiRepository.getCabinetList(subId)
                .subscribe({ data ->
                    dismissLoading()
                    mListData = data
                    viewBinding.cabinet.text =
                            "存储位置:${mListData!![0].cabinetName}-${mListData!![0].cabinetDoorVoList[0].doorName}"
                    viewBinding.cabinet.tag =
                            "${mListData!![0].cabinetDoorVoList[0].doorUniqueId}"
                    mCabinetLockVoList =
                            mListData!![0].cabinetDoorVoList[0].cabinetLockVoList  //柜锁几条
                    mLayers =
                            mListData!![0].cabinetDoorVoList[0].doorLayers//当前几层

                    mCabinetId = mListData!![0].cabinetId
                    mCabinetName = mListData!![0].cabinetName
                    mDoorId = mListData!![0].cabinetDoorVoList[0].doorUniqueId
                    mDoorName = mListData!![0].cabinetDoorVoList[0].doorName
                    mLockNum = mListData!![0].lockNum

                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }

    // 获取实验室基本信息
    private fun getRelList(subjectId: String) {
        showLoading("加载中...")
        val disposable = ApiRepository.getRelList(subjectId)
                .subscribe({ data ->
                    dismissLoading()
                    mChemicalInfoBean = data

                    getCabinet(mChemicalInfoBean!!.subId)
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)

                })
        addDisposable(disposable)
    }

    //化学品/cas搜索
    private fun searchChemica(
            searchValue: String,
            chemicalLevel: String?
    ) {
//        val chemicalName = viewBinding.chemicalName.text.toString()
//        val cas = viewBinding.casNum.text.toString()
        RcLog.info("=============管控搜索$searchValue $chemicalLevel")
        showLoading("加载中...")
        val disposable =
                ApiRepository.searchChemica(searchValue, chemicalLevel)
                        .subscribe({ data ->
                            dismissLoading()
                            val mDialog =
                                    DcaeDialog(
                                            this,
                                            data.toMutableList(),
                                            object : DcaeDialog.IonItemClick {
                                                override fun onItem(chemicalSearchBean: ChemicalSearchBean) {
                                                    upView(chemicalSearchBean)
                                                }
                                            })
                            mDialog.show()
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)

                        })
        addDisposable(disposable)
    }

    //查询结果  更新回显信息
    private fun upView(chemicalSearchBean: ChemicalSearchBean) {
        mChemicalId = chemicalSearchBean.chemicalId
        viewBinding.chemicalName.setText("${chemicalSearchBean.chemicalName}")
        if (chemicalSearchBean.casNum != null) {
            viewBinding.casNum.setText("${chemicalSearchBean.casNum}")
        }
        viewBinding.chemicalDensity.setText("${chemicalSearchBean.chemicalDensity}")
        if (chemicalSearchBean.chemicalPurity != null) {
            viewBinding.chemicalPurity.setText("${chemicalSearchBean.chemicalPurity}")
        }
        if (chemicalSearchBean.specNum != null) {
            viewBinding.specNum.setText("${chemicalSearchBean.specNum}")
        }
        if (chemicalSearchBean.depositUnit != null) {
            when (chemicalSearchBean.depositUnit) {
                "L" -> { //升
                    viewBinding.bugCationsRight.isChecked = true
                    viewBinding.bugCationsLeft.isChecked = false
                    viewBinding.bugCationsLeft.isEnabled = false
                    viewBinding.packUnit.text = "瓶"
                }
                "KG" -> { //千克
                    viewBinding.bugCationsLeft.isChecked = true
                    viewBinding.bugCationsRight.isChecked = false
                    viewBinding.bugCationsRight.isEnabled = false
                    viewBinding.packUnit.text = "件"
                }
                "g" -> { //克
                    viewBinding.bugCationsLeft.isChecked = true
                    viewBinding.bugCationsRight.isChecked = false
                    viewBinding.bugCationsRight.isEnabled = false
                    viewBinding.packUnit.text = "件"

                }
                "ml" -> {//毫升
                    viewBinding.bugCationsRight.isChecked = true
                    viewBinding.bugCationsLeft.isChecked = false
                    viewBinding.bugCationsLeft.isEnabled = false
                    viewBinding.packUnit.text = "瓶"
                }
            }
        }

        if (chemicalSearchBean.packNum != null) {
            viewBinding.packNum.setText("${chemicalSearchBean.packNum}")
        }

        chemTypeIsBoo = false
        if (chemicalSearchBean.chemicalCategory != null) {
            viewBinding.chemType.text = "${chemicalSearchBean.chemicalCategoryName}"
            viewBinding.chemType.tag = "${chemicalSearchBean.chemicalCategory}"
        }

        viewBinding.bugCationsLeft.isEnabled = false
        viewBinding.bugCationsRight.isEnabled = false
        if (chemicalSearchBean.chemicalLevel == 2) {
            viewBinding.butUnregulated.isChecked = true
            viewBinding.butControl.isChecked = false
        } else {
            viewBinding.butControl.isChecked = true
            viewBinding.butUnregulated.isChecked = false
        }
    }


    //厂家搜索
    private fun searchProducer() {
        val disposable = ApiRepository.searchProducer()
                .subscribe({ data ->
                    mOptionsList.clear()
                    data.forEach {
                        mOptionsList.add(it.producerName)
                    }
//                    val adapter =
//                            ArrayAdapter(this, android.R.layout.simple_dropdown_item_1line, mOptionsList)

                    // 创建 ArrayAdapter 并使用自定义布局
                    val adapter = object : ArrayAdapter<String>(this, R.layout.dropdown_item, R.id.text, mOptionsList) {
                        override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
                            val view = super.getView(position, convertView, parent)
                            val textView: TextView = view.findViewById(R.id.text)
                            // 设置字体大小
                            textView.textSize = 10f
                            // 设置行高
                            val params = textView.layoutParams
                            params.height = 30 // 设置行高为 60 像素
                            textView.layoutParams = params
                            return view
                        }
                    }

                    viewBinding.edManufacturer.setAdapter(adapter)
                }, { throwable ->
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    //规格值查询包装值
    private fun searchSpecView(specNum: String) {
        val disposable = ApiRepository.searchSpec(specNum)
                .subscribe({ data ->
                    if (data != null) {
                        if (data.packNum != null) {
                            viewBinding.packNum.setText("${data.packNum}")
                        }
                    }
                }, { throwable ->
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }


    override fun onDestroy() {
        super.onDestroy()
        // 停止定时更新
        timeUpdater.stopUpdating()
//        jobTow?.cancel()

        mPortScanHelper.onPause()
        // 停止定时任务
        try {
            handlerUtil.stopAllTasks()
            countdownTimer?.cancel()
//            timerLock.cancel()
            closePort()
        } catch (e: Exception) {
        }
        try {
            timeUpdater.stopUpdating()
        } catch (e: Exception) {
        }
        // 停止定时更新
        unregisterReceiver(mUsbReceiver)
        EventBus.getDefault().unregister(this) //关闭广播
    }

    //清空所有试图  进行新的录入
    private fun emptyViews() {
        viewBinding.chemicalName.setText("")
        viewBinding.casNum.setText("")
        viewBinding.edManufacturer.setText("")
        viewBinding.chemicalPurity.setText("")
        viewBinding.chemicalDensity.setText("1")
        viewBinding.specNum.setText("")
        viewBinding.packNum.setText("")
        viewBinding.number.setText("1")
        viewBinding.packUnit.text = "瓶"
        viewBinding.chemType.text = ""
        viewBinding.topic.text = "搜索"
        hideKeyboard()
        if (mStockModelList != null) {
            mStockModelList.clear()
        }
        closeKeyboard(viewBinding.number)
        closeKeyboard(viewBinding.chemicalName)
        closeKeyboard(viewBinding.casNum)
        closeKeyboard(viewBinding.edManufacturer)
        closeKeyboard(viewBinding.chemicalPurity)
        closeKeyboard(viewBinding.chemicalDensity)
        closeKeyboard(viewBinding.specNum)
        closeKeyboard(viewBinding.packNum)
        closeKeyboard(viewBinding.number)
        mHandleScanEvent = false

    }

    private fun hideKeyboard() {
        val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(currentFocus?.windowToken, 0)
    }

    //清空所有试图  进行新的录入
    private fun emptyViewsTwo() {
        viewBinding.chemicalName.setText("")
        viewBinding.casNum.setText("")
        viewBinding.edManufacturer.setText("")
        viewBinding.chemicalPurity.setText("")
        viewBinding.chemicalDensity.setText("1")
        viewBinding.specNum.setText("")
        viewBinding.packNum.setText("")
        viewBinding.number.setText("1")
        viewBinding.packUnit.text = "瓶"
        viewBinding.chemType.text = ""
        viewBinding.topic.text = "搜索"
        closeKeyboard(viewBinding.chemicalName)
        closeKeyboard(viewBinding.casNum)
        closeKeyboard(viewBinding.edManufacturer)
        closeKeyboard(viewBinding.chemicalPurity)
        closeKeyboard(viewBinding.chemicalDensity)
        closeKeyboard(viewBinding.specNum)
        closeKeyboard(viewBinding.packNum)
        closeKeyboard(viewBinding.number)
    }

    private fun closeKeyboard(editText: EditText) {
        editText.clearFocus()
    }

    //=========================刷卡start================
    //刷卡信息  调用当前化学品信息 进行归还
    private fun handleScanEvent(cont: String) {
        RcLog.info("=====刷卡信息$cont")
        showLoading("查询中...")
        val disposable =
//            ApiRepository.chemicalSearchBean("202310160919545345", ChemicalApp.subjectId!!)
                ApiRepository.chemicalSearchBean(cont, ChemicalApp.subjectId!!)
                        .subscribe({ data ->
                            dismissLoading()
                            upView(data)
                        }, { throwable ->
                            dismissLoading()
                            showNetError(throwable)
                            mHandleScanEvent = false
                        })
        addDisposable(disposable)
    }


    private val mPortScanHelper by lazy {
        PortScanHelper(this, object : OnSerialScanListener {
            override fun dispatchScanEvent(
                    type: OnSerialScanListener.ScanType,
                    content: String
            ) {
                if (!mHandleScanEvent) {
                    if (content.isNotBlank()) {
                        mHandleScanEvent = true
                        handleScanEvent(content)
                    }
                }
            }

        })
    }

    //刷卡usb链接
    private fun registerUsbBroadcast() {
        if (null == mUsbReceiver) {
            val filter = IntentFilter().apply {
                addAction(UsbReceiver.ACTION_USB_PERMISSION)
                addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED)
                addAction(UsbManager.ACTION_USB_DEVICE_DETACHED)
                addAction(UsbReceiver.ACTION_USB_STATE) // usb连接状态广播
            }
            mUsbReceiver = UsbReceiver()
            registerReceiver(mUsbReceiver, filter)
        }
    }

    override fun onResume() {
        super.onResume()
        mPortScanHelper.onResume()
        registerUsbBroadcast()
        try {
            if (Constants.AUTHENTICATION) {
                try {// 从 SharedPreferences 中取出集合
                    val retrievedList =
                            SharedPreferencesHelper.getList(this@AddedChemicalsActivity)
                    if (retrievedList != null && retrievedList.size > 0) {
                        RcLog.info("===a===${retrievedList[0].userId}")
                        if (mStockModelList != null && mStockModelList.size > 0) {
                            mStockModelList.forEach {
                                it.oneUserId = "${retrievedList[0].userId}"
                                it.oneUserName = "${retrievedList[0].name}"
                                it.twoUserId = "${retrievedList[1].userId}"
                                it.twoUserName = "${retrievedList[1].name}"
                            }
                        }
//                        // 清空 SharedPreferences 中的集合
//                        SharedPreferencesHelper.clearList(this@AddedChemicalsActivity)
                    }
                } catch (e: Exception) {

                }
                //1无锁，2是智能锁，3是钥匙柜
                if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
                    mLockStr.clear()
                    mCabinetLockVoList!!.forEach { it ->
                        when (it.unlockingMethod) {
                            2 -> { //智能锁
                                mLockStr.add("${it.lockNum}")
                            }
                        }
                    }
                    if (mLockStr != null && mLockStr.size > 0) {
                        openLock(mLockStr)
                    } else {
                        subAddData(0)
                    }
                } else {
                    subAddData(0)
                }
                Constants.AUTHENTICATION = false
            }
        } catch (e: Exception) {
            Constants.AUTHENTICATION = false

        }

    }

    //获取刷卡信息
    override fun dispatchKeyEvent(event: KeyEvent?): Boolean {
        mPortScanHelper.dispatchKeyEvent(event)
        return super.dispatchKeyEvent(event)
    }

    //停止 销毁广播传递
    override fun onPause() {
        mPortScanHelper.onPause()
        super.onPause()
    }


    //必须写这个方法  防止注册失败
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onUpdateEventEvent(event: KeyEvent) {

    }


    //=========================刷卡end==================


    override fun onBackPressed() {
        super.onBackPressed()
        finish()
    }


    override fun onActivityResult(
            requestCode: Int,
            resultCode: Int,
            data: Intent?
    ) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == Constants.REQUEST_CODE && resultCode == Activity.RESULT_OK) {
            val value = data?.getBooleanExtra("isLogin", false) // 获取返回的参数
            if (value == true) {
//                //1无锁，2是智能锁，3是钥匙柜
//                if (mCabinetLockVoList != null && mCabinetLockVoList!!.size > 0) {
//                    mCabinetLockVoList!!.forEach { it ->
//                        when (it.unlockingMethod) {
//                            2 -> { //智能锁
//                                mLockStr.add("${it.lockNum}")
//                            }
//                        }
//                    }
//                    if (mLockStr != null && mLockStr.size > 0) {
//                        openLock(mLockStr)
//                    } else {
//                        subAddData()
//                    }
//                } else {
//                    subAddData()
//                }
            } else {
                showToast("认证失败!!")
            }
        }
    }

    override fun cdTime(cd: Int) {
        viewBinding.tvReturn.text = "返回${cd}s"
    }

    //开锁
    private fun openLock(mLockStr: ArrayList<String>) {
        val map = mutableMapOf<String, Any>()
        map["subId"] = mStockModeBean.stockModelList[0].subId
        map["subName"] = mStockModeBean.stockModelList[0].subName
        map["cabinetId"] = "$mCabinetId"
        map["cabinetName"] = "$mCabinetName"
        map["doorId"] = "$mDoorId"
        map["doorName"] = "$mDoorName"
//        map["lockNum"] = "guisuo001"
        map["lockNumList"] = mLockStr
        map["operationType"] = 1
        if (ChemicalApp.subRoom != null) {
            map["subRoom"] = ChemicalApp.subRoom!!
        }
        map["type"] = true
        try {// 从 SharedPreferences 中取出集合
            val retrievedList = SharedPreferencesHelper.getList(this)
            if (retrievedList != null && retrievedList.size > 0) {
                RcLog.info("===b===${retrievedList[0].userId}")
                map["oneUserId"] = "${retrievedList[0].userId}"
                map["oneUserName"] = "${retrievedList[0].name}"
                map["twoUserId"] = "${retrievedList[1].userId}"
                map["twoUserName"] = "${retrievedList[1].name}"
                // 清空 SharedPreferences 中的集合
//                SharedPreferencesHelper.clearList(this)
            }
        } catch (e: Exception) {
        }

        showLoading("加载中...")
        val disposable = ApiRepository.lockOperate(map)
                .subscribe({ data ->
                    dismissLoading()
                    val containsFalse =
                            mCabinetLockVoList!!.any { it.isOk == false && it.unlockingMethod == 2 }
                    if (containsFalse) {
                        showLoading("查询中...")
                        // 开始执行任务，每 3 秒执行一次
                        startCountdownLock()
                        handlerUtil.startTask(task, 1000)
                    } else {
                        try {
                            countdownTimer?.cancel()
                        } catch (e: Exception) {
                        }
                        dismissLoading()
                        //开锁成功
                        subAddData(1)
                        handlerUtil.stopAllTasks()
                    }
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)

    }

    private var countdownTimer: CountDownTimer? = null
    private fun startCountdownLock() {
        val totalTime = 30 * 1000 // 30秒
        val interval = 1000 // 每秒更新一次
        countdownTimer = object : CountDownTimer(totalTime.toLong(), interval.toLong()) {
            override fun onTick(millisUntilFinished: Long) {
                val secondsLeft = millisUntilFinished / 1000
                println("剩余时间: $secondsLeft 秒")
            }

            override fun onFinish() {
                println("倒计时结束！")
                mCabinetLockVoList = null
                mLockStr.clear()
                showToast("开锁超时,可重新操作")
                dismissLoading()
                handlerUtil.stopAllTasks()
                // 在这里执行合适的操作，比如退出应用程序
            }
        }
        println("倒计时开始...")
        countdownTimer?.start()

    }


    private val task = Runnable {
        //判断所有的锁开锁成功
        val containsFalse =
                mCabinetLockVoList!!.any { it.isOk == false && it.unlockingMethod == 2 }
        if (containsFalse) {
            getLocks()
        } else {
            try {
                countdownTimer?.cancel()
            } catch (e: Exception) {
            }
            dismissLoading()
            //开锁成功
            subAddData(1)
            handlerUtil.stopAllTasks()
        }
    }


    //查询开锁信息
    private fun getLocks() {
        mCabinetLockVoList!!.forEachIndexed { index, fruit ->
            if (fruit.isOk == false && fruit.unlockingMethod == 2) {
                getLocksDate(index, fruit.lockNum)
            }
        }
    }

    //查询开锁状态
    private fun getLocksDate(index: Int, fruit: String) {
        val disposable = ApiRepository.getLocks(ChemicalApp.subjectId!!, fruit)
                .subscribe({ data ->
                    if (data) {
                        mCabinetLockVoList!![index].isOk = true
                    }
                }, { throwable ->
                    dismissLoading()
                    showNetError(throwable)
                })
        addDisposable(disposable)
    }

    /**
     * 0  没有图标 1 绿色(成功)   2红色（失败）
     *   失败或者成功的弹框
     */
    private fun customDialogView(types: Int, msg: String) {
        val customDialog = CustomDialog(this, types, msg)
        customDialog.show()
    }

    /**
     * 异常处理
     */
    private fun throwableView(throwable: Throwable) {
        when (throwable) {
            is NetException -> {
                if (throwable.message.isNullOrEmpty()) {
                    "接口请求失败(${throwable.code})"
                } else {
                    throwable.message!!
                }
            }
            is SocketTimeoutException -> "请求超时，请稍后重试"
            is ConnectException -> "无法连接服务器，请检查网络"
            is HttpException -> "服务器繁忙，请稍后重试"
            else -> null
        }?.let { customDialogView(2, "$it") }
    }

}