react-native-ble-nitro 1.10.3 → 1.12.0

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/HybridNativeBleNitroFactorySpec.kt

@@ -24,23 +24,6 @@ import com.margelo.nitro.core.HybridObject
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class HybridNativeBleNitroFactorySpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
-
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
-
-  // Default implementation of `HybridObject.toString()`
-  override fun toString(): String {
-    return "[HybridObject NativeBleNitroFactory]"
-  }
-
   // Properties
   
 
@@ -54,7 +37,21 @@ abstract class HybridNativeBleNitroFactorySpec: HybridObject() {
     return __result
   }
 
-  private external fun initHybrid(): HybridData
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NativeBleNitroFactory]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridNativeBleNitroFactorySpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridNativeBleNitroFactorySpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "HybridNativeBleNitroFactorySpec"

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/HybridNativeBleNitroSpec.kt

@@ -27,23 +27,6 @@ import com.margelo.nitro.core.HybridObject
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
 abstract class HybridNativeBleNitroSpec: HybridObject() {
-  @DoNotStrip
-  private var mHybridData: HybridData = initHybrid()
-
-  init {
-    super.updateNative(mHybridData)
-  }
-
-  override fun updateNative(hybridData: HybridData) {
-    mHybridData = hybridData
-    super.updateNative(hybridData)
-  }
-
-  // Default implementation of `HybridObject.toString()`
-  override fun toString(): String {
-    return "[HybridObject NativeBleNitro]"
-  }
-
   // Properties
   @get:DoNotStrip
   @get:Keep
@@ -130,6 +113,15 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
     return __result
   }
   
+  abstract fun discoverServicesWithCharacteristics(deviceId: String, callback: (success: Boolean, error: String) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun discoverServicesWithCharacteristics_cxx(deviceId: String, callback: Func_void_bool_std__string): Unit {
+    val __result = discoverServicesWithCharacteristics(deviceId, callback)
+    return __result
+  }
+  
   @DoNotStrip
   @Keep
   abstract fun getServices(deviceId: String): Array<String>
@@ -174,6 +166,10 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
     return __result
   }
   
+  @DoNotStrip
+  @Keep
+  abstract fun isSubscribedToCharacteristic(deviceId: String, serviceId: String, characteristicId: String): Boolean
+  
   abstract fun requestBluetoothEnable(callback: (success: Boolean, error: String) -> Unit): Unit
   
   @DoNotStrip
@@ -204,7 +200,21 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   @Keep
   abstract fun openSettings(): Promise<Unit>
 
