react-native-ble-nitro 1.1.0 → 1.3.0

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_()
@@ -222,6 +234,18 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func requestMTU(deviceId: std.string, mtu: Double) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.requestMTU(deviceId: String(deviceId), mtu: mtu)
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func discoverServices(deviceId: std.string, callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {
@@ -275,18 +299,12 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func readCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, callback: bridge.Func_void_bool_std__vector_double__std__string) -> bridge.Result_void_ {
+  public final func readCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, callback: bridge.Func_void_bool_std__shared_ptr_ArrayBuffer__std__string) -> bridge.Result_void_ {
     do {
-      try self.__implementation.readCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), callback: { () -> (Bool, [Double], String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__vector_double__std__string(callback)
-        return { (__success: Bool, __data: [Double], __error: String) -> Void in
-          __wrappedFunction.call(__success, { () -> bridge.std__vector_double_ in
-            var __vector = bridge.create_std__vector_double_(__data.count)
-            for __item in __data {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }(), std.string(__error))
+      try self.__implementation.readCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), callback: { () -> (Bool, ArrayBuffer, String) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(callback)
+        return { (__success: Bool, __data: ArrayBuffer, __error: String) -> Void in
+          __wrappedFunction.call(__success, __data, std.string(__error))
         }
       }())
       return bridge.create_Result_void_()
@@ -297,9 +315,9 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func writeCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, data: bridge.std__vector_double_, 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__string) -> bridge.Result_void_ {
     do {
-      try self.__implementation.writeCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), data: data.map({ __item in __item }), withResponse: withResponse, callback: { () -> (Bool, String) -> Void in
+      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))
@@ -313,18 +331,12 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func subscribeToCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, updateCallback: bridge.Func_void_std__string_std__vector_double_, resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func subscribeToCharacteristic(deviceId: std.string, serviceId: std.string, characteristicId: std.string, updateCallback: bridge.Func_void_std__string_std__shared_ptr_ArrayBuffer_, resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {
-      try self.__implementation.subscribeToCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), updateCallback: { () -> (String, [Double]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__string_std__vector_double_(updateCallback)
-        return { (__characteristicId: String, __data: [Double]) -> Void in
-          __wrappedFunction.call(std.string(__characteristicId), { () -> bridge.std__vector_double_ in
-            var __vector = bridge.create_std__vector_double_(__data.count)
-            for __item in __data {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }())
+      try self.__implementation.subscribeToCharacteristic(deviceId: String(deviceId), serviceId: String(serviceId), characteristicId: String(characteristicId), updateCallback: { () -> (String, ArrayBuffer) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__string_std__shared_ptr_ArrayBuffer_(updateCallback)
+        return { (__characteristicId: String, __data: ArrayBuffer) -> Void in
+          __wrappedFunction.call(std.string(__characteristicId), __data)
         }
       }(), resultCallback: { () -> (Bool, String) -> Void in
         let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(resultCallback)

package/nitrogen/generated/ios/swift/ManufacturerDataEntry.swift

@@ -18,14 +18,8 @@ public extension ManufacturerDataEntry {
   /**
    * Create a new instance of `ManufacturerDataEntry`.
    */
-  init(id: String, data: [Double]) {
-    self.init(std.string(id), { () -> bridge.std__vector_double_ in
-      var __vector = bridge.create_std__vector_double_(data.count)
-      for __item in data {
-        __vector.push_back(__item)
-      }
-      return __vector
-    }())
+  init(id: String, data: ArrayBuffer) {
+    self.init(std.string(id), data.getArrayBuffer())
   }
 
   var id: String {
@@ -39,20 +33,14 @@ public extension ManufacturerDataEntry {
     }
   }
   
-  var data: [Double] {
+  var data: ArrayBuffer {
     @inline(__always)
     get {
-      return self.__data.map({ __item in __item })
+      return ArrayBuffer(self.__data)
     }
     @inline(__always)
     set {
-      self.__data = { () -> bridge.std__vector_double_ in
-        var __vector = bridge.create_std__vector_double_(newValue.count)
-        for __item in newValue {
-          __vector.push_back(__item)
-        }
-        return __vector
-      }()
+      self.__data = newValue.getArrayBuffer()
     }
   }
 }

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.cpp

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

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

@@ -17,6 +17,8 @@
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 // Forward declaration of `OperationResult` to properly resolve imports.
@@ -24,10 +26,11 @@ 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"
 #include <NitroModules/Promise.hpp>
@@ -63,19 +66,20 @@ 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;
       virtual void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) = 0;
       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 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::vector<double>& /* data */, const std::string& /* error */)>& callback) = 0;
-      virtual void writeCharacteristic(const std::string& deviceId, const std::string& serviceId, const std::string& characteristicId, const std::vector<double>& data, bool withResponse, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 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::vector<double>& /* data */)>& updateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 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 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;
       virtual BLEState state() = 0;

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

@@ -18,10 +18,11 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
 
 #include <string>
-#include <vector>
+#include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
 
@@ -31,11 +32,11 @@ namespace margelo::nitro::co::zyke::ble {
   struct ManufacturerDataEntry {
   public:
     std::string id     SWIFT_PRIVATE;
-    std::vector<double> data     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> data     SWIFT_PRIVATE;
 
   public:
     ManufacturerDataEntry() = default;
-    explicit ManufacturerDataEntry(std::string id, std::vector<double> data): id(id), data(data) {}
+    explicit ManufacturerDataEntry(std::string id, std::shared_ptr<ArrayBuffer> data): id(id), data(data) {}
   };
 
 } // namespace margelo::nitro::co::zyke::ble
@@ -49,13 +50,13 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::co::zyke::ble::ManufacturerDataEntry(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "id")),
-        JSIConverter<std::vector<double>>::fromJSI(runtime, obj.getProperty(runtime, "data"))
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "data"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::co::zyke::ble::ManufacturerDataEntry& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "id", JSIConverter<std::string>::toJSI(runtime, arg.id));
-      obj.setProperty(runtime, "data", JSIConverter<std::vector<double>>::toJSI(runtime, arg.data));
+      obj.setProperty(runtime, "data", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.data));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -64,7 +65,7 @@ namespace margelo::nitro {
       }
       jsi::Object obj = value.getObject(runtime);
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "id"))) return false;
-      if (!JSIConverter<std::vector<double>>::canConvert(runtime, obj.getProperty(runtime, "data"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "data"))) return false;
       return true;
     }
   };

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.1.0",
+  "version": "1.3.0",
   "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/react-native.config.js

@@ -1,8 +1,16 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+
 module.exports = {
   dependency: {
     platforms: {
-      android: {},
+      /**
+       * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+       */
       ios: {},
+      /**
+       * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+       */
+      android: {},
     },
   },
-};
+}