react-native-ble-nitro 1.2.0 → 1.3.1

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

@@ -110,12 +110,24 @@ open class HybridNativeBleNitroSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func startScan(filter: ScanFilter, callback: bridge.Func_void_BLEDevice) -> bridge.Result_void_ {
+  public final func startScan(filter: ScanFilter, callback: bridge.Func_void_std__optional_BLEDevice__std__optional_std__string_) -> bridge.Result_void_ {
     do {
-      try self.__implementation.startScan(filter: filter, callback: { () -> (BLEDevice) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_BLEDevice(callback)
-        return { (__device: BLEDevice) -> Void in
-          __wrappedFunction.call(__device)
+      try self.__implementation.startScan(filter: filter, callback: { () -> (BLEDevice?, String?) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__optional_BLEDevice__std__optional_std__string_(callback)
+        return { (__device: BLEDevice?, __error: String?) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__optional_BLEDevice_ in
+            if let __unwrappedValue = __device {
+              return bridge.create_std__optional_BLEDevice_(__unwrappedValue)
+            } else {
+              return .init()
+            }
+          }(), { () -> bridge.std__optional_std__string_ in
+            if let __unwrappedValue = __error {
+              return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+            } else {
+              return .init()
+            }
+          }())
         }
       }())
       return bridge.create_Result_void_()

package/nitrogen/generated/ios/swift/ScanFilter.swift

@@ -18,14 +18,14 @@ public extension ScanFilter {
   /**
    * Create a new instance of `ScanFilter`.
    */
-  init(serviceUUIDs: [String], rssiThreshold: Double, allowDuplicates: Bool) {
+  init(serviceUUIDs: [String], rssiThreshold: Double, allowDuplicates: Bool, androidScanMode: AndroidScanMode) {
     self.init({ () -> bridge.std__vector_std__string_ in
       var __vector = bridge.create_std__vector_std__string_(serviceUUIDs.count)
       for __item in serviceUUIDs {
         __vector.push_back(std.string(__item))
       }
       return __vector
-    }(), rssiThreshold, allowDuplicates)
+    }(), rssiThreshold, allowDuplicates, androidScanMode)
   }
 
   var serviceUUIDs: [String] {
@@ -66,4 +66,15 @@ public extension ScanFilter {
       self.__allowDuplicates = newValue
     }
   }
+  
+  var androidScanMode: AndroidScanMode {
+    @inline(__always)
+    get {
+      return self.__androidScanMode
+    }
+    @inline(__always)
+    set {
+      self.__androidScanMode = newValue
+    }
+  }
 }

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

@@ -0,0 +1,64 @@
+///
+/// AndroidScanMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::co::zyke::ble {
+
+  /**
+   * An enum which can be represented as a JavaScript enum (AndroidScanMode).
+   */
+  enum class AndroidScanMode {
+    LOWLATENCY      SWIFT_NAME(lowlatency) = 0,
+    BALANCED      SWIFT_NAME(balanced) = 1,
+    LOWPOWER      SWIFT_NAME(lowpower) = 2,
+    OPPORTUNISTIC      SWIFT_NAME(opportunistic) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::co::zyke::ble
+
+namespace margelo::nitro {
+
+  // C++ AndroidScanMode <> JS AndroidScanMode (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::co::zyke::ble::AndroidScanMode> final {
+    static inline margelo::nitro::co::zyke::ble::AndroidScanMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::co::zyke::ble::AndroidScanMode>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::co::zyke::ble::AndroidScanMode arg) {
+      int enumValue = static_cast<int>(arg);
+      return JSIConverter<int>::toJSI(runtime, enumValue);
+    }
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
+      if (!value.isNumber()) {
+        return false;
+      }
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
+        return false;
+      }
+      // Check if we are within the bounds of the enum.
+      return integer >= 0 && integer <= 3;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -26,10 +26,10 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
 #include "ScanFilter.hpp"
 #include "BLEDevice.hpp"
+#include <optional>
+#include <string>
 #include <functional>
 #include <vector>
-#include <string>
-#include <optional>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
@@ -66,7 +66,7 @@ namespace margelo::nitro::co::zyke::ble {
 
     public:
       // Methods
-      virtual void startScan(const ScanFilter& filter, const std::function<void(const BLEDevice& /* device */)>& callback) = 0;
+      virtual void startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) = 0;
       virtual bool stopScan() = 0;
       virtual bool isScanning() = 0;
       virtual std::vector<BLEDevice> getConnectedDevices(const std::vector<std::string>& services) = 0;

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

@@ -18,10 +18,12 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// Forward declaration of `AndroidScanMode` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 
 #include <string>
 #include <vector>
+#include "AndroidScanMode.hpp"
 
 namespace margelo::nitro::co::zyke::ble {
 
@@ -33,10 +35,11 @@ namespace margelo::nitro::co::zyke::ble {
     std::vector<std::string> serviceUUIDs     SWIFT_PRIVATE;
     double rssiThreshold     SWIFT_PRIVATE;
     bool allowDuplicates     SWIFT_PRIVATE;
+    AndroidScanMode androidScanMode     SWIFT_PRIVATE;
 
   public:
     ScanFilter() = default;
-    explicit ScanFilter(std::vector<std::string> serviceUUIDs, double rssiThreshold, bool allowDuplicates): serviceUUIDs(serviceUUIDs), rssiThreshold(rssiThreshold), allowDuplicates(allowDuplicates) {}
+    explicit ScanFilter(std::vector<std::string> serviceUUIDs, double rssiThreshold, bool allowDuplicates, AndroidScanMode androidScanMode): serviceUUIDs(serviceUUIDs), rssiThreshold(rssiThreshold), allowDuplicates(allowDuplicates), androidScanMode(androidScanMode) {}
   };
 
 } // namespace margelo::nitro::co::zyke::ble
@@ -51,7 +54,8 @@ namespace margelo::nitro {
       return margelo::nitro::co::zyke::ble::ScanFilter(
         JSIConverter<std::vector<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "serviceUUIDs")),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "rssiThreshold")),
-        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "allowDuplicates"))
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "allowDuplicates")),
+        JSIConverter<margelo::nitro::co::zyke::ble::AndroidScanMode>::fromJSI(runtime, obj.getProperty(runtime, "androidScanMode"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::co::zyke::ble::ScanFilter& arg) {
@@ -59,6 +63,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "serviceUUIDs", JSIConverter<std::vector<std::string>>::toJSI(runtime, arg.serviceUUIDs));
       obj.setProperty(runtime, "rssiThreshold", JSIConverter<double>::toJSI(runtime, arg.rssiThreshold));
       obj.setProperty(runtime, "allowDuplicates", JSIConverter<bool>::toJSI(runtime, arg.allowDuplicates));
+      obj.setProperty(runtime, "androidScanMode", JSIConverter<margelo::nitro::co::zyke::ble::AndroidScanMode>::toJSI(runtime, arg.androidScanMode));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -69,6 +74,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::vector<std::string>>::canConvert(runtime, obj.getProperty(runtime, "serviceUUIDs"))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "rssiThreshold"))) return false;
       if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "allowDuplicates"))) return false;
