Android Native (Kotlin) vs. Flutter: Complex Bluetooth Low Energy (BLE) and Hardware Integration
Navigating the Depths: BLE and Hardware Integration in Native Android vs. Flutter
When architecting mobile applications that demand deep integration with Bluetooth Low Energy (BLE) peripherals and other low-level hardware, the choice between native Android development (Kotlin) and cross-platform frameworks like Flutter becomes critical. While Flutter excels in UI consistency and development speed for many use cases, the intricacies of BLE communication, particularly with custom hardware or complex protocols, often expose fundamental differences in how each platform handles hardware access, threading, and error management. This analysis focuses on the practical challenges and solutions encountered when building sophisticated BLE-dependent applications.
Native Android (Kotlin): Granular Control and Direct Hardware Access
Kotlin on Android provides direct access to the Android SDK’s Bluetooth APIs. This offers unparalleled control over the BLE stack, enabling developers to implement custom GATT (Generic Attribute Profile) services, handle raw byte streams, and manage connection states with fine-grained precision. The primary advantage lies in the ability to leverage platform-specific optimizations and react directly to hardware events without abstraction layers that might introduce latency or limitations.
Core BLE Operations in Kotlin
The foundation of BLE communication in Android is the BluetoothAdapter, BluetoothDevice, and BluetoothGatt classes. Managing the lifecycle of a BluetoothGatt instance is paramount, as it represents the active connection to a peripheral. Asynchronous operations are handled via callbacks, which must be managed carefully to avoid race conditions and ensure proper state transitions.
Establishing a Connection and GATT Operations
Connecting to a BLE device and interacting with its GATT server involves a sequence of asynchronous callbacks. The connectGatt() method initiates the connection, and subsequent operations like discovering services, reading characteristics, or writing data are triggered through the BluetoothGattCallback interface.
Example: Initiating BLE Connection and Service Discovery
This Kotlin snippet demonstrates the basic setup for connecting to a device and initiating service discovery. Note the use of BluetoothGattCallback to handle connection states and discovery results.
import android.bluetooth.*
import android.content.Context
import android.util.Log
import java.util.UUID
class BleManager(private val context: Context) {
private var bluetoothGatt: BluetoothGatt? = null
private val TAG = "BleManager"
// Example UUIDs - replace with your device's specific UUIDs
private val SERVICE_UUID = UUID.fromString("0000180D-0000-1000-8000-00805F9B34FB") // Heart Rate Service
private val CHARACTERISTIC_UUID = UUID.fromString("00002A37-0000-1000-8000-00805F9B34FB") // Heart Rate Measurement
fun connect(device: BluetoothDevice): Boolean {
Log.d(TAG, "Connecting to ${device.address}")
bluetoothGatt = device.connectGatt(context, false, gattCallback)
return bluetoothGatt != null
}
private val gattCallback = object : BluetoothGattCallback() {
override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
val deviceAddress = gatt?.device?.address ?: "Unknown"
if (status == BluetoothGatt.GATT_SUCCESS) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
Log.i(TAG, "Successfully connected to $deviceAddress")
// Discover services after successful connection
gatt?.discoverServices()
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
Log.d(TAG, "Disconnected from $deviceAddress")
closeGatt()
}
} else {
Log.w(TAG, "Connection error to $deviceAddress, status: $status")
closeGatt()
}
}
override fun onServicesDiscovered(gatt: BluetoothGatt?, status: Int) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "Services discovered successfully")
val service = gatt?.getService(SERVICE_UUID)
if (service != null) {
val characteristic = service.getCharacteristic(CHARACTERISTIC_UUID)
if (characteristic != null) {
// Enable notifications for the characteristic
gatt?.setCharacteristicNotification(characteristic, true)
// You might need to write to a Client Characteristic Configuration descriptor here
// Example: val descriptor = characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805F9B34FB"))
// descriptor?.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
// gatt?.writeDescriptor(descriptor)
Log.i(TAG, "Characteristic found and notifications enabled.")
} else {
Log. Log.w(TAG, "Characteristic not found: $CHARACTERISTIC_UUID")
}
} else {
Log.w(TAG, "Service not found: $SERVICE_UUID")
}
} else {
Log.w(TAG, "Service discovery failed, status: $status")
}
}
override fun onCharacteristicChanged(gatt: BluetoothGatt?, characteristic: BluetoothGattCharacteristic?) {
if (characteristic?.uuid == CHARACTERISTIC_UUID) {
val data = characteristic.value
Log.d(TAG, "Characteristic changed: ${data.joinToString { "%02X".format(it) }}")
// Process received data here
}
}
// Add other callbacks like onCharacteristicRead, onCharacteristicWrite, onDescriptorWrite etc.
}
fun disconnect() {
bluetoothGatt?.disconnect()
closeGatt()
}
private fun closeGatt() {
bluetoothGatt?.close()
bluetoothGatt = null
Log.d(TAG, "BluetoothGatt closed.")
}
}
Handling Raw Data and Custom Protocols
BLE communication often involves sending and receiving raw byte arrays. Native Android provides direct access to these byte arrays via BluetoothGattCharacteristic.getValue(). This allows for precise parsing of custom data structures, bit manipulation, and adherence to specific hardware communication protocols. The developer has full control over byte order, data encoding, and error checking.
Example: Reading and Writing Raw Bytes
// Inside BleManager class...
fun readCharacteristic(characteristic: BluetoothGattCharacteristic): Boolean {
return bluetoothGatt?.readCharacteristic(characteristic) ?: false
}
fun writeCharacteristic(characteristic: BluetoothGattCharacteristic, data: ByteArray): Boolean {
if (characteristic.properties.and(BluetoothGattCharacteristic.PROPERTY_WRITE) == 0) {
Log.w(TAG, "Characteristic does not support WRITE property.")
return false
}
characteristic.value = data
return bluetoothGatt?.writeCharacteristic(characteristic) ?: false
}
// Example usage within onServicesDiscovered or other callbacks:
// val service = gatt?.getService(MY_CUSTOM_SERVICE_UUID)
// val writeCharacteristic = service?.getCharacteristic(MY_WRITE_CHARACTERISTIC_UUID)
// if (writeCharacteristic != null) {
// val payload = byteArrayOf(0x01, 0x02, 0x03) // Example data
// writeCharacteristic(writeCharacteristic, payload)
// }
Threading and Asynchronous Operations
All BLE operations in Android are inherently asynchronous. The BluetoothGattCallback methods are invoked on a binder thread managed by the Android system. It’s crucial to dispatch UI updates or heavy data processing to the main thread or a dedicated background thread pool (e.g., using Coroutines or RxJava) to prevent ANRs (Application Not Responding) and maintain a responsive UI.
Advantages of Native Android for Complex BLE
- Direct API Access: Unrestricted access to the full Android Bluetooth API, including low-level details and future platform enhancements.
- Performance: Minimal overhead, allowing for high-throughput data streams and low-latency control.
- Hardware Compatibility: Easier to work around specific device or OS bugs through direct API manipulation.
- Debugging: Access to detailed system logs (e.g., via
adb logcat) that provide granular insights into BLE events and errors. - Background Operations: More robust control over background BLE services, though this requires careful management of foreground services and permissions.
Flutter: Abstraction, Cross-Platform Consistency, and Potential Hurdles
Flutter’s strength lies in its declarative UI and single codebase for multiple platforms. For BLE, Flutter relies on plugins that abstract the native platform APIs. While this simplifies development for common BLE use cases, complex or non-standard hardware integrations can expose limitations imposed by these abstractions.
Popular Flutter BLE Plugins
The most widely used plugin is flutter_blue_plus (a fork of the original flutter_blue). It provides a Dart API that maps to the underlying Android (Kotlin/Java) and iOS (Swift/Objective-C) Bluetooth APIs.
Core BLE Operations in Flutter (using flutter_blue_plus)
The plugin abstracts the connection and GATT operations into Dart streams and futures. This approach simplifies state management for many developers but can obscure the underlying asynchronous nature and potential platform-specific nuances.
Example: Initiating BLE Connection and Service Discovery in Flutter
import 'package:flutter_blue_plus/flutter_blue_plus.dart';
import 'package:flutter/material.dart';
// Assume 'device' is a BluetoothDevice object obtained from scanning
Future<void> connectToDevice(BluetoothDevice device) async {
try {
await device.connect(); // Initiates connection
print('Connected to ${device.name}');
// Discover services
List<BluetoothService> services = await device.discoverServices();
print('Services discovered: ${services.length}');
// Find a specific service and characteristic
var service = services.firstWhere(
(s) => s.uuid == Guid("0000180D-0000-1000-8000-00805F9B34FB"), // Heart Rate Service
orElse: () => throw Exception("Service not found"),
);
var characteristic = service.characteristics.firstWhere(
(c) => c.uuid == Guid("00002A37-0000-1000-8000-00805F9B34FB"), // Heart Rate Measurement
orElse: () => throw Exception("Characteristic not found"),
);
// Enable notifications
await characteristic.setNotifyValue(true);
print('Notifications enabled for characteristic');
// Listen for characteristic changes
characteristic.value.listen((value) {
print('Characteristic value changed: ${value.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join()}');
// Process received data
});
} catch (e) {
print('Error connecting or interacting with device: $e');
// Handle errors appropriately
}
}
// To disconnect:
// await device.disconnect();
Handling Raw Data and Custom Protocols in Flutter
flutter_blue_plus exposes characteristic values as Uint8List, which is Dart’s representation of a byte array. This is analogous to Android’s ByteArray. However, the plugin’s abstraction might limit direct access to certain low-level byte manipulation features or specific GATT descriptor interactions that are readily available in native code.
Example: Reading and Writing Raw Bytes in Flutter
// Inside the BluetoothGattCharacteristic stream listener or a separate function
Future<void> readMyCharacteristic(BluetoothGattCharacteristic characteristic) async {
try {
List<int> value = await characteristic.read();
print('Read value: ${value.map((byte) => byte.toRadixString(16).padLeft(2, '0')).join()}');
// Process value (Uint8List)
} catch (e) {
print('Error reading characteristic: $e');
}
}
Future<void> writeToMyCharacteristic(BluetoothGattCharacteristic characteristic, List<int> data) async {
try {
// Check write property (plugin might handle this internally, but explicit check is good)
if (!characteristic.properties.write) {
print('Characteristic does not support write.');
return;
}
await characteristic.write(data.cast<int>()); // Ensure data is List<int>
print('Successfully wrote data.');
} catch (e) {
print('Error writing characteristic: $e');
}
}
// Example usage:
// final myData = [0x01, 0x02, 0x03]; // Example data
// writeToMyCharacteristic(myCharacteristic, myData);
Threading and Asynchronous Operations in Flutter
Flutter’s asynchronous programming model, based on async/await and Streams, handles the underlying platform threading. Plugin developers are responsible for bridging the native callbacks to Dart’s event loop. While this generally works well, complex scenarios requiring precise timing or direct manipulation of native threads can be challenging to implement within the Flutter paradigm.
Challenges with Flutter for Complex BLE
- Abstraction Leaks: When a plugin doesn’t expose a specific native API feature or behaves unexpectedly, debugging requires diving into the plugin’s native code (Kotlin/Swift) and the underlying platform APIs.
- Plugin Limitations: Custom GATT profiles, obscure BLE features, or specific hardware quirks might not be fully supported by the plugin, necessitating native code integration or forking the plugin.
- Performance Bottlenecks: Data serialization/deserialization between Dart and native code, and the overhead of the plugin’s abstraction layer, can introduce latency for high-frequency data streams.
- Error Handling Nuances: Platform-specific error codes or states might be mapped generically by the plugin, making it harder to diagnose root causes.
- Background Execution: Implementing robust background BLE operations in Flutter can be more complex due to platform restrictions and the need for platform-specific background execution modes (e.g., foreground services on Android).
When to Choose Which: Strategic Architectural Decisions
Opt for Native Android (Kotlin) When:
- Custom GATT Profiles: Your application interacts with hardware using highly custom or non-standard GATT services and characteristics that require precise control over descriptors and properties.
- High-Throughput Data: You need to stream large amounts of data at high frequencies with minimal latency (e.g., sensor data logging, real-time control).
- Low-Level Hardware Interaction: Direct manipulation of hardware features beyond standard BLE, such as specific power management modes or interaction with other onboard sensors via native APIs.
- Platform-Specific Features: You need to leverage advanced Android-specific Bluetooth features or work around OS-level bugs.
- Maximum Performance and Reliability: The application’s core functionality is critically dependent on the absolute best performance and reliability achievable from the BLE stack.
- Deep Debugging Requirements: You anticipate needing to debug at the packet level or analyze system-level Bluetooth logs extensively.
Opt for Flutter When:
- Standard BLE Profiles: Your application primarily uses standard BLE profiles (e.g., Heart Rate, Battery Service) or custom profiles with well-defined, common GATT operations.
- Rapid Prototyping: You need to quickly develop and iterate on an application with BLE features, prioritizing development speed and UI consistency across platforms.
- Cross-Platform UI: The primary goal is a consistent user experience across Android and iOS, with BLE being a supporting feature rather than the core differentiator.
- Simpler Data Exchange: Data exchange with the BLE device is relatively infrequent or low-volume, and latency is not a critical concern.
- Leveraging Existing Plugins: The chosen BLE plugin adequately supports all required features without significant workarounds.
Bridging the Gap: Hybrid Approaches
For complex projects, a hybrid approach can offer the best of both worlds. This typically involves:
- Platform Channels: Flutter’s platform channels allow you to invoke native Android (Kotlin) code from Dart. You can implement your highly specialized BLE logic in a native Android module and expose a simplified API to your Flutter application. This is often the most practical solution for complex BLE requirements within a Flutter app.
- Native Libraries: If you have existing native C/C++ libraries for BLE communication (e.g., using NRF Connect SDK or custom stacks), you can integrate them into both native Android and Flutter projects (via NDK for Android).
Example: Platform Channel for Custom BLE Logic
1. Native Android (Kotlin) – `BleNativeModule.kt`
package com.your_app_name.ble
import android.bluetooth.*
import android.content.Context
import android.util.Log
import io.flutter.embedding.engine.plugins.FlutterPlugin
import io.flutter.embedding.engine.plugins.activity.ActivityAware
import io.flutter.embedding.engine.activity.ActivityPluginBinding
import io.flutter.plugin.common.BinaryMessenger
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.MethodChannel.MethodCallHandler
import io.flutter.plugin.common.MethodChannel.Result
import java.util.UUID
class BleNativeModule(
private var context: Context?,
binaryMessenger: BinaryMessenger
) : FlutterPlugin, MethodCallHandler, ActivityAware {
private val TAG = "BleNativeModule"
private var methodChannel: MethodChannel = MethodChannel(binaryMessenger, "com.your_app_name/ble_native")
private var bluetoothGatt: BluetoothGatt? = null
private val SERVICE_UUID = UUID.fromString("YOUR_CUSTOM_SERVICE_UUID")
private val CHARACTERISTIC_UUID = UUID.fromString("YOUR_CUSTOM_CHARACTERISTIC_UUID")
init {
methodChannel.setMethodCallHandler(this)
Log.d(TAG, "BleNativeModule initialized")
}
override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
context = binding.applicationContext
// Re-initialize channel if needed, or ensure it's handled by constructor
// methodChannel = MethodChannel(binding.binaryMessenger, "com.your_app_name/ble_native")
// methodChannel.setMethodCallHandler(this)
Log.d(TAG, "BleNativeModule attached to engine")
}
override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
Log.d(TAG, "BleNativeModule detached from engine")
methodChannel.setMethodCallHandler(null)
closeGatt()
context = null
}
override fun onAttachedToActivity(binding: ActivityPluginBinding) {
// Activity context might be needed for certain operations
Log.d(TAG, "BleNativeModule attached to activity")
}
override fun onDetachedFromActivity() {
Log.d(TAG, "BleNativeModule detached from activity")
}
override fun onMethodCall(call: MethodCall, result: Result) {
when (call.method) {
"connect" -> {
val deviceAddress = call.argument<String>("deviceAddress")
if (deviceAddress == null) {
result.error("INVALID_ARGUMENT", "Device address is required", null)
return
}
val device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(deviceAddress)
if (device != null) {
bluetoothGatt = device.connectGatt(context, false, gattCallback)
if (bluetoothGatt == null) {
result.error("CONNECTION_FAILED", "Failed to initialize GATT connection", null)
} else {
result.success(true) // Indicate connection attempt started
}
} else {
result.error("DEVICE_NOT_FOUND", "Bluetooth device not found", null)
}
}
"disconnect" -> {
disconnect()
result.success(true)
}
"writeValue" -> {
val address = call.argument<String>("deviceAddress")
val valueBytes = call.argument<ByteArray>("value")
if (address == null || valueBytes == null) {
result.error("INVALID_ARGUMENT", "Device address and value are required", null)
return
}
// Find the correct GATT instance if multiple devices are managed
val gatt = findGattByAddress(address) // Implement findGattByAddress
if (gatt != null) {
val service = gatt.getService(SERVICE_UUID)
if (service != null) {
val characteristic = service.getCharacteristic(CHARACTERISTIC_UUID)
if (characteristic != null) {
if (characteristic.properties.and(BluetoothGattCharacteristic.PROPERTY_WRITE) != 0) {
characteristic.value = valueBytes
val success = gatt.writeCharacteristic(characteristic)
result.success(success)
} else {
result.error("WRITE_NOT_SUPPORTED", "Characteristic does not support write", null)
}
} else {
result.error("CHARACTERISTIC_NOT_FOUND", "Characteristic not found", null)
}
} else {
result.error("SERVICE_NOT_FOUND", "Service not found", null)
}
} else {
result.error("DEVICE_NOT_CONNECTED", "Device not connected", null)
}
}
// Add other methods like readValue, enableNotifications etc.
else -> result.notImplemented()
}
}
private val gattCallback = object : BluetoothGattCallback() {
override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
val deviceAddress = gatt?.device?.address ?: "Unknown"
if (status == BluetoothGatt.GATT_SUCCESS) {
if (newState == BluetoothProfile.STATE_CONNECTED) {
Log.i(TAG, "Native: Successfully connected to $deviceAddress")
gatt?.discoverServices()
} else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
Log.d(TAG, "Native: Disconnected from $deviceAddress")
closeGatt()
// Notify Flutter about disconnection
methodChannel.invokeMethod("onDisconnected", mapOf("deviceAddress" to deviceAddress))
}
} else {
Log.w(TAG, "Native: Connection error to $deviceAddress, status: $status")
closeGatt()
methodChannel.invokeMethod("onError", mapOf("deviceAddress" to deviceAddress, "errorCode" to status))
}
}
override fun onServicesDiscovered(gatt: BluetoothGatt?, status: Int) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "Native: Services discovered")
val service = gatt?.getService(SERVICE_UUID)
if (service != null) {
val characteristic = service.getCharacteristic(CHARACTERISTIC_UUID)
if (characteristic != null) {
// Enable notifications
gatt?.setCharacteristicNotification(characteristic, true)
// Write descriptor for notifications
val descriptorUuid = UUID.fromString("00002902-0000-1000-8000-00805F9B34FB")
val descriptor = characteristic.getDescriptor(descriptorUuid)
if (descriptor != null) {
descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
gatt?.writeDescriptor(descriptor)
} else {
Log.w(TAG, "Notification descriptor not found")
}
methodChannel.invokeMethod("onServiceDiscovered", mapOf("deviceAddress" to gatt?.device?.address))
} else {
Log.w(TAG, "Native: Characteristic not found")
methodChannel.invokeMethod("onError", mapOf("deviceAddress" to gatt?.device?.address, "errorCode" to -1, "message" to "Characteristic not found"))
}
} else {
Log.w(TAG, "Native: Service not found")
methodChannel.invokeMethod("onError", mapOf("deviceAddress" to gatt?.device?.address, "errorCode" to -2, "message" to "Service not found"))
}
} else {
Log.w(TAG, "Native: Service discovery failed, status: $status")
methodChannel.invokeMethod("onError", mapOf("deviceAddress" to gatt?.device?.address, "errorCode" to status, "message" to "Service discovery failed"))
}
}
override fun onCharacteristicChanged(gatt: BluetoothGatt?, characteristic: BluetoothGattCharacteristic?) {
if (characteristic?.uuid == CHARACTERISTIC_UUID) {
val data = characteristic.value
Log.d(TAG, "Native: Characteristic changed: ${data.joinToString { "%02X".format(it) }}")
methodChannel.invokeMethod("onCharacteristicChanged", mapOf(
"deviceAddress" to gatt?.device?.address,
"value" to data // Pass byte array directly
))
}
}
override fun onDescriptorWrite(gatt: BluetoothGatt?, descriptor: BluetoothGattDescriptor?, status: Int) {
if (status == BluetoothGatt.GATT_SUCCESS) {
Log.i(TAG, "Native: Descriptor write successful")
// Optionally invoke a method to signal descriptor write success
} else {
Log.w(TAG, "Native: Descriptor write failed, status: $status")
methodChannel.invokeMethod("onError", mapOf("deviceAddress" to gatt?.device?.address, "errorCode" to status, "message" to "Descriptor write failed"))
}
}
// Implement other callbacks as needed (onCharacteristicRead, onCharacteristicWrite)
}
private fun findGattByAddress(address: String): BluetoothGatt? {
// In a real app, you'd manage a map of addresses to BluetoothGatt instances
// For simplicity, assuming only one active connection here.
return if (bluetoothGatt?.device?.address == address) bluetoothGatt else null
}
fun disconnect() {
bluetoothGatt?.disconnect()
closeGatt()
}
private fun closeGatt() {
bluetoothGatt?.close()
bluetoothGatt = null
Log.d(TAG, "Native: BluetoothGatt closed.")
}
}
// You'll need to register this module in your MainActivity.kt
// Example:
// class MainActivity: FlutterActivity() {
// override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) {
// super.configureFlutterEngine(flutterEngine)
// BleNativeModule(this, flutterEngine.dartExecutor.binaryMessenger)
// }
// }
2. Flutter Dart – `ble_service.dart`
import 'package:flutter/services.dart';
import 'dart:typed_data';
class BleNativeService {
static const MethodChannel _channel = MethodChannel('com.your_app_name/ble_native');
static Future<void> connect(String deviceAddress) async {
try {
await _channel.invokeMethod('connect', {'deviceAddress': deviceAddress});
print('Flutter: Connect method invoked for $deviceAddress');
} on PlatformException catch (e) {
print("Flutter: Failed to connect: '${e.message}'.");
throw e; // Re-throw to be handled by caller
}
}
static Future<void> disconnect(String deviceAddress) async {
try {
await _channel.invokeMethod('disconnect', {'deviceAddress': deviceAddress});
print('Flutter: Disconnect method invoked for $deviceAddress');
} on PlatformException catch (e) {
print("Flutter: Failed to disconnect: '${e.message}'.");
throw e;
}
}
static Future<void> writeValue(String deviceAddress, Uint8List value) async {
try {
await _channel.invokeMethod('writeValue', {'deviceAddress': deviceAddress, 'value': value});
print('Flutter: WriteValue method invoked for $deviceAddress');
} on PlatformException catch (e) {
print("Flutter: Failed to write value: '${e.message}'.");
throw e;
}
}
// Method to set up listeners for native callbacks
static void setEventListeners({
required Function(String deviceAddress) onDisconnected,
required Function(String deviceAddress, int errorCode, String? message) onError,
required Function(String deviceAddress) onServiceDiscovered,
required Function(String deviceAddress, Uint8List value) onCharacteristicChanged,
}) {
_channel.setMethodCallHandler((MethodCall call) async {
final Map<String, dynamic>? args = call.arguments?.cast<String, dynamic>();
final String? deviceAddress = args?['deviceAddress'];
switch (call.method) {
case 'onDisconnected':
if (deviceAddress != null) onDisconnected(deviceAddress);
break;
case 'onError':
if (deviceAddress != null) {
final int errorCode = args?['errorCode'] ?? -1;
final String? message = args?['message'];
onError(deviceAddress, errorCode, message);
}
break;
case 'onServiceDiscovered':
if (deviceAddress != null) onServiceDiscovered(deviceAddress);
break;
case 'onCharacteristicChanged':
if (deviceAddress != null) {
final Uint8List? value = args?['value']?.cast<int>() as Uint8List?;
if (value != null) {
onCharacteristicChanged(deviceAddress, value);
}
}
break;
default:
print('Unknown method call: ${call.method}');
}
});
}
}
// Example Usage in Flutter UI:
//
// @override
// void initState() {
// super.initState();
// BleNativeService.setEventListeners(
// onDisconnected: (address) => print('Device $address disconnected'),
// onError: (address, code, msg) => print('Error from $address: $code - $msg'),
// onServiceDiscovered: (address) => print('Services discovered for $address'),
// onCharacteristicChanged: (address, value) => print('Data from $address: ${value.map((b) => b.toRadixString(16)).join()}'),
// );
// }
//
// Future<void> _connectDevice(BluetoothDevice device) async {
// try {
// await BleNativeService.connect(device.address);
// // Handle successful connection, maybe navigate to another screen
// } catch (e) {
// // Show error message to user
// }
// }
//
// Future<void> _sendData(String deviceAddress, Uint8List data) async {
// try {
// await BleNativeService.writeValue(deviceAddress, data);
// } catch (e) {
// // Show error message
// }
// }
Conclusion
The decision between native Android (Kotlin) and Flutter for complex BLE and hardware integration hinges on the project’s specific requirements for control, performance, and development velocity. Native Android offers the most direct and powerful access, ideal for mission-critical or highly specialized hardware interactions. Flutter, with its robust plugin ecosystem and platform channels, provides a viable and often faster path for applications where standard BLE operations suffice or where a hybrid approach can effectively encapsulate complex native logic. Thoroughly evaluating the BLE interaction complexity and the trade-offs between abstraction and control is key to making the right architectural choice.