How to return boolean when using coroutines kotlin

I get the error The boolean literal does not conform to the expected type Unit when run code. Please help me fix it

public suspend fun RequireDevice(manager: UsbManager, device: UsbDevice): UsbDevice? {
    // 多重要求にならないようにする - Tránh nhiều yêu cầu
    if(permissionContinuation != null)
        return null
    // requestPermissionを実行
    val device = suspendCoroutine<UsbDevice?> {
        manager.requestPermission(device, mPermissionIndent)
        permissionContinuation = it
    }
    // continuationを消去
    permissionContinuation = null
    return device
}

function selectDevice

fun selectDevice(vendorId: Int, productId: Int): Boolean {
    if ((mUsbDevice == null) || (mUsbDevice!!.vendorId != vendorId) || (mUsbDevice!!.productId != productId)) {
        closeConnectionIfExists()
        connectScope.launch label@{
            val usbDevices: List<UsbDevice> = deviceList
            for (usbDevice: UsbDevice in usbDevices) {
                if ((usbDevice.vendorId == vendorId) && (usbDevice.productId == productId)) {
                    Log.v(LOG_TAG, "Request for device: vendor_id: " + usbDevice.vendorId + ", product_id: " + usbDevice.productId)
                    closeConnectionIfExists()
                    val grantedDevice = RequireDevice(mUSBManager!!, usbDevice)
                    if (grantedDevice != null){
                        Log.v(LOG_TAG, "Connected")
                        state = STATE_USB_CONNECTING
                        mHandler?.obtainMessage(STATE_USB_CONNECTING)?.sendToTarget()
                        return@label true
                    }  
                    else{
                        Log.v(LOG_TAG, "Connection failed.")
                        return@label false
                    } 
                }
            }
        }
    } else {
        mHandler?.obtainMessage(state)?.sendToTarget()
        return true
    } 
}

BroadcastReceiver

private val mUsbDeviceReceiver: BroadcastReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val action = intent.action
        if ((ACTION_USB_PERMISSION == action)) {
            synchronized(this) {
                val usbDevice: UsbDevice? = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
                if (intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                    Log.i(
                        LOG_TAG,
                        "Success get permission for device ${usbDevice?.deviceId}, vendor_id: ${usbDevice?.vendorId} product_id: ${usbDevice?.productId}"
                    )
                    mUsbDevice = usbDevice
                    openConnection()
                    permissionContinuation!!.resume(usbDevice)
                    state = STATE_USB_CONNECTED
                    mHandler?.obtainMessage(STATE_USB_CONNECTED)?.sendToTarget()
                } else {
                    permissionContinuation!!.resume(null)
                    Toast.makeText(context, "User refused to give USB device permission: ${usbDevice?.deviceName}", Toast.LENGTH_LONG).show()
                    state = STATE_USB_NONE
                    mHandler?.obtainMessage(STATE_USB_NONE)?.sendToTarget()
                }
            }
        } else if ((UsbManager.ACTION_USB_DEVICE_DETACHED == action)) {

            if (mUsbDevice != null) {
                Toast.makeText(context, "USB device has been turned off", Toast.LENGTH_LONG).show()
                closeConnectionIfExists()
                state = STATE_USB_NONE
                mHandler?.obtainMessage(STATE_USB_NONE)?.sendToTarget()
            }

        } else if ((UsbManager.ACTION_USB_DEVICE_ATTACHED == action)) {
        }
    }
}

Error:

e:USBPrinterService.kt: (139, 42): The boolean literal does not conform to the expected type Unit

Error 2:
e:USBPrinterService.kt: (143, 42): The boolean literal does not conform to the expected type Unit
Error 3:
e:USBPrinterService.kt: (154, 5): A 'return' expression required in a function with a block body ('{...}')

> The boolean literal does not conform to the expected type Unit

You're facing this error because the lambda passed to launch is not expected to return any useful value. Its return type is Unit, which is used in functions for which we don't expect any particular result, and you're trying to return a Boolean out of it, which doesn't match the return type.

In order to return a value, you would need to use async instead of launch. This way, the lambda can indeed return a value (here, a Boolean), and the async function itself will return a Deferred<Boolean> representing the future boolean value that will get when the task completes. However, there is a deeper problem here that you need to understand first.

You have to understand that this function signature denotes a synchronous function:

fun selectDevice(vendorId: Int, productId: Int): Boolean {
   ...
}

It means it blocks the calling thread until the result is returned, because it's not suspend and the Boolean value is returned directly (not via a callback or a Future or Deferred).

However, inside this function, you're trying to launch an asynchronous task (with the launch function), but you somehow still want to return the result from it. That's not how launch works. Because the task is asynchronous, the call to launch returns before the task is completed, and possibly even before the task starts at all. As we've also seen above, launch doesn't return any value itself. In fact, even if you change it to async, the async { .. } function call will not return the value directly, but a Deferred<Boolean> (as we've seen). This wrapper would be returned immediately (before the task completes or even starts), so you would then have to wait for this value to be ready somehow anyway.

Basically, with the signature you chose for selectDevice, you don't have a choice but to block the current thread until the value is ready, which kinda defeats the purpose of coroutines. Instead, it would be best if you made selectDevice a suspend function itself, so you can call suspend functions inside without launching new coroutines.

If you want to stick with the blocking signature, then you have to block the thread to wait for the value, for instance using runBlocking { deferred.await() }.