CMP-Bluetooth-Manager

KO | EN

gitlite — search

#hacktoberfest #llm #android #machine-learning #deep-learning #linux #docker #awesome #kubernetes #vue #security #ios #mcp #openai

CMP-Bluetooth-Manager

(★ 20)

No description available.

CMP-Bluetooth-Manager Latest Version Download

Download Latest Version (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

![badge-android](http://img.shields.io/badge/platform-android-3DDC84.svg?style=flat)
![badge-ios](http://img.shields.io/badge/platform-ios-FF375F.svg?style=flat)

# Compose Multiplatform Bluetooth Manager

A Kotlin Multiplatform library for Bluetooth functionality in Jetpack Compose applications.

![plot](https://github.com/user-attachments/assets/4dd8185a-972f-419d-b180-2b096c370f6e)

## ✨ Features

- **Cross-platform support**: Works on Android and iOS.
- **Easy-to-use API**: Simplified Bluetooth connectivity for Compose apps.
- **Device scanning**: Discover and connect to nearby Bluetooth devices.
- **State management**: Monitor connection status and device states.
- **Bluetooth State Management**: Monitor Bluetooth State allowing app to respond accordingly.
- **Paired and Connected Devices Management**: Retrieve and manage paired and connected devices.
- **Permission Handling**: Request and check Bluetooth permissions.

## 📦 Installation

Add the dependency to your `build.gradle.kts`:

```kotlin
commonMain.dependencies {
    implementation("network.chaintech:cmp-bluetooth-manager:1.0.0")
}
```

## 🔐 Permissions

### Android
Ensure you add the following permissions in your `AndroidManifest.xml`:

```xml

<uses-permission
    android:name="android.permission.BLUETOOTH"
    android:maxSdkVersion="30" />
<uses-permission
    android:name="android.permission.BLUETOOTH_ADMIN"
    android:maxSdkVersion="30" />

<uses-permission
    android:name="android.permission.BLUETOOTH_CONNECT"
    android:usesPermissionFlags="neverForLocation" />
<uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
<uses-permission
    android:name="android.permission.BLUETOOTH_SCAN"
    android:usesPermissionFlags="neverForLocation" />

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

<uses-feature android:name="android.hardware.bluetooth" />
```

### iOS
For iOS, add the following keys to your `Info.plist` file:

```xml
<key>NSBluetoothAlwaysUsageDescription</key>
<string>We require Bluetooth access to connect to nearby devices.</string>
<key>NSBluetoothPeripheralUsageDescription</key>
<string>We use Bluetooth to communicate with other devices.</string>
```

## 📖 Usage

### Initializing Bluetooth

```kotlin
val bluetoothManager = BluetoothManager()
```

### Checking and Requesting Bluetooth Permissions

```kotlin
@Composable
fun RequestPermissions() {
    RequestBluetoothPermission { isGranted ->
        if (isGranted) {
            println("Bluetooth permission granted")
        } else {
            println("Bluetooth permission denied")
        }
    }
}

val isPermissionGranted = isBluetoothPermissionGranted()
if (isPermissionGranted) {
    println("Bluetooth permission is already granted")
} else {
    println("Bluetooth permission is required")
}
```

### Bluetooth State
The bluetoothState flow updates whenever the Bluetooth state changes, allowing the app to respond accordingly.
```kotlin
LaunchedEffect(Unit) {
    bluetoothManager.bluetoothState.collectLatest {(state, device)->
            when(state){
                BluetoothState.IDLE -> println("Bluetooth Idle")
                BluetoothState.BLUETOOTH_ENABLED -> println("Bluetooth Enabled ")
                BluetoothState.BLUETOOTH_DISABLED -> println("Bluetooth Disabled ")
                BluetoothState.DEVICE_CONNECTED -> println("Device Connected ${device?.name}")
                BluetoothState.DEVICE_DISCONNECTED -> println("Device Disconnected ${device?.name}")
            }
    }
}
```

### Scanning for Devices
Start scanning for nearby Bluetooth devices and receive updates on discovered devices and scan state changes.
```kotlin
bluetoothManager.startScan(
    onDeviceFound = { device -> },
    onScanStateChanged = { state ->
        when (state) {
            BluetoothScanState.IDLE -> {}
            BluetoothScanState.SCANNING -> {}
            BluetoothScanState.STOPPED -> {}
        }
    },
    onError = { error -> println("Error: ${error}") }
)
```

### Connecting to a Device
Establish a connection with a Bluetooth device and monitor the connection state.
A Bluetooth device (BluetoothPeripheral) is required to establish a connection. You can get this device by scanning, retrieving paired devices, or checking currently connected devices.
Service UUID is optional and can be used to connect to a specific type of service on the device.
```kotlin
bluetoothManager.connectToDevice(
    device = BluetoothPeripheral(), // Bluetooth Device 
    uuid = YOUR_SERVICE_UUID,       // Optional
    onConnectionStateChanged = { state ->
        when (state) {
            BluetoothConnectionState.DISCONNECTED -> println("Device Disconnected")
            BluetoothConnectionState.CONNECTING -> println("Connecting...")
            BluetoothConnectionState.CONNECTED -> println("Device Connected")
            BluetoothConnectionState.ERROR -> println("Connection Error")
        }
    },
    onError = { error -> println("Connection error: ${error}") }
)
```

### Disconnecting a Device
Terminate an active Bluetooth connection with a device.
```kotlin
bluetoothManager.disconnectDevice(
    device = BluetoothPeripheral()     // Bluetooth Device ,
    onSuccess = { println("Device disconnected successfully") },
    onError = { error -> println("Error disconnecting: ${error}") }
)
```

### Unpairing a Device
Remove a Bluetooth device from the paired devices list.
```kotlin
bluetoothManager.unpairBluetoothDevice(
    device = BluetoothPeripheral() // Bluetooth Device,
    onSuccess = { println("Device unpaired successfully") },
    onError = { error -> println("Error unpairing device: ${error}") }
)
```

### Getting Paired Devices
Retrieve a list of devices that have been paired with the system.
```kotlin
val pairedDevices = bluetoothManager.getPairedDevices()
pairedDevices.forEach { device -> println("Paired device: ${device.name}") }
```

### Getting Connected Devices
Fetch the list of currently connected Bluetooth devices.
```kotlin
bluetoothManager.getConnectedDevices { device ->
    println("Connected device: ${device.name}")
}
```

### Make Device Available for others
Initialize a Bluetooth to allow other devices to connect.
To ensure that only devices with the same UUID can connect, pass a unique Service UUID while making the device visible and while connecting. If the UUIDs do not match, the connection will fail.
```kotlin
bluetoothManager.makeDeviceVisible(
    uuid = YOUR_SERVICE_UUID,      //Unique UUID Required
    onConnectionStateChanged = { state ->
        when (state) {
            BluetoothServerConnectionState.LISTENING -> println("Listening")
            BluetoothServerConnectionState.DISCONNECTED -> println("Disconnected")
            BluetoothServerConnectionState.CONNECTED -> println("Connected")
            BluetoothServerConnectionState.ERROR -> println("Error")
        }
    },
    onError = { error -> println("Server error: ${error}") }
)
```

### Retrieving Device Name
Fetch the name of the current Bluetooth device.
```kotlin
val deviceName = bluetoothManager.getDeviceName()
```

## 🛠️ Libraries Used in Demo
The demo project utilizes the following libraries:

**SDP & SSP for Compose Multiplatform** – Scalable size units for responsive UI
- [sdp-ssp-compose-multiplatform](https://github.com/Chaintech-Network/sdp-ssp-compose-multiplatform) – network.chaintech:sdp-ssp-compose-multiplatform

**Connectivity Monitor** – Seamless Network Monitoring for Compose Multiplatform
- [CMPToast](https://github.com/Chaintech-Network/CMPToast) – network.chaintech:cmptoast

## 📖 Detailed Explanation

For an in-depth guide and detailed explanation, check out our comprehensive Medium Blog Post.

[![Medium](https://img.shields.io/badge/Medium-12100E?style=for-the-badge&logo=medium&logoColor=white)](https://medium.com/mobile-innovation-network/introducing-compose-multiplatform-bluetooth-the-ultimate-solution-for-seamless-wireless-a6534ae066d1)

Stay connected and keep up with our latest innovations! 💼 Let's innovate together!

[![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/showcase/mobile-innovation-network)

<br>

CMP-Bluetooth-Manager

CMP-Bluetooth-Manager Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

CMP-Bluetooth-Manager

CMP-Bluetooth-Manager Latest Version Download

Today's picks

Was this content helpful?

Recent Feedback

Download README