How do I make a BLE connection in compose multiplateform App. using kable Library

[mukeshkibbcom]

I am using the Kable library for BLE scanning and connection in a Compose Multiplatform (KMP) app for Android and iOS. Scanning works perfectly in both platforms, but I am unable to establish a connection with the BLE device. What could be the possible reasons, and how can I fix this issue?

implementation("com.juul.kable:core:0.27.0")

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.juul.kable.Peripheral
import com.juul.kable.Scanner
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.launch

class ScanningViewModel : ViewModel(){

    private val scanner = Scanner()

    private var connectedPeripheral: Peripheral? = null

    private val _devices = MutableStateFlow<List<BleDevice>>(emptyList()) // You can store the device names here
    val devices: StateFlow<List<BleDevice>> = _devices

    fun startScanning() {
        viewModelScope.launch {
            try {
                 // Start scanning and collect advertisements
                scanner.advertisements.collect { advertisement ->

                    val deviceName = advertisement.name ?: "Unknown Device"
                    val txPower = advertisement.txPower ?: 0
                    
                    val newDevice = BleDevice(
                        name = deviceName,
                        peripheralName = "",  // Use peripheral name
                        txPower = txPower,
                    )

                    _devices.update { currentList ->
                        if (newDevice !in currentList) {
                            currentList + newDevice // Add the new device if not already present
                        } else {
                            currentList // Keep the list unchanged if device already exists
                        }
                    }
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
}

data class BleDevice(
    val name: String,
    val peripheralName: String, 
    val txPower: Int?,
)

Note : Connect methos is available in Peripheral object.

Expecting : Peripheral object because it has connect method

I tried with all possible version of kable lib

[twyatt]

It looks like you're acquiring an Advertisement and storing it in your devices list, but when you want to connect to the peripheral, you need to create the Peripheral using the advertisement.

In newer versions of Kable, that would look something like:

val peripheral = Peripheral(advertisement) {
    // todo: configure peripheral
    // see https://github.com/JuulLabs/kable?tab=readme-ov-file#peripheral for more details
}

peripheral.connect()

In older versions, you can use scope.peripheral(advertisement) { .. }.

[mukeshkibbcom]

Thanks for answering my question

But if I am trying to implement this

val peripheral = Peripheral(advertisement) {

}

"

Interface Peripheral does not have constructors"

I don't know what is wrong with me.

below is my grade file

import org.jetbrains.compose.desktop.application.dsl.TargetFormat
import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
import org.jetbrains.kotlin.gradle.dsl.JvmTarget

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidApplication)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)

}

kotlin {
    androidTarget {
        @OptIn(ExperimentalKotlinGradlePluginApi::class)
        compilerOptions {
            jvmTarget.set(JvmTarget.JVM_11)
        }
    }
    
    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "ComposeApp"
            isStatic = true
        }
    }
    
    jvm("desktop")
    
    sourceSets {
        val desktopMain by getting
        
        androidMain.dependencies {
            implementation(compose.preview)
            implementation(libs.androidx.activity.compose)

            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.1")
            implementation(libs.ktor.client.okhttp)
        }
        commonMain.dependencies {
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material)
            implementation(compose.material3)
            implementation(compose.ui)
            implementation(compose.components.resources)
            implementation(compose.components.uiToolingPreview)
            implementation(libs.androidx.lifecycle.viewmodel)
            implementation(libs.androidx.lifecycle.runtime.compose)

            implementation(libs.coil.compose)
            implementation(libs.coil.svg)
            implementation(libs.coil.network.ktor3)
            implementation(libs.ktor.client.core)

            implementation(libs.lifecycle.viewmodel)
            implementation(libs.lifecycle.viewmodel.compose)
            api(libs.moko.permissions)
            api(libs.moko.permissions.compose)
            implementation("com.juul.kable:core:0.27.0")

            api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1")


            implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.0") // for Compose integration
            implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.0")


        }
        desktopMain.dependencies {
            implementation(compose.desktop.currentOs)
            implementation(libs.kotlinx.coroutines.swing)


        }

        iosMain.dependencies {
            implementation(libs.ktor.client.darwin)
        }
    }
}

android {
    namespace = "org.kibbcom.tm_x"
    compileSdk = libs.versions.android.compileSdk.get().toInt()

    defaultConfig {
        applicationId = "org.kibbcom.tm_x"
        minSdk = libs.versions.android.minSdk.get().toInt()
        targetSdk = libs.versions.android.targetSdk.get().toInt()
        versionCode = 1
        versionName = "1.0"
    }
    packaging {
        resources {
            excludes += "/META-INF/{AL2.0,LGPL2.1}"
        }
    }
    buildTypes {
        getByName("release") {
            isMinifyEnabled = false
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_11
        targetCompatibility = JavaVersion.VERSION_11
    }
}

dependencies {
    implementation(libs.androidx.runtime.android)
    debugImplementation(compose.uiTooling)
}

compose.desktop {
    application {
        mainClass = "org.kibbcom.tm_x.MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "org.kibbcom.tm-x"
            packageVersion = "1.0.0"
        }
    }
}

[twyatt]

You need Kable 0.35.x (or newer) for Peripheral(advertisement) { .. }.

For versions before 0.35.x, you need to use scope.peripheral(advertisement) { .. } (where scope is a CoroutineScope).

[mukeshkibbcom]

Thanks for helping me here

Now i am able to get the peripheral object and able to call the connect() method

Now I need to create the bond with the ble device to communicate with .
i searched in google and found we need to call android and ios native API to create bond
For Android I need BluetoothDevice device object to create the bond using below code.
below I am putting the reference code I found over internet or how to create the bond between devices

                // Get BluetoothDevice from the peripheral
                val bluetoothDevice: BluetoothDevice? = peripheral.bluetoothDevice

                // Check if the BluetoothDevice is available and trigger bonding
                if (bluetoothDevice != null) {
                    val bluetoothAdapter: BluetoothAdapter? = BluetoothAdapter.getDefaultAdapter()

                    if (bluetoothAdapter != null && bluetoothAdapter.isEnabled) {
                        // Trigger bonding (pairing) with the device
                        val bondStatus = bluetoothDevice.createBond()
                        isBonded.value = bondStatus
                        connectionStatus.value = "Bonding initiated"
                    } else {
                        connectionStatus.value = "Bluetooth adapter not available or disabled"
                    }
                } else {
                    connectionStatus.value = "Bluetooth device not found"
                }
            } 

[twyatt]

Unfortunately, Kable does not yet support bonding, but may in the future (#111).