react-native-ble-nitro 1.0.0 → 1.1.0

package/src/index.ts

@@ -47,7 +47,7 @@ export type CharacteristicUpdateCallback = (
 ) => void;
 
 export type Subscription = {
-  remove: () => Promise<void>;
+  remove: () => void;
 };
 
 export enum BLEState {
@@ -117,85 +117,62 @@ export class BleNitro {
   public startScan(
     filter: ScanFilter = {},
     callback: ScanCallback
-  ): Promise<boolean> {
-    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: NativeScanFilter = {
-        serviceUUIDs: filter.serviceUUIDs || [],
-        rssiThreshold: filter.rssiThreshold ?? -100,
-        allowDuplicates: filter.allowDuplicates ?? false,
-      };
-
-      // Create callback wrapper
-      const scanCallback = (device: NativeBLEDevice) => {
-        device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
-        callback(device);
-      };
+  ): void {
+    if (this._isScanning) {
+      return;
+    }
 
-      // Start scan
-      BleNitroNative.startScan(nativeFilter, scanCallback);
-      this._isScanning = true;
-      resolve(true);
-    });
+    // Create native scan filter with defaults
+    const nativeFilter: NativeScanFilter = {
+      serviceUUIDs: filter.serviceUUIDs || [],
+      rssiThreshold: filter.rssiThreshold ?? -100,
+      allowDuplicates: filter.allowDuplicates ?? false,
+    };
+
+    // Create callback wrapper
+    const scanCallback = (device: NativeBLEDevice) => {
+      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
    */
-  public stopScan(): Promise<boolean> {
-    return new Promise((resolve, reject) => {
-      // Don't stop scanning if not scanning
-      if (!this._isScanning) {
-        resolve(true);
-        return;
-      }
+  public stopScan(): void {
+    if (!this._isScanning) {
+      return;
+    }
 
-      BleNitroNative.stopScan((success: boolean, error: string) => {
-        if (success) {
-          this._isScanning = false;
-          resolve(true);
-        } else {
-          reject(new Error(error));
-        }
-      });
-    });
+    BleNitroNative.stopScan();
   }
 
   /**
    * Check if currently scanning for devices
    * @returns Promise resolving to scanning state
    */
-  public isScanning(): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isScanning((scanning: boolean) => {
-        this._isScanning = scanning;
-        resolve(scanning);
-      });
-    });
+  public isScanning(): boolean {
+    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
    */
-  public getConnectedDevices(): Promise<BLEDevice[]> {
-    return new Promise((resolve) => {
-      BleNitroNative.getConnectedDevices((devices: BLEDevice[]) => {
-        // Normalize service UUIDs for connected devices
-        const normalizedDevices = devices.map(device => ({
-          ...device,
-          serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
-        }));
-        resolve(normalizedDevices);
-      });
-    });
+  public getConnectedDevices(services?: string[]): BLEDevice[] {
+    const devices = BleNitroNative.getConnectedDevices(services || []);
+    // Normalize service UUIDs for connected devices
+    return devices.map(device => ({
+      ...device,
+      serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
+    }));
   }
 
   /**
@@ -239,11 +216,11 @@ export class BleNitro {
    * @param deviceId ID of the device to disconnect from
    * @returns Promise resolving when disconnected
    */
-  public disconnect(deviceId: string): Promise<boolean> {
+  public disconnect(deviceId: string): Promise<void> {
     return new Promise((resolve, reject) => {
       // Check if already disconnected
       if (!this._connectedDevices[deviceId]) {
-        resolve(true);
+        resolve();
         return;
       }
 
@@ -252,7 +229,7 @@ export class BleNitro {
         (success: boolean, error: string) => {
           if (success) {
             delete this._connectedDevices[deviceId];
-            resolve(true);
+            resolve();
           } else {
             reject(new Error(error));
           }
@@ -266,13 +243,8 @@ export class BleNitro {
    * @param deviceId ID of the device to check
    * @returns Promise resolving to connection state
    */
-  public isConnected(deviceId: string): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isConnected(deviceId, (connected: boolean) => {
-        this._connectedDevices[deviceId] = connected;
-        resolve(connected);
-      });
-    });
+  public isConnected(deviceId: string): boolean {
+    return BleNitroNative.isConnected(deviceId);
   }
 
   /**
@@ -319,9 +291,8 @@ export class BleNitro {
         reject(new Error('Failed to discover services'));
         return;
       }
-      BleNitroNative.getServices(deviceId, (services: string[]) => {
-        resolve(BleNitro.normalizeGattUUIDs(services));
-      });
+      const services = BleNitroNative.getServices(deviceId);
+      resolve(BleNitro.normalizeGattUUIDs(services));
     });
   }
 
@@ -334,22 +305,16 @@ export class BleNitro {
   public getCharacteristics(
     deviceId: string,
     serviceId: string
-  ): Promise<string[]> {
-    return new Promise((resolve, reject) => {
-      // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
-        reject(new Error('Device not connected'));
-        return;
-      }
+  ): string[] {
+    if (!this._connectedDevices[deviceId]) {
+      throw new Error('Device not connected');
+    }
 
-      BleNitroNative.getCharacteristics(
-        deviceId,
-        BleNitro.normalizeGattUUID(serviceId),
-        (characteristics: string[]) => {
-          resolve(BleNitro.normalizeGattUUIDs(characteristics));
-        }
-      );
-    });
+    const characteristics = BleNitroNative.getCharacteristics(
+      deviceId,
+      BleNitro.normalizeGattUUID(serviceId),
+    );
+    return BleNitro.normalizeGattUUIDs(characteristics);
   }
 
   /**
@@ -439,40 +404,41 @@ export class BleNitro {
     serviceId: string,
     characteristicId: string,
     callback: CharacteristicUpdateCallback
-  ): Promise<Subscription> {
-    return new Promise((resolve, reject) => {
-      // Check if connected first
-      if (!this._connectedDevices[deviceId]) {
-        reject(new Error('Device not connected'));
-        return;
+  ): Subscription {
+    // 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: string, data: number[]) => {
+        callback(charId, data);
+      },
+      (success, error) => {
+        _success = success;
+        if (!success) {
+          throw new Error(error);
+        }
       }
+    );
 
-      BleNitroNative.subscribeToCharacteristic(
-        deviceId,
-        BleNitro.normalizeGattUUID(serviceId),
-        BleNitro.normalizeGattUUID(characteristicId),
-        (charId: string, data: number[]) => {
-          callback(charId, data);
-        },
-        (success: boolean, error: string) => {
-          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(() => {});
+      }
+    };
   }
 
   /**
@@ -513,16 +479,13 @@ export class BleNitro {
    * Check if Bluetooth is enabled
    * @returns Promise resolving to Bluetooth state
    */
-  public isBluetoothEnabled(): Promise<boolean> {
-    return new Promise((resolve) => {
-      BleNitroNative.isBluetoothEnabled((enabled: boolean) => {
-        resolve(enabled);
-      });
-    });
+  public isBluetoothEnabled(): boolean {
+    return this.state() === BLEState.PoweredOn;
   }
 
   /**
    * Request to enable Bluetooth
+   * Only works on Android
    * @returns Promise resolving when Bluetooth is enabled
    */
   public requestBluetoothEnable(): Promise<boolean> {
@@ -544,12 +507,8 @@ export class BleNitro {
    * @returns Promise resolving to Bluetooth state
    * @see BLEState
    */
-  public state(): Promise<BLEState> {
-    return new Promise((resolve) => {
-      BleNitroNative.state((state: NativeBLEState) => {
-        resolve(mapNativeBLEStateToBLEState(state));
-      });
-    });
+  public state(): BLEState {
+    return mapNativeBLEStateToBLEState(BleNitroNative.state());
   }
 
   /**
@@ -559,36 +518,21 @@ export class BleNitro {
    * @returns Promise resolving when subscription is complete
    * @see BLEState
    */
-  public subscribeToStateChange(callback: (state: BLEState) => void, emitInitial = false): Promise<Subscription> {
-    return new Promise(async (resolve, reject) => {
+  public subscribeToStateChange(callback: (state: BLEState) => void, emitInitial = false): Subscription {
       if (emitInitial) {
-        const state = await this.state().catch(() => {
-          return BLEState.Unknown;
-        });
+        const state = this.state();
         callback(state);
       }
+
       BleNitroNative.subscribeToStateChange((nativeState: NativeBLEState) => {
         callback(mapNativeBLEStateToBLEState(nativeState));
-      }, (success: boolean, error: string) => {
-        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));
-        }
       });
-    })
+
+      return {
+        remove: () => {
+          BleNitroNative.unsubscribeFromStateChange();
+        },
+      };
   }
 
   /**

package/src/specs/NativeBleNitro.nitro.ts

@@ -45,6 +45,11 @@ 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
@@ -52,21 +57,21 @@ export type ReadCharacteristicCallback = (success: boolean, data: number[], erro
 export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   // Scanning operations
   startScan(filter: ScanFilter, callback: ScanCallback): void;
-  stopScan(callback: OperationCallback): void;
-  isScanning(callback: BooleanCallback): void;
+  stopScan(): boolean;
+  isScanning(): boolean;
 
   // Device discovery
-  getConnectedDevices(callback: DevicesCallback): void;
+  getConnectedDevices(services: string[]): BLEDevice[];
 
   // Connection management
   connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
   disconnect(deviceId: string, callback: OperationCallback): void;
-  isConnected(deviceId: string, callback: BooleanCallback): void;
+  isConnected(deviceId: string): boolean;
 
   // Service discovery
   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[];
 
   // Characteristic operations
   readCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: ReadCharacteristicCallback): void;
@@ -75,10 +80,9 @@ export interface NativeBleNitro extends HybridObject<{ ios: 'swift'; android: 'k
   unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;
 
   // Bluetooth state management
-  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/c++/JFunc_void_bool.hpp

@@ -1,74 +0,0 @@
-///
-/// JFunc_void_bool.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include <functional>
-
-namespace margelo::nitro::co::zyke::ble {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(result: Boolean) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
-     */
-    void invoke(bool result) const {
-      static const auto method = javaClassStatic()->getMethod<void(jboolean /* result */)>("invoke");
-      method(self(), result);
-    }
-  };
-
-  /**
-   * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
-  public:
-    static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* result */)>& func) {
-      return JFunc_void_bool_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_cxx` instance holds.
-     */
-    void invoke_cxx(jboolean result) {
-      _func(static_cast<bool>(result));
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(bool /* result */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_bool_cxx(const std::function<void(bool /* result */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(bool /* result */)> _func;
-  };
-
-} // namespace margelo::nitro::co::zyke::ble

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

@@ -1,99 +0,0 @@
-///
-/// JFunc_void_std__vector_BLEDevice_.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include "BLEDevice.hpp"
-#include <vector>
-#include <functional>
-#include "JBLEDevice.hpp"
-#include <string>
-#include "ManufacturerData.hpp"
-#include "JManufacturerData.hpp"
-#include "ManufacturerDataEntry.hpp"
-#include "JManufacturerDataEntry.hpp"
-
-namespace margelo::nitro::co::zyke::ble {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(devices: Array<BLEDevice>) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_std__vector_BLEDevice_: public jni::JavaClass<JFunc_void_std__vector_BLEDevice_> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_BLEDevice_;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_std__vector_BLEDevice_` instance holds through JNI.
-     */
-    void invoke(const std::vector<BLEDevice>& devices) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JBLEDevice>> /* devices */)>("invoke");
-      method(self(), [&]() {
-        size_t __size = devices.size();
-        jni::local_ref<jni::JArrayClass<JBLEDevice>> __array = jni::JArrayClass<JBLEDevice>::newArray(__size);
-        for (size_t __i = 0; __i < __size; __i++) {
-          const auto& __element = devices[__i];
-          __array->setElement(__i, *JBLEDevice::fromCpp(__element));
-        }
-        return __array;
-      }());
-    }
-  };
-
-  /**
-   * An implementation of Func_void_std__vector_BLEDevice_ that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  struct JFunc_void_std__vector_BLEDevice__cxx final: public jni::HybridClass<JFunc_void_std__vector_BLEDevice__cxx, JFunc_void_std__vector_BLEDevice_> {
-  public:
-    static jni::local_ref<JFunc_void_std__vector_BLEDevice_::javaobject> fromCpp(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& func) {
-      return JFunc_void_std__vector_BLEDevice__cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_BLEDevice__cxx` instance holds.
-     */
-    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JBLEDevice>> devices) {
-      _func([&]() {
-              size_t __size = devices->size();
-              std::vector<BLEDevice> __vector;
-              __vector.reserve(__size);
-              for (size_t __i = 0; __i < __size; __i++) {
-                auto __element = devices->getElement(__i);
-                __vector.push_back(__element->toCpp());
-              }
-              return __vector;
-            }());
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(const std::vector<BLEDevice>& /* devices */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_BLEDevice__cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_BLEDevice__cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_std__vector_BLEDevice__cxx(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(const std::vector<BLEDevice>& /* devices */)> _func;
-  };
-
-} // namespace margelo::nitro::co::zyke::ble

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

@@ -1,93 +0,0 @@
-///
-/// JFunc_void_std__vector_std__string_.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include <string>
-#include <vector>
-#include <functional>
-
-namespace margelo::nitro::co::zyke::ble {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(result: Array<String>) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_std__vector_std__string_: public jni::JavaClass<JFunc_void_std__vector_std__string_> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_std__string_;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_std__vector_std__string_` instance holds through JNI.
-     */
-    void invoke(const std::vector<std::string>& result) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* result */)>("invoke");
-      method(self(), [&]() {
-        size_t __size = result.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 = result[__i];
-          __array->setElement(__i, *jni::make_jstring(__element));
-        }
-        return __array;
-      }());
-    }
-  };
-
-  /**
-   * An implementation of Func_void_std__vector_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  struct JFunc_void_std__vector_std__string__cxx final: public jni::HybridClass<JFunc_void_std__vector_std__string__cxx, JFunc_void_std__vector_std__string_> {
-  public:
-    static jni::local_ref<JFunc_void_std__vector_std__string_::javaobject> fromCpp(const std::function<void(const std::vector<std::string>& /* result */)>& func) {
-      return JFunc_void_std__vector_std__string__cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_std__string__cxx` instance holds.
-     */
-    void invoke_cxx(jni::alias_ref<jni::JArrayClass<jni::JString>> result) {
-      _func([&]() {
-              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;
-            }());
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(const std::vector<std::string>& /* result */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_std__string__cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_std__string__cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_std__vector_std__string__cxx(const std::function<void(const std::vector<std::string>& /* result */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(const std::vector<std::string>& /* result */)> _func;
-  };
-
-} // namespace margelo::nitro::co::zyke::ble