react-native-ble-nitro 1.4.0 → 1.5.0

package/lib/manager.d.ts

@@ -45,7 +45,7 @@ export declare enum AndroidScanMode {
     Opportunistic = "Opportunistic"
 }
 export type BleNitroManagerOptions = {
-    onRestoreState?: RestoreStateCallback;
+    onRestoredState?: RestoreStateCallback;
 };
 export declare function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState;
 export declare function mapAndroidScanModeToNativeAndroidScanMode(scanMode: AndroidScanMode): NativeAndroidScanMode;
@@ -55,11 +55,11 @@ export declare function byteArrayToArrayBuffer(data: ByteArray): ArrayBuffer;
 export declare class BleNitroManager {
     private _isScanning;
     private _connectedDevices;
-    private _restoreStateCallback;
+    private _restoredStateCallback;
     private _restoredState;
     constructor(options?: BleNitroManagerOptions);
     private onNativeRestoreStateCallback;
-    onRestoreState(callback: RestoreStateCallback): void;
+    onRestoredState(callback: RestoreStateCallback): void;
     /**
      * Converts a 16- oder 32-Bit UUID to a 128-Bit UUID
      *
@@ -117,6 +117,12 @@ export declare class BleNitroManager {
      * @returns On Android: new MTU size; on iOS: current MTU size as it is handled by iOS itself; on error: -1
      */
     requestMTU(deviceId: string, mtu: number): number;
+    /**
+     * Read RSSI for a connected device
+     * @param deviceId ID of the device
+     * @returns Promise resolving to RSSI value
+     */
+    readRSSI(deviceId: string): Promise<number>;
     /**
      * Discover services for a connected device
      * @param deviceId ID of the device
@@ -151,9 +157,9 @@ export declare class BleNitroManager {
      * @param characteristicId ID of the characteristic
      * @param data Data to write as ByteArray (number[])
      * @param withResponse Whether to wait for response
-     * @returns Promise resolving when write is complete
+     * @returns Promise resolving with response data (empty ByteArray when withResponse=false)
      */
-    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: ByteArray, withResponse?: boolean): Promise<boolean>;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: ByteArray, withResponse?: boolean): Promise<ByteArray>;
     /**
      * Subscribe to characteristic notifications
      * @param deviceId ID of the device

package/lib/manager.js

@@ -59,26 +59,26 @@ export class BleNitroManager {
     constructor(options) {
         this._isScanning = false;
         this._connectedDevices = {};
-        this._restoreStateCallback = null;
+        this._restoredStateCallback = null;
         this._restoredState = null;
-        this._restoreStateCallback = options?.onRestoreState || null;
+        this._restoredStateCallback = options?.onRestoredState || null;
         BleNitroNative.setRestoreStateCallback((peripherals) => this.onNativeRestoreStateCallback(peripherals));
     }
     onNativeRestoreStateCallback(peripherals) {
         const bleDevices = peripherals.map((peripheral) => convertNativeBleDeviceToBleDevice(peripheral));
-        if (this._restoreStateCallback) {
-            this._restoreStateCallback(bleDevices);
+        if (this._restoredStateCallback) {
+            this._restoredStateCallback(bleDevices);
         }
         else {
             this._restoredState = bleDevices;
         }
     }
-    onRestoreState(callback) {
+    onRestoredState(callback) {
         if (this._restoredState) {
             callback(this._restoredState);
             this._restoredState = null;
         }
-        this._restoreStateCallback = callback;
+        this._restoredStateCallback = callback;
     }
     /**
      * Converts a 16- oder 32-Bit UUID to a 128-Bit UUID
@@ -232,6 +232,28 @@ export class BleNitroManager {
         const deviceMtu = BleNitroNative.requestMTU(deviceId, mtu);
         return deviceMtu;
     }
+    /**
+     * Read RSSI for a connected device
+     * @param deviceId ID of the device
+     * @returns Promise resolving to RSSI value
+     */
+    readRSSI(deviceId) {
+        return new Promise((resolve, reject) => {
+            // Check if connected first
+            if (!this._connectedDevices[deviceId]) {
+                reject(new Error('Device not connected'));
+                return;
+            }
+            BleNitroNative.readRSSI(deviceId, (success, rssi, error) => {
+                if (success) {
+                    resolve(rssi);
+                }
+                else {
+                    reject(new Error(error));
+                }
+            });
+        });
+    }
     /**
      * Discover services for a connected device
      * @param deviceId ID of the device
@@ -319,7 +341,7 @@ export class BleNitroManager {
      * @param characteristicId ID of the characteristic
      * @param data Data to write as ByteArray (number[])
      * @param withResponse Whether to wait for response
-     * @returns Promise resolving when write is complete
+     * @returns Promise resolving with response data (empty ByteArray when withResponse=false)
      */
     writeCharacteristic(deviceId, serviceId, characteristicId, data, withResponse = true) {
         return new Promise((resolve, reject) => {
@@ -328,9 +350,11 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.writeCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), byteArrayToArrayBuffer(data), withResponse, (success, error) => {
+            BleNitroNative.writeCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), byteArrayToArrayBuffer(data), withResponse, (success, responseData, error) => {
                 if (success) {
-                    resolve(true);
+                    // Convert ArrayBuffer response to ByteArray
+                    const responseByteArray = arrayBufferToByteArray(responseData);
+                    resolve(responseByteArray);
                 }
                 else {
                     reject(new Error(error));

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

@@ -45,6 +45,8 @@ export type StateCallback = (state: BLEState) => void;
 export type BooleanCallback = (result: boolean) => void;
 export type StringArrayCallback = (result: string[]) => void;
 export type ReadCharacteristicCallback = (success: boolean, data: BLEValue, error: string) => void;
+export type WriteCharacteristicCallback = (success: boolean, responseData: BLEValue, error: string) => void;
+export type ReadRSSICallback = (success: boolean, rssi: number, error: string) => void;
 export type RestoreCallback = (restoredPeripherals: BLEDevice[]) => void;
 export type OperationResult = {
     success: boolean;
@@ -67,11 +69,12 @@ export interface NativeBleNitro extends HybridObject<{
     disconnect(deviceId: string, callback: OperationCallback): void;
     isConnected(deviceId: string): boolean;
     requestMTU(deviceId: string, mtu: number): number;
+    readRSSI(deviceId: string, callback: ReadRSSICallback): void;
     discoverServices(deviceId: string, callback: OperationCallback): 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: BLEValue, withResponse: boolean, callback: OperationCallback): void;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: BLEValue, withResponse: boolean, callback: WriteCharacteristicCallback): void;
     subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, updateCallback: CharacteristicCallback, resultCallback: OperationCallback): void;
     unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: OperationCallback): void;
     requestBluetoothEnable(callback: OperationCallback): void;

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -21,6 +21,7 @@
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
 #include "JFunc_void_bool_std__string.hpp"
+#include "JFunc_void_bool_double_std__string.hpp"
 #include "JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string.hpp"
 #include "JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JFunc_void_BLEState.hpp"
@@ -41,6 +42,7 @@ int initialize(JavaVM* vm) {
     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_bool_std__string_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JFunc_void_bool_double_std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();

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

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_bool_double_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 <functional>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(success: Boolean, rssi: Double, error: String) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool_double_std__string: public jni::JavaClass<JFunc_void_bool_double_std__string> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_double_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool_double_std__string` instance holds through JNI.
+     */
+    void invoke(bool success, double rssi, const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* success */, double /* rssi */, jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), success, rssi, jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_bool_double_std__string that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_bool_double_std__string_cxx final: public jni::HybridClass<JFunc_void_bool_double_std__string_cxx, JFunc_void_bool_double_std__string> {
+  public:
+    static jni::local_ref<JFunc_void_bool_double_std__string::javaobject> fromCpp(const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& func) {
+      return JFunc_void_bool_double_std__string_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_bool_double_std__string_cxx` instance holds.
+     */
+    void invoke_cxx(jboolean success, double rssi, jni::alias_ref<jni::JString> error) {
+      _func(static_cast<bool>(success), rssi, error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_bool_double_std__string_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_bool_double_std__string_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_bool_double_std__string_cxx(const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -52,6 +52,7 @@ namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
 #include "JFunc_void_bool_std__string.hpp"
+#include "JFunc_void_bool_double_std__string.hpp"
 #include "JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string.hpp"
 #include "JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JFunc_void_BLEState.hpp"
@@ -140,6 +141,10 @@ namespace margelo::nitro::co::zyke::ble {
     auto __result = method(_javaPart, jni::make_jstring(deviceId), mtu);
     return __result;
   }
+  void JHybridNativeBleNitroSpec::readRSSI(const std::string& deviceId, const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JFunc_void_bool_double_std__string::javaobject> /* callback */)>("readRSSI_cxx");
+    method(_javaPart, jni::make_jstring(deviceId), JFunc_void_bool_double_std__string_cxx::fromCpp(callback));
+  }
   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));
@@ -176,9 +181,9 @@ 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__shared_ptr_ArrayBuffer__std__string::javaobject> /* callback */)>("readCharacteristic_cxx");
     method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::fromCpp(callback));
   }
