react-native-ble-nitro 1.0.0 → 1.1.0

package/lib/index.js

@@ -59,78 +59,54 @@ export class BleNitro {
      * @returns Promise resolving to success state
      */
     startScan(filter = {}, callback) {
-        return new Promise((resolve) => {
-            // Don't start scanning if already scanning
-            if (this._isScanning) {
-                resolve(true);
-                return;
-            }
-            // Create native scan filter with defaults
-            const nativeFilter = {
-                serviceUUIDs: filter.serviceUUIDs || [],
-                rssiThreshold: filter.rssiThreshold ?? -100,
-                allowDuplicates: filter.allowDuplicates ?? false,
-            };
-            // Create callback wrapper
-            const scanCallback = (device) => {
-                device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-                callback(device);
-            };
-            // Start scan
-            BleNitroNative.startScan(nativeFilter, scanCallback);
-            this._isScanning = true;
-            resolve(true);
-        });
+        if (this._isScanning) {
+            return;
+        }
+        // Create native scan filter with defaults
+        const nativeFilter = {
+            serviceUUIDs: filter.serviceUUIDs || [],
+            rssiThreshold: filter.rssiThreshold ?? -100,
+            allowDuplicates: filter.allowDuplicates ?? false,
+        };
+        // Create callback wrapper
+        const scanCallback = (device) => {
+            device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
+            callback(device);
+        };
+        // Start scan
+        BleNitroNative.startScan(nativeFilter, scanCallback);
+        this._isScanning = true;
     }
     /**
      * Stop scanning for Bluetooth devices
      * @returns Promise resolving to success state
      */
     stopScan() {
-        return new Promise((resolve, reject) => {
-            // Don't stop scanning if not scanning
-            if (!this._isScanning) {
-                resolve(true);
-                return;
-            }
-            BleNitroNative.stopScan((success, error) => {
-                if (success) {
-                    this._isScanning = false;
-                    resolve(true);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
+        if (!this._isScanning) {
+            return;
+        }
+        BleNitroNative.stopScan();
     }
     /**
      * Check if currently scanning for devices
      * @returns Promise resolving to scanning state
      */
     isScanning() {
-        return new Promise((resolve) => {
-            BleNitroNative.isScanning((scanning) => {
-                this._isScanning = scanning;
-                resolve(scanning);
-            });
-        });
+        this._isScanning = BleNitroNative.isScanning();
+        return this._isScanning;
     }
     /**
      * Get all currently connected devices
-     * @returns Promise resolving to array of connected devices
+     * @param services Optional list of service UUIDs to filter by
+     * @returns Array of connected devices
      */
-    getConnectedDevices() {
-        return new Promise((resolve) => {
-            BleNitroNative.getConnectedDevices((devices) => {
-                // Normalize service UUIDs for connected devices
-                const normalizedDevices = devices.map(device => ({
-                    ...device,
-                    serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
-                }));
-                resolve(normalizedDevices);
-            });
-        });
+    getConnectedDevices(services) {
+        const devices = BleNitroNative.getConnectedDevices(services || []);
+        // Normalize service UUIDs for connected devices
+        return devices.map(device => ({
+            ...device,
+            serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
+        }));
     }
     /**
      * Connect to a Bluetooth device
@@ -169,13 +145,13 @@ export class BleNitro {
         return new Promise((resolve, reject) => {
             // Check if already disconnected
             if (!this._connectedDevices[deviceId]) {
-                resolve(true);
+                resolve();
                 return;
             }
             BleNitroNative.disconnect(deviceId, (success, error) => {
                 if (success) {
                     delete this._connectedDevices[deviceId];
-                    resolve(true);
+                    resolve();
                 }
                 else {
                     reject(new Error(error));
@@ -189,12 +165,7 @@ export class BleNitro {
      * @returns Promise resolving to connection state
      */
     isConnected(deviceId) {
-        return new Promise((resolve) => {
-            BleNitroNative.isConnected(deviceId, (connected) => {
-                this._connectedDevices[deviceId] = connected;
-                resolve(connected);
-            });
-        });
+        return BleNitroNative.isConnected(deviceId);
     }
     /**
      * Discover services for a connected device
@@ -235,9 +206,8 @@ export class BleNitro {
                 reject(new Error('Failed to discover services'));
                 return;
             }
-            BleNitroNative.getServices(deviceId, (services) => {
-                resolve(BleNitro.normalizeGattUUIDs(services));
-            });
+            const services = BleNitroNative.getServices(deviceId);
+            resolve(BleNitro.normalizeGattUUIDs(services));
         });
     }
     /**
@@ -247,16 +217,11 @@ export class BleNitro {
      * @returns Promise resolving to array of characteristic UUIDs
      */
     getCharacteristics(deviceId, serviceId) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId), (characteristics) => {
-                resolve(BleNitro.normalizeGattUUIDs(characteristics));
-            });
-        });
+        if (!this._connectedDevices[deviceId]) {
+            throw new Error('Device not connected');
+        }
+        const characteristics = BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId));
+        return BleNitro.normalizeGattUUIDs(characteristics);
     }
     /**
      * Read a characteristic value
@@ -317,29 +282,27 @@ export class BleNitro {
      * @returns Promise resolving when subscription is complete
      */
     subscribeToCharacteristic(deviceId, serviceId, characteristicId, callback) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