+      if (!JSIConverter<margelo::nitro::co::zyke::ble::AndroidScanMode>::canConvert(runtime, obj.getProperty(runtime, "androidScanMode"))) return false;
       return true;
     }
   };

package/package.json

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

package/plugin/build/index.d.ts

@@ -15,6 +15,8 @@ import withBleNitro, { withBleNitroAndroid, withBleNitroIOS, type BleNitroPlugin
  *         {
  *           "isBackgroundEnabled": true,
  *           "modes": ["peripheral", "central"],
+ *           "neverForLocation": true,
+ *           "androidAdvertisingEnabled": true,
  *           "bluetoothAlwaysPermission": "Allow $(PRODUCT_NAME) to connect to bluetooth devices"
  *         }
  *       ]

package/plugin/build/index.js

@@ -53,6 +53,8 @@ Object.defineProperty(exports, "withBleNitroIOS", { enumerable: true, get: funct
  *         {
  *           "isBackgroundEnabled": true,
  *           "modes": ["peripheral", "central"],
+ *           "neverForLocation": true,
+ *           "androidAdvertisingEnabled": true,
  *           "bluetoothAlwaysPermission": "Allow $(PRODUCT_NAME) to connect to bluetooth devices"
  *         }
  *       ]

package/plugin/build/withBleNitro.d.ts

@@ -11,7 +11,6 @@ export interface BleNitroPluginProps {
      * physical location from Bluetooth scan results. The location permission
      * will still be required on older Android devices.
      * @default false
-     * @warning This parameter is experimental and BLE might not work. Test before releasing.
      */
     neverForLocation?: boolean;
     /**
@@ -24,6 +23,11 @@ export interface BleNitroPluginProps {
      * @default "Allow $(PRODUCT_NAME) to connect to bluetooth devices"
      */
     bluetoothAlwaysPermission?: string | false;
+    /**
+     * Android advertising permission message. Set to false to skip adding the permission.
+     * @default "Allow $(PRODUCT_NAME) to advertise bluetooth devices"
+     */
+    androidAdvertisingEnabled?: boolean;
 }
 export declare const withBleNitroAndroid: ConfigPlugin<BleNitroPluginProps>;
 export declare const withBleNitroIOS: ConfigPlugin<BleNitroPluginProps>;

package/plugin/build/withBleNitro.js

@@ -5,22 +5,26 @@ const config_plugins_1 = require("@expo/config-plugins");
 const BLUETOOTH_PERMISSIONS = [
     'android.permission.BLUETOOTH',
     'android.permission.BLUETOOTH_ADMIN',
-    'android.permission.ACCESS_COARSE_LOCATION',
+    // 'android.permission.ACCESS_COARSE_LOCATION',
     'android.permission.ACCESS_FINE_LOCATION',
 ];
 const BLUETOOTH_PERMISSIONS_API_31 = [
     'android.permission.BLUETOOTH_SCAN',
-    'android.permission.BLUETOOTH_ADVERTISE',
+    // 'android.permission.BLUETOOTH_ADVERTISE',
     'android.permission.BLUETOOTH_CONNECT',
 ];
+const BLUETOOTH_ADVERTISE_API_31 = [
+    'android.permission.BLUETOOTH_ADVERTISE',
+];
 const withBleNitroAndroid = (config, props = {}) => {
-    const { isBackgroundEnabled = false, neverForLocation = false } = props;
+    const { isBackgroundEnabled = false, neverForLocation = false, androidAdvertisingEnabled = false } = props;
     return (0, config_plugins_1.withAndroidManifest)(config, (config) => {
         const androidManifest = config.modResults;
         // Add required permissions
         config_plugins_1.AndroidConfig.Permissions.ensurePermissions(config.modResults, [
             ...BLUETOOTH_PERMISSIONS,
             ...BLUETOOTH_PERMISSIONS_API_31,
+            ...(androidAdvertisingEnabled ? BLUETOOTH_ADVERTISE_API_31 : []),
         ]);
         // Add uses-feature for BLE
         if (!androidManifest.manifest['uses-feature']) {
@@ -38,16 +42,23 @@ const withBleNitroAndroid = (config, props = {}) => {
             usesFeatures.push(bleFeature);
         }
         // Handle location permission settings for Android 12+
+        const permissions = androidManifest.manifest['uses-permission'] || [];
         if (neverForLocation) {
-            // Add neverForLocation attribute to location permissions for Android 12+
-            const permissions = androidManifest.manifest['uses-permission'] || [];
             permissions.forEach((permission) => {
-                if (permission.$?.['android:name'] === 'android.permission.ACCESS_FINE_LOCATION' ||
-                    permission.$?.['android:name'] === 'android.permission.ACCESS_COARSE_LOCATION') {
+                if (permission.$?.['android:name'] === 'android.permission.ACCESS_FINE_LOCATION') {
+                    permission.$['android:maxSdkVersion'] = '30';
+                }
+                if (permission.$?.['android:name'] === 'android.permission.BLUETOOTH_SCAN') {
                     permission.$['android:usesPermissionFlags'] = 'neverForLocation';
                 }
             });
         }
+        permissions.forEach((permission) => {
+            if (permission.$?.['android:name'] === 'android.permission.BLUETOOTH' ||
+                permission.$?.['android:name'] === 'android.permission.BLUETOOTH_ADMIN') {
+                permission.$['android:maxSdkVersion'] = '30';
+            }
+        });
         return config;
     });
 };

package/src/__tests__/index.test.ts

@@ -8,6 +8,7 @@ jest.mock('../specs/NativeBleNitro', () => ({
     connect: jest.fn(),
     disconnect: jest.fn(),
     isConnected: jest.fn(),
+    requestMTU: jest.fn(),
     discoverServices: jest.fn(),
     getServices: jest.fn(),
     getCharacteristics: jest.fn(),
@@ -15,12 +16,27 @@ jest.mock('../specs/NativeBleNitro', () => ({
     writeCharacteristic: jest.fn(),
     subscribeToCharacteristic: jest.fn(),
     unsubscribeFromCharacteristic: jest.fn(),
-    isBluetoothEnabled: jest.fn(),
+    getConnectedDevices: jest.fn(),
     requestBluetoothEnable: jest.fn(),
     state: jest.fn(),
     subscribeToStateChange: jest.fn(),
+    unsubscribeFromStateChange: jest.fn(),
+    openSettings: jest.fn(),
+  },
+  BLEState: { 
+    Unknown: 0,
+    Resetting: 1,
+    Unsupported: 2,
+    Unauthorized: 3,
+    PoweredOff: 4,
+    PoweredOn: 5
+  },
+  AndroidScanMode: {
+    LowLatency: 0,
+    Balanced: 1,
+    LowPower: 2,
+    Opportunistic: 3
   },
-  BLEState: { PoweredOn: 5, PoweredOff: 4 },
 }));
 
 import { ble as BleNitro } from '../index';
@@ -46,15 +62,23 @@ describe('BleNitro', () => {
         serviceUUIDs: ['test'],
         rssiThreshold: -100,
         allowDuplicates: false,
+        androidScanMode: 1, // AndroidScanMode.Balanced (default)
       },
       expect.any(Function)
     );
   });
 
-  test('stopScan calls native and resolves', () => {
-    mockNative.stopScan.mockImplementation(() => {
-      // stopScan is void, no callback needed
+  test('stopScan calls native and resolves', async () => {
+    // First start a scan to set _isScanning to true
+    mockNative.startScan.mockImplementation((filter, callback) => { // eslint-disable-line @typescript-eslint/no-unused-vars
+      // Just start scanning
     });
+    
+    const scanCallback = jest.fn();
+    await BleNitro.startScan({ serviceUUIDs: ['test'] }, scanCallback);
+
+    // Now stop the scan
+    mockNative.stopScan.mockImplementation(() => true);
 
     BleNitro.stopScan();
     
@@ -91,8 +115,9 @@ describe('BleNitro', () => {
   });
 
   test('writeCharacteristic requires connected device', async () => {
+    const data = [1, 2, 3];
     await expect(
-      BleNitro.writeCharacteristic('device', 'service', 'char', [1, 2, 3])
+      BleNitro.writeCharacteristic('device', 'service', 'char',data)
     ).rejects.toThrow('Device not connected');
   });
 
@@ -104,8 +129,9 @@ describe('BleNitro', () => {
     await BleNitro.connect('device');
 
     // Then read
-    mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: number[], error: string) => void) => {
-      callback(true, [85], ''); // Battery level 85%
+    mockNative.readCharacteristic.mockImplementation((_device: string, _service: string, _char: string, callback: (success: boolean, data: ArrayBuffer, error: string) => void) => {
+      const testData = new Uint8Array([85]);
+      callback(true, testData.buffer, ''); // Battery level 85%
     });
 
     const result = await BleNitro.readCharacteristic('device', 'service', 'char');
@@ -117,6 +143,9 @@ describe('BleNitro', () => {
       '0000char-0000-1000-8000-00805f9b34fb',  // 'char' padded to 8 chars
       expect.any(Function)
     );
+    
+    // Result should be number array (ByteArray)
+    expect(Array.isArray(result)).toBe(true);
     expect(result).toEqual([85]);
   });
 
@@ -146,17 +175,22 @@ describe('BleNitro', () => {
     await BleNitro.connect('device');
 
     // Mock subscription
-    mockNative.subscribeToCharacteristic.mockImplementation((_device: string, _service: string, _char: string, updateCallback: (charId: string, data: number[]) => void, resultCallback: (success: boolean, error: string) => void) => {
+    mockNative.subscribeToCharacteristic.mockImplementation((_device: string, _service: string, _char: string, updateCallback: (charId: string, data: ArrayBuffer) => void, resultCallback: (success: boolean, error: string) => void) => {
       resultCallback(true, '');
       // Simulate notification
-      updateCallback('char-id', [1, 2, 3]);
+      const testData = new Uint8Array([1, 2, 3]);
+      updateCallback('char-id', testData.buffer);
     });
 
     const notificationCallback = jest.fn();
-    BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
+    const subscription = BleNitro.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
     
     expect(mockNative.subscribeToCharacteristic).toHaveBeenCalled();
     expect(notificationCallback).toHaveBeenCalledWith('char-id', [1, 2, 3]);
+    
+    // Verify subscription object
+    expect(subscription).toHaveProperty('remove');
+    expect(typeof subscription.remove).toBe('function');
   });
 
   test('connect with disconnect event callback', async () => {

package/src/index.ts

@@ -3,6 +3,8 @@ import {
   ScanFilter as NativeScanFilter,
   BLEDevice as NativeBLEDevice,
   BLEState as NativeBLEState,
+  ScanCallback as NativeScanCallback,
+  AndroidScanMode as NativeAndroidScanMode,
 } from './specs/NativeBleNitro';
 
 export type ByteArray = number[];
@@ -11,6 +13,7 @@ export interface ScanFilter {
   serviceUUIDs?: string[];
   rssiThreshold?: number;
   allowDuplicates?: boolean;
+  androidScanMode?: AndroidScanMode;
 }
 
 export interface ManufacturerDataEntry {
@@ -32,6 +35,7 @@ export interface BLEDevice {
 }
 
 export type ScanCallback = (device: BLEDevice) => void;
+export type RestoreStateCallback = (connectedPeripherals: BLEDevice[]) => void;
 export type ConnectionCallback = (
   success: boolean,
   deviceId: string,
@@ -61,6 +65,18 @@ export enum BLEState {
   PoweredOn = 'PoweredOn',
 };
 
+export enum AndroidScanMode {
+  LowLatency = 'LowLatency',
+  Balanced = 'Balanced',
+  LowPower = 'LowPower',
+  Opportunistic = 'Opportunistic',
+}
+
+export type BleNitroOptions = {
+  restoreStateIdentifier?: string;
+  onRestoreState?: RestoreStateCallback;
+};
+
 function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
   const map = {
     0: BLEState.Unknown,
@@ -73,6 +89,29 @@ function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState {
   return map[nativeState];
 }
 
+function mapAndroidScanModeToNativeAndroidScanMode(scanMode: AndroidScanMode): NativeAndroidScanMode {
+  const map = {
+    LowLatency: NativeAndroidScanMode.LowLatency,
+    Balanced: NativeAndroidScanMode.Balanced,
+    LowPower: NativeAndroidScanMode.LowPower,
+    Opportunistic: NativeAndroidScanMode.Opportunistic,
+  }
+  return map[scanMode];
+}
+
+function convertNativeBleDeviceToBleDevice(nativeBleDevice: NativeBLEDevice): BLEDevice {
+  return {
+    ...nativeBleDevice,
+    serviceUUIDs: BleNitro.normalizeGattUUIDs(nativeBleDevice.serviceUUIDs),
+    manufacturerData: {
+      companyIdentifiers: nativeBleDevice.manufacturerData.companyIdentifiers.map(entry => ({
+        id: entry.id,
+        data: arrayBufferToByteArray(entry.data)
+      }))
+    }
+  }
+}
+
 function arrayBufferToByteArray(buffer: ArrayBuffer): ByteArray {
   return Array.from(new Uint8Array(buffer));
 }
@@ -126,7 +165,8 @@ export class BleNitro {
    */
   public startScan(
     filter: ScanFilter = {},
-    callback: ScanCallback
+    callback: ScanCallback,
+    onError?: (error: string) => void,
   ): void {
     if (this._isScanning) {
       return;
@@ -137,21 +177,19 @@ export class BleNitro {
       serviceUUIDs: filter.serviceUUIDs || [],
       rssiThreshold: filter.rssiThreshold ?? -100,
       allowDuplicates: filter.allowDuplicates ?? false,
+      androidScanMode: mapAndroidScanModeToNativeAndroidScanMode(filter.androidScanMode ?? AndroidScanMode.Balanced),
     };
 
     // Create callback wrapper
-    const scanCallback = (device: NativeBLEDevice) => {
+    const scanCallback: NativeScanCallback = (device: NativeBLEDevice | null, error: string | null) => {
+      if (error && !device) {
+        this._isScanning = false;
+        onError?.(error);
+        return;
+      }
+      device = device!; // eslint-disable-line @typescript-eslint/no-non-null-assertion
       // Convert manufacturer data to Uint8Arrays
-      const convertedDevice: BLEDevice = {
-        ...device,
-        serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
-        manufacturerData: {
-          companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
-            id: entry.id,
-            data: arrayBufferToByteArray(entry.data)
-          }))
-        }
-      };
+      const convertedDevice: BLEDevice = convertNativeBleDeviceToBleDevice(device);
       callback(convertedDevice);
     };
 
@@ -170,6 +208,7 @@ export class BleNitro {
     }
 
     BleNitroNative.stopScan();
+    this._isScanning = false;
   }
 
   /**
@@ -189,16 +228,7 @@ export class BleNitro {
   public getConnectedDevices(services?: string[]): BLEDevice[] {
     const devices = BleNitroNative.getConnectedDevices(services || []);
     // Normalize service UUIDs - manufacturer data already comes as ArrayBuffers
-    return devices.map(device => ({
-      ...device,
-      serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs),
-      manufacturerData: {
-        companyIdentifiers: device.manufacturerData.companyIdentifiers.map(entry => ({
-          id: entry.id,
-          data: arrayBufferToByteArray(entry.data)
-        }))
-      }
-    }));
+    return devices.map(device => convertNativeBleDeviceToBleDevice(device));
   }
 
   /**
@@ -360,7 +390,7 @@ export class BleNitro {
    * @param deviceId ID of the device
    * @param serviceId ID of the service
    * @param characteristicId ID of the characteristic
-   * @returns Promise resolving to the characteristic data as ByteArray
+   * @returns Promise resolving to the characteristic data as ArrayBuffer
    */
   public readCharacteristic(
     deviceId: string,
@@ -394,7 +424,7 @@ export class BleNitro {
    * @param deviceId ID of the device
    * @param serviceId ID of the service
    * @param characteristicId ID of the characteristic
-   * @param data Data to write as ByteArray(number[])
+   * @param data Data to write as ByteArray (number[])
    * @param withResponse Whether to wait for response
    * @returns Promise resolving when write is complete
    */
@@ -412,13 +442,11 @@ export class BleNitro {
         return;
       }
 
-      const dataAsArrayBuffer = byteArrayToArrayBuffer(data);
-
       BleNitroNative.writeCharacteristic(
         deviceId,
         BleNitro.normalizeGattUUID(serviceId),
         BleNitro.normalizeGattUUID(characteristicId),
-        dataAsArrayBuffer,
+        byteArrayToArrayBuffer(data),
         withResponse,
         (success: boolean, error: string) => {
           if (success) {

package/src/specs/NativeBleNitro.nitro.ts

@@ -31,13 +31,21 @@ export interface BLEDevice {
   isConnectable: boolean;
 }
 
+export enum AndroidScanMode {
+  LowLatency = 0,
+  Balanced = 1,
+  LowPower = 2,
+  Opportunistic = 3,
+}
+
 export interface ScanFilter {
   serviceUUIDs: string[];
   rssiThreshold: number;
   allowDuplicates: boolean;
+  androidScanMode: AndroidScanMode;
 }
 
-export type ScanCallback = (device: BLEDevice) => void;
+export type ScanCallback = (device: BLEDevice | null, error: string | null) => void;
 export type DevicesCallback = (devices: BLEDevice[]) => void;
 export type ConnectionCallback = (success: boolean, deviceId: string, error: string) => void;
 export type DisconnectionEventCallback = (deviceId: string, interrupted: boolean, error: string) => void;