-  void JHybridNativeBleNitroSpec::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::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<JArrayBuffer::javaobject> /* data */, jboolean /* withResponse */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* callback */)>("writeCharacteristic_cxx");
-    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JArrayBuffer::wrap(data), withResponse, JFunc_void_bool_std__string_cxx::fromCpp(callback));
+  void JHybridNativeBleNitroSpec::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) {
+    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<JArrayBuffer::javaobject> /* data */, jboolean /* withResponse */, jni::alias_ref<JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string::javaobject> /* callback */)>("writeCharacteristic_cxx");
+    method(_javaPart, jni::make_jstring(deviceId), jni::make_jstring(serviceId), jni::make_jstring(characteristicId), JArrayBuffer::wrap(data), withResponse, JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::fromCpp(callback));
   }
   void JHybridNativeBleNitroSpec::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 */)>& resultCallback) {
     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_std__string_std__shared_ptr_ArrayBuffer_::javaobject> /* updateCallback */, jni::alias_ref<JFunc_void_bool_std__string::javaobject> /* resultCallback */)>("subscribeToCharacteristic_cxx");

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

@@ -62,11 +62,12 @@ namespace margelo::nitro::co::zyke::ble {
     void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;
     bool isConnected(const std::string& deviceId) override;
     double requestMTU(const std::string& deviceId, double mtu) override;
+    void readRSSI(const std::string& deviceId, const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& callback) override;
     void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& 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::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>& callback) override;
-    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::string& /* error */)>& callback) override;
+    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) 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::shared_ptr<ArrayBuffer>& /* 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 requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;

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

@@ -0,0 +1,81 @@
+///
+/// Func_void_bool_double_std__string.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.co.zyke.ble
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(success: boolean, rssi: number, error: string) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_bool_double_std__string: (Boolean, Double, String) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(success: Boolean, rssi: Double, error: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(success: boolean, rssi: number, error: string) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_bool_double_std__string_cxx: Func_void_bool_double_std__string {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(success: Boolean, rssi: Double, error: String): Unit
+    = invoke_cxx(success,rssi,error)
+
+  @FastNative
+  private external fun invoke_cxx(success: Boolean, rssi: Double, error: String): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(success: boolean, rssi: number, error: string) => void`.
+ * This is implemented in Java/Kotlin, via a `(Boolean, Double, String) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_bool_double_std__string_java(private val function: (Boolean, Double, String) -> Unit): Func_void_bool_double_std__string {
+  @DoNotStrip
+  @Keep
+  override fun invoke(success: Boolean, rssi: Double, error: String): Unit {
+    return this.function(success, rssi, error)
+  }
+}

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

@@ -96,6 +96,15 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   @Keep
   abstract fun requestMTU(deviceId: String, mtu: Double): Double
   
+  abstract fun readRSSI(deviceId: String, callback: (success: Boolean, rssi: Double, error: String) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun readRSSI_cxx(deviceId: String, callback: Func_void_bool_double_std__string): Unit {
+    val __result = readRSSI(deviceId, callback)
+    return __result
+  }
+  
   abstract fun discoverServices(deviceId: String, callback: (success: Boolean, error: String) -> Unit): Unit
   
   @DoNotStrip
@@ -122,11 +131,11 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
     return __result
   }
   
-  abstract fun writeCharacteristic(deviceId: String, serviceId: String, characteristicId: String, data: ArrayBuffer, withResponse: Boolean, callback: (success: Boolean, error: String) -> Unit): Unit
+  abstract fun writeCharacteristic(deviceId: String, serviceId: String, characteristicId: String, data: ArrayBuffer, withResponse: Boolean, callback: (success: Boolean, responseData: ArrayBuffer, error: String) -> Unit): Unit
   
   @DoNotStrip
   @Keep
-  private fun writeCharacteristic_cxx(deviceId: String, serviceId: String, characteristicId: String, data: ArrayBuffer, withResponse: Boolean, callback: Func_void_bool_std__string): Unit {
+  private fun writeCharacteristic_cxx(deviceId: String, serviceId: String, characteristicId: String, data: ArrayBuffer, withResponse: Boolean, callback: Func_void_bool_std__shared_ptr_ArrayBuffer__std__string): Unit {
     val __result = writeCharacteristic(deviceId, serviceId, characteristicId, data, withResponse, callback)
     return __result
   }

package/nitrogen/generated/ios/BleNitro-Swift-Cxx-Bridge.cpp

@@ -53,6 +53,14 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>
+  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_bool_double_std__string::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool success, double rssi, const std::string& error) mutable -> void {
+      swiftClosure.call(success, rssi, error);
+    };
+  }
+  
   // pragma MARK: std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>
   Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = BleNitro::Func_void_bool_std__shared_ptr_ArrayBuffer__std__string::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/BleNitro-Swift-Cxx-Bridge.hpp

@@ -224,6 +224,28 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return Func_void_bool_std__string_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>
+  /**
+   * Specialized version of `std::function<void(bool, double, const std::string&)>`.
+   */
+  using Func_void_bool_double_std__string = std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * success * /, double / * rssi * /, const std::string& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_double_std__string_Wrapper final {
+  public:
+    explicit Func_void_bool_double_std__string_Wrapper(std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>&& func): _function(std::make_unique<std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>>(std::move(func))) {}
+    inline void call(bool success, double rssi, std::string error) const {
+      _function->operator()(success, rssi, error);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_bool_double_std__string_Wrapper wrap_Func_void_bool_double_std__string(Func_void_bool_double_std__string value) {
+    return Func_void_bool_double_std__string_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>
   /**
    * Specialized version of `std::function<void(bool, const std::shared_ptr<ArrayBuffer>&, const std::string&)>`.

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

@@ -151,6 +151,12 @@ namespace margelo::nitro::co::zyke::ble {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline void readRSSI(const std::string& deviceId, const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& callback) override {
+      auto __result = _swiftPart.readRSSI(deviceId, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override {
       auto __result = _swiftPart.discoverServices(deviceId, callback);
       if (__result.hasError()) [[unlikely]] {
@@ -179,7 +185,7 @@ namespace margelo::nitro::co::zyke::ble {
         std::rethrow_exception(__result.error());
       }
     }
-    inline 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::string& /* error */)>& callback) override {
+    inline 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) override {
       auto __result = _swiftPart.writeCharacteristic(deviceId, serviceId, characteristicId, ArrayBufferHolder(data), std::forward<decltype(withResponse)>(withResponse), callback);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());

package/nitrogen/generated/ios/swift/Func_void_bool_double_std__string.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_bool_double_std__string.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+
+/**
+ * Wraps a Swift `(_ success: Bool, _ rssi: Double, _ error: String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_bool_double_std__string {
+  public typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  private let closure: (_ success: Bool, _ rssi: Double, _ error: String) -> Void
+
+  public init(_ closure: @escaping (_ success: Bool, _ rssi: Double, _ error: String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(success: Bool, rssi: Double, error: std.string) -> Void {
+    self.closure(success, rssi, String(error))
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_bool_double_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_bool_double_std__string>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_bool_double_std__string {
+    return Unmanaged<Func_void_bool_double_std__string>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

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

@@ -23,11 +23,12 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
   func disconnect(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func isConnected(deviceId: String) throws -> Bool
   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 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, _ 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, resultCallback: @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 requestBluetoothEnable(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void

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

@@ -268,6 +268,22 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func readRSSI(deviceId: std.string, callback: bridge.Func_void_bool_double_std__string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.readRSSI(deviceId: String(deviceId), callback: { () -> (Bool, Double, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool_double_std__string(callback)
+        return { (__success: Bool, __rssi: Double, __error: String) -> Void in
+          __wrappedFunction.call(__success, __rssi, 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 discoverServices(deviceId: std.string, callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {
@@ -337,12 +353,12 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func writeCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, data: ArrayBuffer, withResponse: Bool, callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func writeCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, data: ArrayBuffer, withResponse: Bool, callback: bridge.Func_void_bool_std__shared_ptr_ArrayBuffer__std__string) -> bridge.Result_void_ {
     do {
-      try self.__implementation.writeCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), data: data, withResponse: withResponse, 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))
+      try self.__implementation.writeCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), data: data, withResponse: withResponse, callback: { () -> (Bool, ArrayBuffer, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(callback)
+        return { (__success: Bool, __responseData: ArrayBuffer, __error: String) -> Void in
+          __wrappedFunction.call(__success, __responseData, std.string(__error))
         }
       }())
       return bridge.create_Result_void_()

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

@@ -23,6 +23,7 @@ namespace margelo::nitro::co::zyke::ble {
       prototype.registerHybridMethod("disconnect", &HybridNativeBleNitroSpec::disconnect);
       prototype.registerHybridMethod("isConnected", &HybridNativeBleNitroSpec::isConnected);
       prototype.registerHybridMethod("requestMTU", &HybridNativeBleNitroSpec::requestMTU);
+      prototype.registerHybridMethod("readRSSI", &HybridNativeBleNitroSpec::readRSSI);
       prototype.registerHybridMethod("discoverServices", &HybridNativeBleNitroSpec::discoverServices);
       prototype.registerHybridMethod("getServices", &HybridNativeBleNitroSpec::getServices);
       prototype.registerHybridMethod("getCharacteristics", &HybridNativeBleNitroSpec::getCharacteristics);

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

@@ -75,11 +75,12 @@ namespace margelo::nitro::co::zyke::ble {
       virtual void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual bool isConnected(const std::string& deviceId) = 0;
       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 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::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 */)>& resultCallback) = 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 void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",