native-mt

sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("com.juul.kable:core:0.7.0")  // here the version of Coroutine is 1.5.0
            }
        }

        val androidMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1") // here the version of Coroutine is greater // line 10
            }
        }

        val nativeMain by creating {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1-native-mt") {
                    version {
                        strictly("1.5.1-native-mt")
                    }
                }
            }
        }
    }
}

scope

val iosTarget: (String, KotlinNativeTarget.() -> Unit) -> KotlinNativeTarget = when {
    System.getenv("SDK_NAME")?.startsWith("iphoneos") == true -> ::iosArm64
    else -> ::iosX64
}

iosTarget("ios") {
    binaries {
        framework {
            baseName = "shared"
        }
    }
}

com.juul.sensortag.features.sensor.SensorActivityIntent

import machine
import utime
led_onboard = machine.Pin(25, machine.Pin.OUT)
uart = machine.UART(0, baudrate=9600)
while True:
    led_onboard.value(1)
    utime.sleep(0.05)
    led_onboard.value(0)
    uart.write("test")
    utime.sleep(0.05)

@OptIn(ExperimentalCoroutinesApi::class)
    fun connect(device: Device) {
        connectingCoroutine = viewModelScope.launch {
            try {
                val scanner = Scanner {
                    filters = null
                    logging {
                        engine = SystemLogEngine
                        level = Logging.Level.Data
                        format = Logging.Format.Multiline
                    }

                }

                scanner.advertisements.collect {
                    if (it.address == device.deviceUUID) {
                        val p = peripheral(it)
                        p.connect()
                        dataTransferState = DataTransferState.CONNECTED(device)
                        val services = p.services!!
                        val char = services
                            .first { service -> service.serviceUuid == uuidFrom("0000ffe0-0000-1000-8000-00805f9b34fb") }
                            .characteristics
                            .first { char -> char.characteristicUuid == uuidFrom("0000ffe1-0000-1000-8000-00805f9b34fb") }
                        Log.d("TAG", "serv=${char}")
                        dataTransferState = DataTransferState.WAITING
                        p.observe(char).catch { er -> Log.d("TAG", "$er") }
                            .collect { data ->
                                dataTransferState =
                                    DataTransferState.TRANSFERING_FROM_DEVICE
                                Log.d("TAG", "data1=${data.contentToString()}")
                            }
                        dataTransferState = DataTransferState.NOT_CONNECTED
                        Log.d("TAG", "data1=Done")
                    }
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
        connectingCoroutine?.invokeOnCompletion {
            connectingCoroutine = null
        }
    }

public val identifierString: String
    get() = identifier.toString()

withTimeoutOrNull(3000) {
    Scanner().advertisements.filter { it.identifierString == address}.collect{ adv ->
        Log.debug { "scanner - $adv" }
    }
    Log.debug { "scanner - completed" }
}

Uncaught Kotlin exception: kotlin.RuntimeException: Unexpected receiver type: kotlin.String

kable

private val job = SupervisorJob(parentCoroutineContext.job) 
private val scope = CoroutineScope(parentCoroutineContext + job)
private val connectionScope = CoroutineScope(scope.coroutineContext + Job(scope.coroutineContext[Job]))

scope

job

job

SupervisorJob

scope

job

connectionScope

scope

override suspend fun dataOad(characteristic: Characteristic) : Flow<ByteArray> {
    return peripheral.value.observe(characteristic)
        .onStart { Log.debug { "AudioProcessorImpl - dataOad - onStart" } }
        .onEach { Log.debug { "AudioProcessorImpl - dataOad - onEach" } }
        .onCompletion { Log.debug { "AudioProcessorImpl - dataOad - onCompletion" } }
}

Scanner { filters = listOf(Filter.Service(uuidFrom("00000123-0000-1000-8000-00805F9B34FB"))) }

Product A

Scanner { filters = listOf(Filter.Service(uuidFrom("00000124-0000-1000-8000-00805F9B34FB"))) }

Product A

Product B