-  private external fun initHybrid(): HybridData
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NativeBleNitro]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridNativeBleNitroSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridNativeBleNitroSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
 
   companion object {
     protected const val TAG = "HybridNativeBleNitroSpec"

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/Variant_NullType_BLEDevice.kt

@@ -21,12 +21,6 @@ sealed class Variant_NullType_BLEDevice {
   @DoNotStrip
   data class Second(@DoNotStrip val value: BLEDevice): Variant_NullType_BLEDevice()
 
-  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
-  inline fun <reified T> getAs(): T? = when (this) {
-    is First -> value as? T
-    is Second -> value as? T
-  }
-
   val isFirst: Boolean
     get() = this is First
   val isSecond: Boolean

package/nitrogen/generated/android/kotlin/com/margelo/nitro/co/zyke/ble/Variant_NullType_String.kt

@@ -21,12 +21,6 @@ sealed class Variant_NullType_String {
   @DoNotStrip
   data class Second(@DoNotStrip val value: String): Variant_NullType_String()
 
-  @Deprecated("getAs() is not type-safe. Use fold/asFirstOrNull/asSecondOrNull instead.", level = DeprecationLevel.ERROR)
-  inline fun <reified T> getAs(): T? = when (this) {
-    is First -> value as? T
-    is Second -> value as? T
-  }
-
   val isFirst: Boolean
     get() = this is First
   val isSecond: Boolean

package/nitrogen/generated/ios/c++/HybridNativeBleNitroSpecSwift.hpp

@@ -184,6 +184,12 @@ namespace margelo::nitro::co::zyke::ble {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void discoverServicesWithCharacteristics(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.discoverServicesWithCharacteristics(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::vector<std::string> getServices(const std::string& deviceId) override {
       auto __result = _swiftPart.getServices(deviceId);
       if (__result.hasError()) [[unlikely]] {
@@ -224,6 +230,14 @@ namespace margelo::nitro::co::zyke::ble {
         std::rethrow_exception(__result.error());
       }
     }
+    inline bool isSubscribedToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId) override {
+      auto __result = _swiftPart.isSubscribedToCharacteristic(deviceId, serviceId, characteristicId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
       auto __result = _swiftPart.requestBluetoothEnable(callback);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec.swift

@@ -25,12 +25,14 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
   func requestMTU(deviceId: String, mtu: Double) throws -> Double
   func readRSSI(deviceId: String, callback: @escaping (_ success: Bool, _ rssi: Double, _ error: String) -> Void) throws -> Void
   func discoverServices(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
+  func discoverServicesWithCharacteristics(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func getServices(deviceId: String) throws -> [String]
   func getCharacteristics(deviceId: String, serviceId: String) throws -> [String]
   func readCharacteristic(deviceId: String, serviceId: String, characteristicId: String, callback: @escaping (_ success: Bool, _ data: ArrayBuffer, _ error: String) -> Void) throws -> Void
   func writeCharacteristic(deviceId: String, serviceId: String, characteristicId: String, data: ArrayBuffer, withResponse: Bool, callback: @escaping (_ success: Bool, _ responseData: ArrayBuffer, _ error: String) -> Void) throws -> Void
   func subscribeToCharacteristic(deviceId: String, serviceId: String, characteristicId: String, updateCallback: @escaping (_ characteristicId: String, _ data: ArrayBuffer) -> Void, completionCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func unsubscribeFromCharacteristic(deviceId: String, serviceId: String, characteristicId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
+  func isSubscribedToCharacteristic(deviceId: String, serviceId: String, characteristicId: String) throws -> Bool
   func requestBluetoothEnable(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func state() throws -> BLEState
   func subscribeToStateChange(stateCallback: @escaping (_ state: BLEState) -> Void) throws -> OperationResult

package/nitrogen/generated/ios/swift/HybridNativeBleNitroSpec_cxx.swift

@@ -370,6 +370,22 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func discoverServicesWithCharacteristics(deviceId: std.string, callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.discoverServicesWithCharacteristics(deviceId: String(deviceId), callback: { () -> (Bool, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(callback)
+        return { (__success: Bool, __error: String) -> Void in
+          __wrappedFunction.call(__success, std.string(__error))
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getServices(deviceId: std.string) -> bridge.Result_std__vector_std__string__ {
     do {
@@ -475,6 +491,18 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func isSubscribedToCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isSubscribedToCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func requestBluetoothEnable(callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp

@@ -28,12 +28,14 @@ namespace margelo::nitro::co::zyke::ble {
       prototype.registerHybridMethod("requestMTU", &HybridNativeBleNitroSpec::requestMTU);
       prototype.registerHybridMethod("readRSSI", &HybridNativeBleNitroSpec::readRSSI);
       prototype.registerHybridMethod("discoverServices", &HybridNativeBleNitroSpec::discoverServices);
+      prototype.registerHybridMethod("discoverServicesWithCharacteristics", &HybridNativeBleNitroSpec::discoverServicesWithCharacteristics);
       prototype.registerHybridMethod("getServices", &HybridNativeBleNitroSpec::getServices);
       prototype.registerHybridMethod("getCharacteristics", &HybridNativeBleNitroSpec::getCharacteristics);
       prototype.registerHybridMethod("readCharacteristic", &HybridNativeBleNitroSpec::readCharacteristic);
       prototype.registerHybridMethod("writeCharacteristic", &HybridNativeBleNitroSpec::writeCharacteristic);
       prototype.registerHybridMethod("subscribeToCharacteristic", &HybridNativeBleNitroSpec::subscribeToCharacteristic);
       prototype.registerHybridMethod("unsubscribeFromCharacteristic", &HybridNativeBleNitroSpec::unsubscribeFromCharacteristic);
+      prototype.registerHybridMethod("isSubscribedToCharacteristic", &HybridNativeBleNitroSpec::isSubscribedToCharacteristic);
       prototype.registerHybridMethod("requestBluetoothEnable", &HybridNativeBleNitroSpec::requestBluetoothEnable);
       prototype.registerHybridMethod("state", &HybridNativeBleNitroSpec::state);
       prototype.registerHybridMethod("subscribeToStateChange", &HybridNativeBleNitroSpec::subscribeToStateChange);

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.hpp

@@ -79,12 +79,14 @@ namespace margelo::nitro::co::zyke::ble {
       virtual double requestMTU(const std::string& deviceId, double mtu) = 0;
       virtual void readRSSI(const std::string& deviceId, const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& callback) = 0;
       virtual void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
+      virtual void discoverServicesWithCharacteristics(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual std::vector<std::string> getServices(const std::string& deviceId) = 0;
       virtual std::vector<std::string> getCharacteristics(const std::string& deviceId, const std::string& serviceId) = 0;
       virtual void readCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& callback) = 0;
       virtual void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::shared_ptr<ArrayBuffer>& data, bool withResponse, const std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* responseData */, const std::string& /* error */)>& callback) = 0;
       virtual void subscribeToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& completionCallback) = 0;
       virtual 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) = 0;
+      virtual bool isSubscribedToCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId) = 0;
       virtual void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual BLEState state() = 0;
       virtual OperationResult subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.10.3",
+  "version": "1.12.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -77,25 +77,25 @@
     "url": "https://github.com/zykeco/react-native-ble-nitro/issues"
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=20.0.0"
   },
   "peerDependencies": {
     "react-native": ">=0.76.0",
-    "react-native-nitro-modules": ">=0.33.0"
+    "react-native-nitro-modules": ">=0.35.0"
   },
   "devDependencies": {
-    "@expo/config-plugins": "^54.0.4",
+    "@expo/config-plugins": "^55.0.6",
     "@types/jest": "^29.5.0",
-    "@types/node": "^20.19.30",
-    "@types/react": "^19.2.2",
+    "@types/node": "^24.11.0",
+    "@types/react": "^19.2.14",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "eslint": "^8.57.1",
-    "expo-module-scripts": "^5.0.8",
+    "expo-module-scripts": "^55.0.2",
     "jest": "^29.0.0",
-    "nitrogen": "^0.33.9",
+    "nitrogen": "^0.35.0",
     "react-native": "^0.83.2",
-    "react-native-nitro-modules": "^0.33.9",
+    "react-native-nitro-modules": "^0.35.0",
     "rimraf": "^6.1.3",
     "ts-jest": "^29.4.6",
     "typescript": "^5.9.3"

package/src/__tests__/index.test.ts

@@ -10,12 +10,14 @@ const mockNativeInstance = {
   requestMTU: jest.fn(),
   readRSSI: jest.fn(),
   discoverServices: jest.fn(),
+  discoverServicesWithCharacteristics: jest.fn(),
   getServices: jest.fn(),
   getCharacteristics: jest.fn(),
   readCharacteristic: jest.fn(),
   writeCharacteristic: jest.fn(),
   subscribeToCharacteristic: jest.fn(),
   unsubscribeFromCharacteristic: jest.fn(),
+  isSubscribedToCharacteristic: jest.fn(),
   getConnectedDevices: jest.fn(),
   requestBluetoothEnable: jest.fn(),
   state: jest.fn(),
@@ -143,6 +145,10 @@ describe('BleNitro', () => {
     });
     await BleManager.connect('device-write');
 
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-write';
+    });
+
     // Mock writeCharacteristic with new signature (success, responseData, error)
     mockNative.writeCharacteristic.mockImplementation((_deviceId: string, _serviceId: string, _charId: string, _data: ArrayBuffer, withResponse: boolean, callback: (success: boolean, responseData: ArrayBuffer, error: string) => void) => {
       // For withResponse=false, return empty ArrayBuffer
@@ -171,6 +177,10 @@ describe('BleNitro', () => {
     });
     await BleManager.connect('device-write-resp');
 
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-write-resp';
+    });
+
     // Mock writeCharacteristic to return response data
     mockNative.writeCharacteristic.mockImplementation((_deviceId: string, _serviceId: string, _charId: string, _data: ArrayBuffer, withResponse: boolean, callback: (success: boolean, responseData: ArrayBuffer, error: string) => void) => {
       // For withResponse=true, return some response data
@@ -192,12 +202,99 @@ describe('BleNitro', () => {
     expect(result).toEqual([0xAA, 0xBB, 0xCC]); // Response data as ByteArray
   });
 
+  test('getServicesWithCharacteristics discovers and returns services with characteristics', async () => {
+    // First connect
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-svc');
+
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-svc';
+    });
+
+    // Mock discoverServicesWithCharacteristics
+    mockNative.discoverServicesWithCharacteristics.mockImplementation((_deviceId: string, callback: (success: boolean, error: string) => void) => {
+      callback(true, '');
+    });
+
+    // Mock getServices to return service UUIDs
+    mockNative.getServices.mockReturnValue(['0000180a-0000-1000-8000-00805f9b34fb', '0000180f-0000-1000-8000-00805f9b34fb']);
+
+    // Mock getCharacteristics per service
+    mockNative.getCharacteristics.mockImplementation((_deviceId: string, serviceId: string) => {
+      if (serviceId === '0000180a-0000-1000-8000-00805f9b34fb') {
+        return ['00002a29-0000-1000-8000-00805f9b34fb'];
+      }
+      return ['00002a19-0000-1000-8000-00805f9b34fb'];
+    });
+
+    const result = await BleManager.getServicesWithCharacteristics('device-svc');
+
+    expect(mockNative.discoverServicesWithCharacteristics).toHaveBeenCalledWith(
+      'device-svc',
+      expect.any(Function)
+    );
+    expect(result).toHaveLength(2);
+    expect(result[0]).toHaveProperty('uuid');
+    expect(result[0]).toHaveProperty('characteristics');
+    expect(result[0].characteristics.length).toBeGreaterThan(0);
+  });
+
+  test('getServicesWithCharacteristics rejects on discovery failure', async () => {
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-svc-fail');
+
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-svc-fail';
+    });
+
+    mockNative.discoverServicesWithCharacteristics.mockImplementation((_deviceId: string, callback: (success: boolean, error: string) => void) => {
+      callback(false, 'Discovery failed');
+    });
+
+    await expect(BleManager.getServicesWithCharacteristics('device-svc-fail')).rejects.toThrow('Discovery failed');
+  });
+
+  test('getServicesWithCharacteristics rejects when not connected', async () => {
+    mockNative.isConnected.mockReturnValue(false);
+
+    await expect(BleManager.getServicesWithCharacteristics('unknown-device')).rejects.toThrow('Device not connected');
+  });
+
+  test('getServicesWithCharacteristics rejects with BleTimeoutError on timeout', async () => {
+    jest.useFakeTimers();
+
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void) => {
+      callback(true, id, '');
+    });
+    await BleManager.connect('device-timeout');
+
+    mockNative.isConnected.mockImplementation((id: string) => id === 'device-timeout');
+
+    // Mock that NEVER calls its callback — simulates hung native discovery
+    mockNative.discoverServicesWithCharacteristics.mockImplementation(() => {});
+
+    const promise = BleManager.getServicesWithCharacteristics('device-timeout');
+
+    jest.advanceTimersByTime(30_000);
+
+    await expect(promise).rejects.toThrow('timed out after 30000ms');
+
+    jest.useRealTimers();
+  });
+
   test('readCharacteristic works after connection', async () => {
     // First connect
     mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
     });
     await BleManager.connect('device');
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device';
+    });
 
     // Then read
     mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: ArrayBuffer, error: string) => void) => {
@@ -239,7 +336,7 @@ describe('BleNitro', () => {
     const result = await BleManager.disconnect('device');
 
     expect(mockNative.disconnect).toHaveBeenCalledWith('device', expect.any(Function));
-    expect(result).toBe(undefined);
+    expect(result).toBe('device');
   });
 
   test('subscribeToCharacteristic calls callback', async () => {
@@ -293,6 +390,47 @@ describe('BleNitro', () => {
     expect(onDisconnect).toHaveBeenCalledWith(deviceId, true, 'Connection lost');
   });
 
+  test('isSubscribedToCharacteristic delegates to native with normalized UUIDs', () => {
+    mockNative.isSubscribedToCharacteristic.mockReturnValueOnce(true);
+
+    const result = BleManager.isSubscribedToCharacteristic('device', 'service', 'char');
+
+    expect(result).toBe(true);
+    expect(mockNative.isSubscribedToCharacteristic).toHaveBeenCalledWith(
+      'device',
+      '0service-0000-1000-8000-00805f9b34fb',
+      '0000char-0000-1000-8000-00805f9b34fb'
+    );
+  });
+
+  test('isSubscribedToCharacteristic returns false when not subscribed', () => {
+    mockNative.isSubscribedToCharacteristic.mockReturnValueOnce(false);
+
+    const result = BleManager.isSubscribedToCharacteristic('device', 'service', 'char');
+
+    expect(result).toBe(false);
+  });
+
+  test('isSubscribedToCharacteristic delegates to native for unknown devices', () => {
+    // Native layer handles unknown/disconnected devices by returning false
+    mockNative.isSubscribedToCharacteristic.mockReturnValueOnce(false);
+
+    const result = BleManager.isSubscribedToCharacteristic('unknown-device', 'service', 'char');
+
+    expect(result).toBe(false);
+    expect(mockNative.isSubscribedToCharacteristic).toHaveBeenCalled();
+  });
+
+  test('isSubscribedToCharacteristic propagates native exception', () => {
+    mockNative.isSubscribedToCharacteristic.mockImplementationOnce(() => {
+      throw new Error('Native error');
+    });
+
+    expect(() =>
+      BleManager.isSubscribedToCharacteristic('device', 'service', 'char')
+    ).toThrow('Native error');
+  });
+
   test('readRSSI requires connected device', async () => {
     await expect(
       BleManager.readRSSI('device-not-connected')
@@ -305,6 +443,9 @@ describe('BleNitro', () => {
       callback(true, id, '');
     });
     await BleManager.connect('device-rssi');
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-rssi';
+    });
 
     // Mock readRSSI with new signature (success, rssi, error)
     mockNative.readRSSI.mockImplementation((_deviceId: string, callback: (success: boolean, rssi: number, error: string) => void) => {
@@ -326,6 +467,9 @@ describe('BleNitro', () => {
       callback(true, id, '');
     });
     await BleManager.connect('device-rssi-fail');
+    mockNative.isConnected.mockImplementation((id: string) => {
+      return id === 'device-rssi-fail';
+    });
 
     // Mock readRSSI failure
     mockNative.readRSSI.mockImplementation((_deviceId: string, callback: (success: boolean, rssi: number, error: string) => void) => {

package/src/index.ts

@@ -15,6 +15,7 @@ export {
   BLEState,
   AndroidScanMode,
   BleNitroManager,
+  BleTimeoutError,
 } from "./manager";
 
 export { BleNitro } from './singleton';