add: write, read, status functions, interface and example

Author: matfire

android/src/main/kotlin/com/matteogassend/bluetooth_classic/BluetoothClassicPlugin.kt

@@ -42,9 +42,9 @@ class BluetoothClassicPlugin: FlutterPlugin, MethodCallHandler, PluginRegistry.R
   private lateinit var bluetoothDeviceChannel: EventChannel
   private var bluetoothDeviceChannelSink: EventSink ?= null
   private lateinit var bluetoothReadChannel: EventChannel
-  private var bluetoothReadChannelSink : EventChannel.EventSink ?= null
+  private var bluetoothReadChannelSink : EventSink ?= null
   private lateinit var bluetoothStatusChannel: EventChannel
-  private var bluetoothStatusChannelSink: EventChannel.EventSink ?= null
+  private var bluetoothStatusChannelSink: EventSink ?= null
   private lateinit var ba: BluetoothAdapter
   private lateinit var pluginActivity: Activity
   private lateinit var application: Context
@@ -57,7 +57,7 @@ class BluetoothClassicPlugin: FlutterPlugin, MethodCallHandler, PluginRegistry.R
   private var device: BluetoothDevice ?= null
 
 
-  private inner class ConnectedThread(private val socket: BluetoothSocket): Thread() {
+  private inner class ConnectedThread(socket: BluetoothSocket): Thread() {
 
     private val inputStream = socket.inputStream
     private val outputStream = socket.outputStream
@@ -137,12 +137,9 @@ class BluetoothClassicPlugin: FlutterPlugin, MethodCallHandler, PluginRegistry.R
     ba = BluetoothAdapter.getDefaultAdapter()
     channel.setMethodCallHandler(this)
     looper = flutterPluginBinding.applicationContext.mainLooper
-
     application = flutterPluginBinding.applicationContext
-
-
     bluetoothDeviceChannel.setStreamHandler(object: StreamHandler {
-      override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
+      override fun onListen(arguments: Any?, events: EventSink?) {
           bluetoothDeviceChannelSink = events
       }
 
@@ -171,24 +168,50 @@ class BluetoothClassicPlugin: FlutterPlugin, MethodCallHandler, PluginRegistry.R
   }
 
   override fun onMethodCall(call: MethodCall, result: Result) {
-
+    Log.i("method_call", call.method)
     when(call.method) {
-      "getPlatformVersion" -> result.success("Android ${android.os.Build.VERSION.RELEASE}")
+      "getPlatformVersion" -> result.success("Android ${Build.VERSION.RELEASE}")
       "initPermissions" -> initPermissions(result)
       "getDevices" -> getDevices(result)
       "startDiscovery" -> startScan(result)
       "stopDiscovery" -> stopScan(result)
       "connect" -> connect(result, call.argument<String>("deviceId")!!,
         call.argument<String>("serviceUUID")!!
       )
+      "disconnect" -> disconnect(result)
+      "write" -> write(result, call.argument<String>("message")!!)
       else -> result.notImplemented()
     }
   }
 
+  private fun write(result: Result, message: String) {
+    Log.i("write_handle", "inside write handle")
+    if (thread != null) {
+      thread!!.write(message.toByteArray())
+      result.success(true)
+    } else {
+      result.error("write_impossible", "could not send message to unconnected device", null)
+    }
+  }
+
+  private fun disconnect(result: Result) {
+    device = null
+    android.util.Log.i("Bluetooth Disconnect", "device removed from memory")
+    thread!!.interrupt()
+    android.util.Log.i("Bluetooth Disconnect", "read thread closed")
+    thread = null
+    android.util.Log.i("Bluetooth Disconnect", "read thread freed")
+    socket!!.close()
+    android.util.Log.i("Bluetooth Disconnect", "rfcomm socket closed")
+    publishBluetoothStatus(0)
+    android.util.Log.i("Bluetooth Disconnect", "disconnected")
+    result.success(true)
+  }
+
   private fun connect(result: Result, deviceId: String, serviceUuid: String) {
     try {
       publishBluetoothStatus(1)
-      device = ba!!.getRemoteDevice(deviceId)
+      device = ba.getRemoteDevice(deviceId)
       android.util.Log.i("Bluetooth Connection", "device found")
       assert(device != null)
       socket = device?.createRfcommSocketToServiceRecord(UUID.fromString(serviceUuid))

example/lib/main.dart

@@ -22,11 +22,22 @@ class _MyAppState extends State<MyApp> {
   List<Device> _devices = [];
   List<Device> _discoveredDevices = [];
   bool _scanning = false;
-
+  int _deviceStatus = Device.disconnected;
+  Uint8List _data = Uint8List(0);
   @override
   void initState() {
     super.initState();
     initPlatformState();
+    _bluetoothClassicPlugin.onDeviceStatusChanged().listen((event) {
+      setState(() {
+        _deviceStatus = event;
+      });
+    });
+    _bluetoothClassicPlugin.onDeviceDataReceived().listen((event) {
+      setState(() {
+        _data = Uint8List.fromList([..._data, ...event]);
+      });
+    });
   }
 
   // Platform messages are asynchronous, so we initialize in an async method.
@@ -89,6 +100,7 @@ class _MyAppState extends State<MyApp> {
         body: SingleChildScrollView(
           child: Column(
             children: [
+              Text("Device status is $_deviceStatus"),
               TextButton(
                 onPressed: () async {
                   await _bluetoothClassicPlugin.initPermissions();
@@ -99,15 +111,35 @@ class _MyAppState extends State<MyApp> {
                 onPressed: _getDevices,
                 child: const Text("Get Paired Devices"),
               ),
+              TextButton(
+                onPressed: _deviceStatus == Device.connected
+                    ? () async {
+                        await _bluetoothClassicPlugin.disconnect();
+                      }
+                    : null,
+                child: const Text("disconnect"),
+              ),
+              TextButton(
+                onPressed: _deviceStatus == Device.connected
+                    ? () async {
+                        await _bluetoothClassicPlugin.write("ping");
+                      }
+                    : null,
+                child: const Text("send ping"),
+              ),
               Center(
                 child: Text('Running on: $_platformVersion\n'),
               ),
               ...[
                 for (var device in _devices)
                   TextButton(
-                      onPressed: () {
-                        _bluetoothClassicPlugin.connect(device.address,
+                      onPressed: () async {
+                        await _bluetoothClassicPlugin.connect(device.address,
                             "00001101-0000-1000-8000-00805f9b34fb");
+                        setState(() {
+                          _discoveredDevices = [];
+                          _devices = [];
+                        });
                       },
                       child: Text(device.name ?? device.address))
               ],
@@ -119,6 +151,7 @@ class _MyAppState extends State<MyApp> {
                 for (var device in _discoveredDevices)
                   Text(device.name ?? device.address)
               ],
+              Text("Received data: ${String.fromCharCodes(_data)}"),
             ],
           ),
         ),

lib/bluetooth_classic.dart

@@ -1,3 +1,5 @@
+import 'dart:typed_data';
+
 import 'bluetooth_classic_platform_interface.dart';
 import 'models/device.dart';
 
@@ -22,11 +24,27 @@ class BluetoothClassic {
     return BluetoothClassicPlatform.instance.stopScan();
   }
 
+  Future<bool> disconnect() {
+    return BluetoothClassicPlatform.instance.disconnect();
+  }
+
   Stream<Device> onDeviceDiscovered() {
     return BluetoothClassicPlatform.instance.onDeviceDiscovered();
   }
 
+  Stream<int> onDeviceStatusChanged() {
+    return BluetoothClassicPlatform.instance.onDeviceStatusChanged();
+  }
+
+  Stream<Uint8List> onDeviceDataReceived() {
+    return BluetoothClassicPlatform.instance.onDeviceDataReceived();
+  }
+
   Future<bool> connect(String address, String serviceUUID) {
     return BluetoothClassicPlatform.instance.connect(address, serviceUUID);
   }
+
+  Future<bool> write(String message) {
+    return BluetoothClassicPlatform.instance.write(message);
+  }
 }

lib/bluetooth_classic_method_channel.dart

@@ -16,17 +16,39 @@ class MethodChannelBluetoothClassic extends BluetoothClassicPlatform {
   /// The event channel used to receive discovered devices events
   final deviceDiscoveryChannel =
       const EventChannel("com.matteogassend/bluetooth_classic/devices");
+  final deviceStatusChannel =
+      const EventChannel("com.matteogassend/bluetooth_classic/status");
+  final deviceDataChannel =
+      const EventChannel("com.matteogassend/bluetooth_classic/read");
 
   /// stream mapped to deviceDiscoveryChannel
   Stream<dynamic>? _deviceDiscoveryStream;
 
+  /// stream mapped to deviceStatusChannel
+  Stream<dynamic>? _deviceStatusStream;
+
+  /// stream mapped to deviceDataChannel
+  Stream<dynamic>? _deviceDataReceivedStream;
+
   /// user facing stream controller for device discovery
   final StreamController<Device> discoveryStream = StreamController();
 
+  final StreamController<int> statusStream = StreamController();
+
+  final StreamController<Uint8List> dataReceivedStream = StreamController();
+
   void _onDeviceDiscovered(Device device) {
     discoveryStream.add(device);
   }
 
+  void _onDeviceStatus(int status) {
+    statusStream.add(status);
+  }
+
+  void _onDeviceDataReceived(Uint8List data) {
+    dataReceivedStream.add(data);
+  }
+
   @override
   Future<String?> getPlatformVersion() async {
     final version =
@@ -79,4 +101,35 @@ class MethodChannelBluetoothClassic extends BluetoothClassicPlatform {
     });
     return res!;
   }
+
+  @override
+  Future<bool> disconnect() async {
+    var res = await methodChannel.invokeMethod<bool>("disconnect");
+    return res!;
+  }
+
+  @override
+  Stream<int> onDeviceStatusChanged() {
+    _deviceStatusStream = deviceStatusChannel.receiveBroadcastStream();
+    _deviceStatusStream!.listen((event) {
+      _onDeviceStatus(event);
+    });
+    return statusStream.stream;
+  }
+
+  @override
+  Stream<Uint8List> onDeviceDataReceived() {
+    _deviceDataReceivedStream = deviceDataChannel.receiveBroadcastStream();
+    _deviceDataReceivedStream!.listen((event) {
+      _onDeviceDataReceived(event);
+    });
+    return dataReceivedStream.stream;
+  }
+
+  @override
+  Future<bool> write(String message) async {
+    var res = await methodChannel
+        .invokeMethod<bool>("write", <String, String>{"message": message});
+    return res!;
+  }
 }

lib/bluetooth_classic_platform_interface.dart

@@ -1,3 +1,5 @@
+import 'dart:typed_data';
+
 import 'package:plugin_platform_interface/plugin_platform_interface.dart';
 
 import 'bluetooth_classic_method_channel.dart';
@@ -48,7 +50,24 @@ abstract class BluetoothClassicPlatform extends PlatformInterface {
     throw UnimplementedError('onDeviceDiscovered() has not been implemented.');
   }
 
+  Stream<int> onDeviceStatusChanged() {
+    throw UnimplementedError('onDeviceStatus() has not been implemented.');
+  }
+
+  Stream<Uint8List> onDeviceDataReceived() {
+    throw UnimplementedError(
+        'onDeviceDataReceived() has not been implemented.');
+  }
+
   Future<bool> connect(String address, String serviceUUID) {
     throw UnimplementedError('connect() has not been implemented.');
   }
+
+  Future<bool> disconnect() {
+    throw UnimplementedError('disconnect() has not been implemented.');
+  }
+
+  Future<bool> write(String message) {
+    throw UnimplementedError('write() has not been implemented.');
+  }
 }