+        // Check if connected first
+        if (!this._connectedDevices[deviceId]) {
+            throw new Error('Device not connected');
+        }
+        let _success = false;
+        BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
+            callback(charId, data);
+        }, (success, error) => {
+            _success = success;
+            if (!success) {
+                throw new Error(error);
             }
-            BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
-                callback(charId, data);
-            }, (success, error) => {
-                if (success) {
-                    resolve({
-                        remove: () => {
-                            return new Promise((resolve, reject) => {
-                                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).then(resolve).catch(reject);
-                            });
-                        },
-                    });
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
         });
+        return {
+            remove: () => {
+                if (!_success) {
+                    return;
+                }
+                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).catch(() => { });
+            }
+        };
     }
     /**
      * Unsubscribe from characteristic notifications
@@ -370,14 +333,11 @@ export class BleNitro {
      * @returns Promise resolving to Bluetooth state
      */
     isBluetoothEnabled() {
-        return new Promise((resolve) => {
-            BleNitroNative.isBluetoothEnabled((enabled) => {
-                resolve(enabled);
-            });
-        });
+        return this.state() === BLEState.PoweredOn;
     }
     /**
      * Request to enable Bluetooth
+     * Only works on Android
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable() {
@@ -398,11 +358,7 @@ export class BleNitro {
      * @see BLEState
      */
     state() {
-        return new Promise((resolve) => {
-            BleNitroNative.state((state) => {
-                resolve(mapNativeBLEStateToBLEState(state));
-            });
-        });
+        return mapNativeBLEStateToBLEState(BleNitroNative.state());
     }
     /**
      * Subscribe to Bluetooth state changes
@@ -412,37 +368,18 @@ export class BleNitro {
      * @see BLEState
      */
     subscribeToStateChange(callback, emitInitial = false) {
-        return new Promise(async (resolve, reject) => {
-            if (emitInitial) {
-                const state = await this.state().catch(() => {
-                    return BLEState.Unknown;
-                });
-                callback(state);
-            }
-            BleNitroNative.subscribeToStateChange((nativeState) => {
-                callback(mapNativeBLEStateToBLEState(nativeState));
-            }, (success, error) => {
-                if (success) {
-                    resolve({
-                        remove: () => {
-                            return new Promise((resolve, reject) => {
-                                BleNitroNative.unsubscribeFromStateChange((success, error) => {
-                                    if (success) {
-                                        resolve();
-                                    }
-                                    else {
-                                        reject(new Error(error));
-                                    }
-                                });
-                            });
-                        },
-                    });
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
+        if (emitInitial) {
+            const state = this.state();
+            callback(state);
+        }
+        BleNitroNative.subscribeToStateChange((nativeState) => {
+            callback(mapNativeBLEStateToBLEState(nativeState));
         });
+        return {
+            remove: () => {
+                BleNitroNative.unsubscribeFromStateChange();
+            },
+        };
     }
     /**
      * Open Bluetooth settings

package/lib/specs/NativeBleNitro.nitro.d.ts

@@ -37,6 +37,10 @@ export type StateCallback = (state: BLEState) => void;
 export type BooleanCallback = (result: boolean) => void;
 export type StringArrayCallback = (result: string[]) => void;
 export type ReadCharacteristicCallback = (success: boolean, data: number[], error: string) => void;
+export type OperationResult = {
+    success: boolean;
+    error?: string;
+};
 /**
  * Native BLE Nitro Module Specification
  * Defines the interface between TypeScript and native implementations
@@ -46,23 +50,22 @@ export interface NativeBleNitro extends HybridObject<{
     android: 'kotlin';
 }> {
     startScan(filter: ScanFilter, callback: ScanCallback): void;
-    stopScan(callback: OperationCallback): void;
-    isScanning(callback: BooleanCallback): void;
-    getConnectedDevices(callback: DevicesCallback): void;
+    stopScan(): boolean;
+    isScanning(): boolean;
+    getConnectedDevices(services: string[]): BLEDevice[];
     connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
     disconnect(deviceId: string, callback: OperationCallback): void;
-    isConnected(deviceId: string, callback: BooleanCallback): void;
+    isConnected(deviceId: string): boolean;
     discoverServices(deviceId: string, callback: OperationCallback): void;
-    getServices(deviceId: string, callback: StringArrayCallback): void;
-    getCharacteristics(deviceId: string, serviceId: string, callback: StringArrayCallback): void;
+    getServices(deviceId: string): string[];
+    getCharacteristics(deviceId: string, serviceId: string): string[];
     readCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: ReadCharacteristicCallback): void;
     writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], withResponse: boolean, callback: OperationCallback): void;
     subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, updateCallback: CharacteristicCallback, resultCallback: OperationCallback): void;
     unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;
-    isBluetoothEnabled(callback: BooleanCallback): void;
     requestBluetoothEnable(callback: OperationCallback): void;
-    state(callback: StateCallback): void;
-    subscribeToStateChange(stateCallback: StateCallback, resultCallback: OperationCallback): void;
-    unsubscribeFromStateChange(resultCallback: OperationCallback): void;
+    state(): BLEState;
+    subscribeToStateChange(stateCallback: StateCallback): OperationResult;
+    unsubscribeFromStateChange(): OperationResult;
     openSettings(): Promise<void>;
 }

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -17,12 +17,9 @@
 
 #include "JHybridNativeBleNitroSpec.hpp"
 #include "JFunc_void_BLEDevice.hpp"
-#include "JFunc_void_bool_std__string.hpp"
-#include "JFunc_void_bool.hpp"
-#include "JFunc_void_std__vector_BLEDevice_.hpp"
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
-#include "JFunc_void_std__vector_std__string_.hpp"
+#include "JFunc_void_bool_std__string.hpp"
 #include "JFunc_void_bool_std__vector_double__std__string.hpp"
 #include "JFunc_void_std__string_std__vector_double_.hpp"
 #include "JFunc_void_BLEState.hpp"
@@ -39,12 +36,9 @@ int initialize(JavaVM* vm) {
     // Register native JNI methods
     margelo::nitro::co::zyke::ble::JHybridNativeBleNitroSpec::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEDevice_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_bool_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_BLEDevice__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_bool_std__string_cxx::registerNatives();
-    margelo::nitro::co::zyke::ble::JFunc_void_std__vector_std__string__cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__vector_double__std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__vector_double__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();

package/nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.cpp

@@ -7,8 +7,6 @@
 
 #include "JHybridNativeBleNitroSpec.hpp"
 
-// Forward declaration of `ScanFilter` to properly resolve imports.
-namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `ManufacturerData` to properly resolve imports.
@@ -17,33 +15,36 @@ namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
 namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+// Forward declaration of `OperationResult` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
+// Forward declaration of `ScanFilter` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 
-#include <NitroModules/Promise.hpp>
-#include <NitroModules/JPromise.hpp>
-#include "ScanFilter.hpp"
-#include "JScanFilter.hpp"
-#include <string>
-#include <vector>
 #include "BLEDevice.hpp"
-#include <functional>
-#include "JFunc_void_BLEDevice.hpp"
+#include <vector>
 #include "JBLEDevice.hpp"
+#include <string>
 #include "ManufacturerData.hpp"
 #include "JManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
 #include "JManufacturerDataEntry.hpp"
-#include "JFunc_void_bool_std__string.hpp"
-#include "JFunc_void_bool.hpp"
-#include "JFunc_void_std__vector_BLEDevice_.hpp"
-#include "JFunc_void_bool_std__string_std__string.hpp"
+#include "BLEState.hpp"
+#include "JBLEState.hpp"
+#include "OperationResult.hpp"
+#include "JOperationResult.hpp"
 #include <optional>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "ScanFilter.hpp"
+#include "JScanFilter.hpp"
+#include <functional>
+#include "JFunc_void_BLEDevice.hpp"
+#include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
-#include "JFunc_void_std__vector_std__string_.hpp"
+#include "JFunc_void_bool_std__string.hpp"
 #include "JFunc_void_bool_std__vector_double__std__string.hpp"
 #include "JFunc_void_std__string_std__vector_double_.hpp"
-#include "BLEState.hpp"
 #include "JFunc_void_BLEState.hpp"
-#include "JBLEState.hpp"
 
 namespace margelo::nitro::co::zyke::ble {
 
@@ -75,17 +76,37 @@ namespace margelo::nitro::co::zyke::ble {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScanFilter> /* filter */, jni::alias_ref<JFunc_void_BLEDevice::javaobject> /* callback */)>("startScan_cxx");
     method(_javaPart, JScanFilter::fromCpp(filter), JFunc_void_BLEDevice_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::stopScan(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("stopScan_cxx");
-    method(_javaPart, JFunc_void_bool_std__string_cxx::fromCpp(callback));
-  }
-  void JHybridNativeBleNitroSpec::isScanning(const std::function<void(bool /* result */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("isScanning_cxx");
-    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
+  bool JHybridNativeBleNitroSpec::stopScan() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("stopScan");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
   }
-  void JHybridNativeBleNitroSpec::getConnectedDevices(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_BLEDevice_::javaobject> /* callback */)>("getConnectedDevices_cxx");
-    method(_javaPart, JFunc_void_std__vector_BLEDevice__cxx::fromCpp(callback));
+  bool JHybridNativeBleNitroSpec::isScanning() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isScanning");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::vector<BLEDevice> JHybridNativeBleNitroSpec::getConnectedDevices(const std::vector<std::string>& services) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JBLEDevice>>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* services */)>("getConnectedDevices");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = services.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = services[__i];
+        __array->setElement(__i, *jni::make_jstring(__element));
+      }
+      return __array;
+    }());
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<BLEDevice> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
   }
   void JHybridNativeBleNitroSpec::connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool_std__string_std__string::javaobject> /* callback */, jni::alias_ref<JFunc_void_std__string_bool_std__string::javaobject> /* disconnectCallback */)>("connect_cxx");
@@ -95,21 +116,42 @@ namespace margelo::nitro::co::zyke::ble {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("disconnect_cxx");
     method(_javaPart, jni::make_jstring(deviceId), JFunc_void_bool_std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::isConnected(const std::string& deviceId, const std::function<void(bool /* result */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("isConnected_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), JFunc_void_bool_cxx::fromCpp(callback));
+  bool JHybridNativeBleNitroSpec::isConnected(const std::string& deviceId) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* deviceId */)>("isConnected");
+    auto __result = method(_javaPart, jni::make_jstring(deviceId));
+    return static_cast<bool>(__result);
   }
   void JHybridNativeBleNitroSpec::discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("discoverServices_cxx");
     method(_javaPart, jni::make_jstring(deviceId), JFunc_void_bool_std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::getServices(const std::string& deviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_std__vector_std__string_::javaobject> /* callback */)>("getServices_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), JFunc_void_std__vector_std__string__cxx::fromCpp(callback));
+  std::vector<std::string> JHybridNativeBleNitroSpec::getServices(const std::string& deviceId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>(jni::alias_ref<jni::JString> /* deviceId */)>("getServices");
+    auto __result = method(_javaPart, jni::make_jstring(deviceId));
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }();
   }
-  void JHybridNativeBleNitroSpec::getCharacteristics(const std::string& deviceId, const std::string& serviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<JFunc_void_std__vector_std__string_::javaobject> /* callback */)>("getCharacteristics_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), JFunc_void_std__vector_std__string__cxx::fromCpp(callback));
+  std::vector<std::string> JHybridNativeBleNitroSpec::getCharacteristics(const std::string& deviceId, const std::string& serviceId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */)>("getCharacteristics");
+    auto __result = method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId));
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }();
   }
   void JHybridNativeBleNitroSpec::readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_bool_std__vector_double__std__string::javaobject> /* callback */)>("readCharacteristic_cxx");
@@ -132,25 +174,24 @@ namespace margelo::nitro::co::zyke::ble {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<jni::JString> /* serviceId */, jni::alias_ref<jni::JString> /* characteristicId */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("unsubscribeFromCharacteristic_cxx");
     method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_bool_std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::isBluetoothEnabled(const std::function<void(bool /* result */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("isBluetoothEnabled_cxx");
-    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
-  }
   void JHybridNativeBleNitroSpec::requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("requestBluetoothEnable_cxx");
     method(_javaPart, JFunc_void_bool_std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::state(const std::function<void(BLEState /* state */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_BLEState::javaobject> /* callback */)>("state_cxx");
-    method(_javaPart, JFunc_void_BLEState_cxx::fromCpp(callback));
+  BLEState JHybridNativeBleNitroSpec::state() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JBLEState>()>("state");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
   }
-  void JHybridNativeBleNitroSpec::subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_BLEState::javaobject> /* stateCallback */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* resultCallback */)>("subscribeToStateChange_cxx");
-    method(_javaPart, JFunc_void_BLEState_cxx::fromCpp(stateCallback), JFunc_void_bool_std__string_cxx::fromCpp(resultCallback));
+  OperationResult JHybridNativeBleNitroSpec::subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JOperationResult>(jni::alias_ref<JFunc_void_BLEState::javaobject> /* stateCallback */)>("subscribeToStateChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_BLEState_cxx::fromCpp(stateCallback));
+    return __result->toCpp();
   }
-  void JHybridNativeBleNitroSpec::unsubscribeFromStateChange(const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* resultCallback */)>("unsubscribeFromStateChange_cxx");
-    method(_javaPart, JFunc_void_bool_std__string_cxx::fromCpp(resultCallback));
+  OperationResult JHybridNativeBleNitroSpec::unsubscribeFromStateChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JOperationResult>()>("unsubscribeFromStateChange");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
   }
   std::shared_ptr<Promise<void>> JHybridNativeBleNitroSpec::openSettings() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("openSettings");

package/nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.hpp

@@ -54,24 +54,23 @@ namespace margelo::nitro::co::zyke::ble {
   public:
     // Methods
     void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) override;
-    void stopScan(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
-    void isScanning(const std::function<void(bool /* result */)>& callback) override;
-    void getConnectedDevices(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& callback) override;
+    bool stopScan() override;
+    bool isScanning() override;
+    std::vector<BLEDevice> getConnectedDevices(const std::vector<std::string>& services) override;
     void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) override;
     void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
-    void isConnected(const std::string& deviceId, const std::function<void(bool /* result */)>& callback) override;
+    bool isConnected(const std::string& deviceId) override;
     void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
-    void getServices(const std::string& deviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) override;
-    void getCharacteristics(const std::string& deviceId, const std::string& serviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) override;
+    std::vector<std::string> getServices(const std::string& deviceId) override;
+    std::vector<std::string> getCharacteristics(const std::string& deviceId, const std::string& serviceId) override;
     void readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::vector<double>& /* data */, const std::string& /* error */)>& callback) override;
     void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::vector<double>& data, bool withResponse, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
     void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(const std::string& /* characteristicId */, const std::vector<double>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) override;
     void unsubscribeFromCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
-    void isBluetoothEnabled(const std::function<void(bool /* result */)>& callback) override;
     void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
-    void state(const std::function<void(BLEState /* state */)>& callback) override;
-    void subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) override;
-    void unsubscribeFromStateChange(const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) override;
+    BLEState state() override;
+    OperationResult subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback) override;
+    OperationResult unsubscribeFromStateChange() override;
     std::shared_ptr<Promise<void>> openSettings() override;
 
   private: