Function Android studio说，当我调用kotlin代码中较低的函数时出现错误，我是否设置了错误

AndroidStudio说，当我调用kotlin代码中较低的函数时，会出现“未解决的引用：连接”错误，我是否设置了错误。只要函数在调用之上，它就可以工作，但我不能像调用单过程编译器那样调用代码中较低的函数。Below con=connect（）会导致一个错误，但我有一个相同的调用，代码在函数下面，可以正常工作

    class MainActivity() : AppCompatActivity() {

    private val handler= Handler()


    private enum class UsbPermission {
        Unknown, Requested, Granted, Denied
    }
    lateinit var _usbManager: UsbManager
//    lateinit var device: UsbDevice
    //private val _context: Context = context
//    private var _errorMessage: String = ""
    private var _connected: Boolean = false
//    private var _deviceName: String = ""
//    private var _device: UsbDevice? = null
    private lateinit var _serial: UsbSerialPort
//    private var _receiveBuffer = Vector<Byte>()

    private val withIoManager = false

    private var broadcastReceiver: BroadcastReceiver? = null
//    private var mainLooper: Handler? = null
//    private val receiveText: TextView? = null
//    private val controlLines: ControlLines? = null

    private var usbIoManager: SerialInputOutputManager? = null
//    val device: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
//    private val usbSerialPort: UsbSerialPort? = null
    private var usbPermission: UsbPermission = UsbPermission.Unknown

    private val INTENT_ACTION_GRANT_USB = BuildConfig.APPLICATION_ID + ".GRANT_USB"
//    private val WRITE_WAIT_MILLIS = 2000
//    private val READ_WAIT_MILLIS = 2000

//    private val ACTION_USB_PERMISSIONs = "com.android.example.USB_PERMISSION"
    val ACTION_USB_PERMISIION = "permission"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        window.requestFeature(Window.FEATURE_NO_TITLE)

        window.setFlags(
            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
            WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
        )
        setContentView(R.layout.activity_main)

        _usbManager = getSystemService(USB_SERVICE) as UsbManager
//        val deviceList = _usbManager.getDeviceList()
//        val device = deviceList.get("deviceName")

//        val permissionIntent = PendingIntent.getBroadcast(this, 0, Intent(ACTION_USB_PERMISSIONs), 0)
//        _usbManager.requestPermission(device, permissionIntent)
        val filter = IntentFilter()
        filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED)
        filter.addAction(UsbManager.ACTION_USB_ACCESSORY_ATTACHED)
        filter.addAction(ACTION_USB_PERMISIION)
        registerReceiver(broadcastReceiver, filter)

---

您的KotlinRuntime库似乎未附加到项目。在“项目结构”下查看一下，如果有，您可以尝试删除它，然后运行“工具->Kotlin->在项目中配置Kotlin”

，错误是…？“未解决的引用：连接”错误您可以发布更多的代码吗？也许你把connect（）放在了包含onRunError（）或类似内容的类之外。据我所知（可能不多），它们在同一个类中，因为我认为我只有一个“MainActivity”，代码非常混乱，而且它不是该活动的完整代码。您能否发布一个完整活动的版本，并删除方法中的所有代码？然后它会更短，我们可以更好地看到结构。另外-是在构建应用程序时显示错误，还是直接在编辑器中显示错误？编辑器中是否显示任何错误？例如，编辑器窗口的右上角是否有一个红色感叹号？）我添加了更多的代码，我检查了“项目结构”，看起来还不错（不过我是Android Studio的新手）。运行“工具->Kotlin->在项目中配置Kotlin”，并表示所有模块都已配置。

        val ctson = Runnable {
            if (con == true) {
                _serial.setRTS(true)
            }
        }

        val mListener: Listener =
            object : Listener {

                override fun onNewData(data: ByteArray) {
//                    mainLooper.post(() -> {
                    if (efitable == 1) {
                        for (i in 0 until data.size) table[len + i] = data[i] //fuel table
                        len = len + data.size
                        //                    _serial.setRTS(false)
                        //len = receive(387, 400)
                        if (len >= 8187) { // && efitable==1) {
                            _serial.setRTS(false)
                            efichk = 0
                            len = 0
                            for (i in 0 until 8184) efichk = efichk + (table[i].toInt() and 0xFF)
                            efichk = (efichk and 0xFFFF)
                            chktst =
                                (table[8185].toInt() and 0xFF shl 8 or (table[8184].toInt() and 0xFF)).toInt()
                            if (efichk == chktst) {
                                efitable = 2
                                etable(table) //extract data from table
                                _serial.write("R".toByteArray(), 4)
                                _serial.setRTS(true)
                                sergo = 0
                            } else {
                                efitable = 0
                                _serial.purgeHwBuffers(true, true)
                                _serial.write("R".toByteArray(), 4)
                                _serial.setRTS(true)
                                sergo = 0
                            }
                        }
                    } else { //if(efitable==0 || efitable==2){
                        for (i in 0 until data.size) rsdash[len + i] = data[i]
                        len = len + data.size
                        if (len >= 387) {  // && (efitable==0 || efitable==2)) {
                            _serial.setRTS(false)
                            len = 0
                            chksum = 0
                            for (i in 0 until 384) chksum = chksum + (rsdash[i].toInt() and 0xFF)
                            chksum = (chksum and 0xFFFF)
                            chktst =
                                (rsdash[385].toInt() and 0xFF shl 8 or (rsdash[384].toInt() and 0xFF)).toInt()
                            if (chksum == chktst) {
                                if (efitable == 0) {
                                    efitable = 1
                                    sergo = 20
                                    _serial.write("X".toByteArray(), 4) //88
                                    display(rsdash)
                                    _serial.setRTS(true)
                                } else {
                                    if (save == 2) {
                                        _serial.write("U".toByteArray(), 4) //85
                                        efichk = 0
                                        for (i in 0 until 8184) efichk =
                                            efichk + (table[i].toInt() and 0xFF)
                                        table[8184] = (efichk and 0xFF0000 shr 16).toByte()
                                        table[8185] = (efichk and 0xFF00 shr 8).toByte()
                                        table[8186] = (efichk and 0xFF).toByte()
                                        _serial.write(table, 1200) //85
                                        efichk = (efichk and 0xFFFF)
                                        save = 0
                                        _serial.setRTS(true)
                                    } else {
                                        _serial.write("R".toByteArray(), 4) //82
                                        if (exit > 1) {
                                            sergo = 1
                                            if (con == true) {
                                                _serial.setRTS(false)
                                                _serial.close()
                                                _connected = false
                                                con = false
                                            }
                                        } else {
                                            display(rsdash)
                                            handler.postDelayed(ctson, 37)
                                            sergo = 0
                                        }
                                    }
                                }
                            } else {
                                _serial.write("R".toByteArray(), 4)
                                for (i in 0 until 100) Thread.sleep(1)
                                _serial.purgeHwBuffers(true, true)
                                _serial.setRTS(true)
                                _serial.purgeHwBuffers(true, true)
                            }
                        }
                    }
//                })
                }

                override fun onRunError(e: Exception) {
                    len = 0
                    if (con == true) {
                        _serial.setRTS(false)
                        _serial.close()
                        _connected = false
                        con = false
                        con = connect()  //This line causes the "Unresolved reference: connect" error
                    }
/*                   _serial.setRTS(false) // original code to try to recover serial port
                    _serial.write("R".toByteArray(), 4)
                    len = 0
                    for (i in 0 until 120) Thread.sleep(1)
                    _serial.purgeHwBuffers(true, true)
                    _serial.setRTS(true)
*/              



            }


        fun connect(): Boolean {
            val drivers = UsbSerialProber.getDefaultProber().findAllDrivers(_usbManager)
            if (drivers.isEmpty()) {
                return false
            }

            val driver = drivers[0]
            val _connection = _usbManager.openDevice(driver.device)
            if (_connection == null) {
                _connected = false
                return false
            }

            val port = driver.ports[0]
            if (port == null) {
                _connected = false
                return false
            }

            try {
                port.open(_connection)
                port.setParameters(
                    115200,
                    8,
                    UsbSerialPort.STOPBITS_1,
                    UsbSerialPort.PARITY_NONE
                )
                port.purgeHwBuffers(true, true)
                _serial = port
                _connected = true

//                if (withIoManager) {
//                    usbIoManager = SerialInputOutputManager(usbSerialPort)
//                    Executors.newSingleThreadExecutor().submit(usbIoManager)
//                }
                //usbIoManager = SerialInputOutputManager(_serial,this)
                usbIoManager = SerialInputOutputManager(_serial, mListener)
                Executors.newSingleThreadExecutor().submit(usbIoManager)
//                val submit = Executors.newSingleThreadExecutor().submit(usbIoManager)
//                Executors.newSingleThreadExecutor().asCoroutineDispatcher(usbIoManager)

                _serial.setRTS(true)
                return true

            } catch (e: IOException) {
                //e.printStackTrace()

                if(_connected==true){port.close()}
                _connected = false
                return false
            }
        }
//        mainLooper = Handler(Looper.getMainLooper())

        broadcastReceiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                if (intent.action == INTENT_ACTION_GRANT_USB) {
                    usbPermission = if (intent.getBooleanExtra(
                            UsbManager.EXTRA_PERMISSION_GRANTED,
                            false
                        )
                    ) UsbPermission.Granted else UsbPermission.Denied
                    con=connect()
                }
            }
        }
        //mainLooper = Handler(Looper.getMainLooper())