react-native-ble-nitro 1.14.0 → 1.15.1

package/lib/commonjs/specs/NativeBleNitro.nitro.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AndroidScanMode = exports.BLEState = void 0;
+exports.AndroidConnectionPriority = exports.AndroidScanMode = exports.BLEState = void 0;
 // Nitro constraint: Use numeric enums instead of string unions
 var BLEState;
 (function (BLEState) {
@@ -18,4 +18,10 @@ var AndroidScanMode;
     AndroidScanMode[AndroidScanMode["LowPower"] = 2] = "LowPower";
     AndroidScanMode[AndroidScanMode["Opportunistic"] = 3] = "Opportunistic";
 })(AndroidScanMode || (exports.AndroidScanMode = AndroidScanMode = {}));
+var AndroidConnectionPriority;
+(function (AndroidConnectionPriority) {
+    AndroidConnectionPriority[AndroidConnectionPriority["Balanced"] = 0] = "Balanced";
+    AndroidConnectionPriority[AndroidConnectionPriority["High"] = 1] = "High";
+    AndroidConnectionPriority[AndroidConnectionPriority["LowPower"] = 2] = "LowPower";
+})(AndroidConnectionPriority || (exports.AndroidConnectionPriority = AndroidConnectionPriority = {}));
 //# sourceMappingURL=NativeBleNitro.nitro.js.map

package/lib/commonjs/specs/NativeBleNitro.nitro.js.map

@@ -1 +1 @@
-{"version":3,"file":"NativeBleNitro.nitro.js","sourceRoot":"","sources":["../../../src/specs/NativeBleNitro.nitro.ts"],"names":[],"mappings":";;;AAKA,+DAA+D;AAC/D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6CAAW,CAAA;IACX,iDAAa,CAAA;IACb,qDAAe,CAAA;IACf,uDAAgB,CAAA;IAChB,mDAAc,CAAA;IACd,iDAAa,CAAA;AACf,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB;AA+BD,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,iEAAc,CAAA;IACd,6DAAY,CAAA;IACZ,6DAAY,CAAA;IACZ,uEAAiB,CAAA;AACnB,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B"}
+{"version":3,"file":"NativeBleNitro.nitro.js","sourceRoot":"","sources":["../../../src/specs/NativeBleNitro.nitro.ts"],"names":[],"mappings":";;;AAKA,+DAA+D;AAC/D,IAAY,QAOX;AAPD,WAAY,QAAQ;IAClB,6CAAW,CAAA;IACX,iDAAa,CAAA;IACb,qDAAe,CAAA;IACf,uDAAgB,CAAA;IAChB,mDAAc,CAAA;IACd,iDAAa,CAAA;AACf,CAAC,EAPW,QAAQ,wBAAR,QAAQ,QAOnB;AA+BD,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,iEAAc,CAAA;IACd,6DAAY,CAAA;IACZ,6DAAY,CAAA;IACZ,uEAAiB,CAAA;AACnB,CAAC,EALW,eAAe,+BAAf,eAAe,QAK1B;AAED,IAAY,yBAIX;AAJD,WAAY,yBAAyB;IACnC,iFAAY,CAAA;IACZ,yEAAQ,CAAA;IACR,iFAAY,CAAA;AACd,CAAC,EAJW,yBAAyB,yCAAzB,yBAAyB,QAIpC"}

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-export { type ByteArray, type ScanFilter, type BLEDevice, type ScanCallback, type ManufacturerDataEntry, type ManufacturerData, type ServiceDataEntry, type ServiceData, type ConnectionCallback, type DisconnectEventCallback, type OperationCallback, type CharacteristicUpdateCallback, type Subscription, type AsyncSubscription, type BleNitroManagerOptions, BLEState, AndroidScanMode, BleNitroManager, BleTimeoutError, } from "./manager";
+export { type ByteArray, type ScanFilter, type BLEDevice, type ScanCallback, type ManufacturerDataEntry, type ManufacturerData, type ServiceDataEntry, type ServiceData, type ConnectionCallback, type DisconnectEventCallback, type OperationCallback, type CharacteristicUpdateCallback, type Subscription, type AsyncSubscription, type BleNitroManagerOptions, BLEState, AndroidScanMode, AndroidConnectionPriority, BleNitroManager, BleTimeoutError, } from "./manager";
 export { BleNitro } from './singleton';

package/lib/index.js

@@ -1,2 +1,2 @@
-export { BLEState, AndroidScanMode, BleNitroManager, BleTimeoutError, } from "./manager";
+export { BLEState, AndroidScanMode, AndroidConnectionPriority, BleNitroManager, BleTimeoutError, } from "./manager";
 export { BleNitro } from './singleton';

package/lib/manager.d.ts

@@ -1,4 +1,4 @@
-import { BLEDevice as NativeBLEDevice, BLEState as NativeBLEState, AndroidScanMode as NativeAndroidScanMode } from './specs/NativeBleNitro';
+import { BLEDevice as NativeBLEDevice, BLEState as NativeBLEState, AndroidScanMode as NativeAndroidScanMode, AndroidConnectionPriority as NativeAndroidConnectionPriority } from './specs/NativeBleNitro';
 export declare class BleTimeoutError extends Error {
     constructor(operation: string, ms: number);
 }
@@ -59,12 +59,18 @@ export declare enum AndroidScanMode {
     LowPower = "LowPower",
     Opportunistic = "Opportunistic"
 }
+export declare enum AndroidConnectionPriority {
+    Balanced = "Balanced",
+    High = "High",
+    LowPower = "LowPower"
+}
 export type BleNitroManagerOptions = {
     restoreIdentifier?: string;
     onRestoredState?: RestoreStateCallback;
 };
 export declare function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState;
 export declare function mapAndroidScanModeToNativeAndroidScanMode(scanMode: AndroidScanMode): NativeAndroidScanMode;
+export declare function mapAndroidConnectionPriorityToNativeAndroidConnectionPriority(priority: AndroidConnectionPriority): NativeAndroidConnectionPriority;
 export declare function convertNativeBleDeviceToBleDevice(nativeBleDevice: NativeBLEDevice): BLEDevice;
 export declare function arrayBufferToByteArray(buffer: ArrayBuffer): ByteArray;
 export declare function byteArrayToArrayBuffer(data: ByteArray): ArrayBuffer;
@@ -158,6 +164,15 @@ 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;
+    /**
+     * Request an Android connection priority for an active connection.
+     * @param deviceId ID of the device
+     * @param priority Desired Android connection priority
+     * @returns On Android: true if the request was successfully initiated (the
+     *   priority change itself is applied asynchronously); on iOS, an error, or a
+     *   disconnected device: false
+     */
+    requestConnectionPriority(deviceId: string, priority: AndroidConnectionPriority): boolean;
     /**
      * Read RSSI for a connected device
      * @param deviceId ID of the device

package/lib/manager.js

@@ -1,5 +1,5 @@
 import BleNitroNativeFactory from './specs/NativeBleNitroFactory';
-import { AndroidScanMode as NativeAndroidScanMode, } from './specs/NativeBleNitro';
+import { AndroidScanMode as NativeAndroidScanMode, AndroidConnectionPriority as NativeAndroidConnectionPriority, } from './specs/NativeBleNitro';
 export class BleTimeoutError extends Error {
     constructor(operation, ms) {
         super(`${operation} timed out after ${ms}ms`);
@@ -30,6 +30,12 @@ export var AndroidScanMode;
     AndroidScanMode["LowPower"] = "LowPower";
     AndroidScanMode["Opportunistic"] = "Opportunistic";
 })(AndroidScanMode || (AndroidScanMode = {}));
+export var AndroidConnectionPriority;
+(function (AndroidConnectionPriority) {
+    AndroidConnectionPriority["Balanced"] = "Balanced";
+    AndroidConnectionPriority["High"] = "High";
+    AndroidConnectionPriority["LowPower"] = "LowPower";
+})(AndroidConnectionPriority || (AndroidConnectionPriority = {}));
 export function mapNativeBLEStateToBLEState(nativeState) {
     const map = {
         0: BLEState.Unknown,
@@ -50,6 +56,14 @@ export function mapAndroidScanModeToNativeAndroidScanMode(scanMode) {
     };
     return map[scanMode];
 }
+export function mapAndroidConnectionPriorityToNativeAndroidConnectionPriority(priority) {
+    const map = {
+        Balanced: NativeAndroidConnectionPriority.Balanced,
+        High: NativeAndroidConnectionPriority.High,
+        LowPower: NativeAndroidConnectionPriority.LowPower,
+    };
+    return map[priority];
+}
 export function convertNativeBleDeviceToBleDevice(nativeBleDevice) {
     return {
         ...nativeBleDevice,
@@ -297,6 +311,17 @@ export class BleNitroManager {
         const deviceMtu = this.Instance.requestMTU(deviceId, mtu);
         return deviceMtu;
     }
+    /**
+     * Request an Android connection priority for an active connection.
+     * @param deviceId ID of the device
+     * @param priority Desired Android connection priority
+     * @returns On Android: true if the request was successfully initiated (the
+     *   priority change itself is applied asynchronously); on iOS, an error, or a
+     *   disconnected device: false
+     */
+    requestConnectionPriority(deviceId, priority) {
+        return this.Instance.requestConnectionPriority(deviceId, mapAndroidConnectionPriorityToNativeAndroidConnectionPriority(priority));
+    }
     /**
      * Read RSSI for a connected device
      * @param deviceId ID of the device

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

@@ -38,6 +38,11 @@ export declare enum AndroidScanMode {
     LowPower = 2,
     Opportunistic = 3
 }
+export declare enum AndroidConnectionPriority {
+    Balanced = 0,
+    High = 1,
+    LowPower = 2
+}
 export interface ScanFilter {
     serviceUUIDs: string[];
     rssiThreshold: number;
@@ -80,6 +85,7 @@ export interface NativeBleNitro extends HybridObject<{
     disconnect(deviceId: string, callback: OperationCallback): void;
     isConnected(deviceId: string): boolean;
     requestMTU(deviceId: string, mtu: number): number;
+    requestConnectionPriority(deviceId: string, androidConnectionPriority: AndroidConnectionPriority): boolean;
     readRSSI(deviceId: string, callback: ReadRSSICallback): void;
     discoverServices(deviceId: string, callback: OperationCallback): void;
     /** Discover services and wait for all characteristic discovery to complete before resolving. */

package/lib/specs/NativeBleNitro.nitro.js

@@ -15,3 +15,9 @@ export var AndroidScanMode;
     AndroidScanMode[AndroidScanMode["LowPower"] = 2] = "LowPower";
     AndroidScanMode[AndroidScanMode["Opportunistic"] = 3] = "Opportunistic";
 })(AndroidScanMode || (AndroidScanMode = {}));
+export var AndroidConnectionPriority;
+(function (AndroidConnectionPriority) {
+    AndroidConnectionPriority[AndroidConnectionPriority["Balanced"] = 0] = "Balanced";
+    AndroidConnectionPriority[AndroidConnectionPriority["High"] = 1] = "High";
+    AndroidConnectionPriority[AndroidConnectionPriority["LowPower"] = 2] = "LowPower";
+})(AndroidConnectionPriority || (AndroidConnectionPriority = {}));

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

@@ -0,0 +1,61 @@
+///
+/// JAndroidConnectionPriority.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AndroidConnectionPriority.hpp"
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidConnectionPriority" and the the Kotlin enum "AndroidConnectionPriority".
+   */
+  struct JAndroidConnectionPriority final: public jni::JavaClass<JAndroidConnectionPriority> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/AndroidConnectionPriority;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidConnectionPriority.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidConnectionPriority toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidConnectionPriority>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidConnectionPriority> fromCpp(AndroidConnectionPriority value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidConnectionPriority::BALANCED:
+          static const auto fieldBALANCED = clazz->getStaticField<JAndroidConnectionPriority>("BALANCED");
+          return clazz->getStaticFieldValue(fieldBALANCED);
+        case AndroidConnectionPriority::HIGH:
+          static const auto fieldHIGH = clazz->getStaticField<JAndroidConnectionPriority>("HIGH");
+          return clazz->getStaticFieldValue(fieldHIGH);
+        case AndroidConnectionPriority::LOWPOWER:
+          static const auto fieldLOWPOWER = clazz->getStaticField<JAndroidConnectionPriority>("LOWPOWER");
+          return clazz->getStaticFieldValue(fieldLOWPOWER);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -25,6 +25,8 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `AndroidScanMode` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
+// Forward declaration of `AndroidConnectionPriority` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidConnectionPriority; }
 
 #include <string>
 #include <optional>
@@ -64,6 +66,8 @@ 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 "AndroidConnectionPriority.hpp"
+#include "JAndroidConnectionPriority.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"
@@ -173,6 +177,11 @@ namespace margelo::nitro::co::zyke::ble {
     auto __result = method(_javaPart, jni::make_jstring(deviceId), mtu);
     return __result;
   }
+  bool JHybridNativeBleNitroSpec::requestConnectionPriority(const std::string& deviceId, AndroidConnectionPriority androidConnectionPriority) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* deviceId */, jni::alias_ref<JAndroidConnectionPriority> /* androidConnectionPriority */)>("requestConnectionPriority");
+    auto __result = method(_javaPart, jni::make_jstring(deviceId), JAndroidConnectionPriority::fromCpp(androidConnectionPriority));
+    return static_cast<bool>(__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 = _javaPart->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));

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

@@ -65,6 +65,7 @@ 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;
+    bool requestConnectionPriority(const std::string& deviceId, AndroidConnectionPriority androidConnectionPriority) 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;
     void discoverServicesWithCharacteristics(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) override;

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

@@ -0,0 +1,24 @@
+///
+/// AndroidConnectionPriority.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.co.zyke.ble
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AndroidConnectionPriority".
+ */
+@DoNotStrip
+@Keep
+enum class AndroidConnectionPriority(@DoNotStrip @Keep val value: Int) {
+  BALANCED(0),
+  HIGH(1),
+  LOWPOWER(2);
+
+  companion object
+}

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

@@ -95,6 +95,10 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   @Keep
   abstract fun requestMTU(deviceId: String, mtu: Double): Double
   
+  @DoNotStrip
+  @Keep
+  abstract fun requestConnectionPriority(deviceId: String, androidConnectionPriority: AndroidConnectionPriority): Boolean
+  
   abstract fun readRSSI(deviceId: String, callback: (success: Boolean, rssi: Double, error: String) -> Unit): Unit
   
   @DoNotStrip

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AndroidConnectionPriority` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidConnectionPriority; }
 // Forward declaration of `AndroidScanMode` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 // Forward declaration of `BLEDevice` to properly resolve imports.
@@ -32,6 +34,7 @@ namespace margelo::nitro::co::zyke::ble { struct ServiceDataEntry; }
 namespace margelo::nitro::co::zyke::ble { struct ServiceData; }
 
 // Include C++ defined types
+#include "AndroidConnectionPriority.hpp"
 #include "AndroidScanMode.hpp"
 #include "BLEDevice.hpp"
 #include "BLEState.hpp"

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

@@ -28,6 +28,8 @@ namespace margelo::nitro::co::zyke::ble { struct ServiceDataEntry; }
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `AndroidScanMode` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
+// Forward declaration of `AndroidConnectionPriority` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidConnectionPriority; }
 // 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.
@@ -48,6 +50,7 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 #include "AndroidScanMode.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
+#include "AndroidConnectionPriority.hpp"
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -178,6 +181,14 @@ namespace margelo::nitro::co::zyke::ble {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool requestConnectionPriority(const std::string& deviceId, AndroidConnectionPriority androidConnectionPriority) override {
+      auto __result = _swiftPart.requestConnectionPriority(deviceId, static_cast<int>(androidConnectionPriority));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      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]] {

package/nitrogen/generated/ios/swift/AndroidConnectionPriority.swift

@@ -0,0 +1,44 @@
+///
+/// AndroidConnectionPriority.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS enum `AndroidConnectionPriority`, backed by a C++ enum.
+ */
+public typealias AndroidConnectionPriority = margelo.nitro.co.zyke.ble.AndroidConnectionPriority
+
+public extension AndroidConnectionPriority {
+  /**
+   * Get a AndroidConnectionPriority for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "Balanced":
+        self = .balanced
+      case "High":
+        self = .high
+      case "LowPower":
+        self = .lowpower
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this AndroidConnectionPriority represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .balanced:
+        return "Balanced"
+      case .high:
+        return "High"
+      case .lowpower:
+        return "LowPower"
+    }
+  }
+}

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

@@ -23,6 +23,7 @@ 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 requestConnectionPriority(deviceId: String, androidConnectionPriority: AndroidConnectionPriority) throws -> Bool
   func readRSSI(deviceId: String, callback: @escaping (_ success: Bool, _ rssi: Double, _ error: String) -> Void) throws -> Void
   func discoverServices(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
   func discoverServicesWithCharacteristics(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void

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

@@ -338,6 +338,18 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func requestConnectionPriority(deviceId: std.string, androidConnectionPriority: Int32) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.requestConnectionPriority(deviceId: String(deviceId), androidConnectionPriority: margelo.nitro.co.zyke.ble.AndroidConnectionPriority(rawValue: androidConnectionPriority)!)
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func readRSSI(deviceId: std.string, callback: bridge.Func_void_bool_double_std__string) -> bridge.Result_void_ {
     do {

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

@@ -0,0 +1,63 @@
+///
+/// AndroidConnectionPriority.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 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 (AndroidConnectionPriority).
+   */
+  enum class AndroidConnectionPriority {
+    BALANCED      SWIFT_NAME(balanced) = 0,
+    HIGH      SWIFT_NAME(high) = 1,
+    LOWPOWER      SWIFT_NAME(lowpower) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::co::zyke::ble
+
+namespace margelo::nitro {
+
+  // C++ AndroidConnectionPriority <> JS AndroidConnectionPriority (enum)
+  template <>
+  struct JSIConverter<margelo::nitro::co::zyke::ble::AndroidConnectionPriority> final {
+    static inline margelo::nitro::co::zyke::ble::AndroidConnectionPriority fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
+      return static_cast<margelo::nitro::co::zyke::ble::AndroidConnectionPriority>(enumValue);
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::co::zyke::ble::AndroidConnectionPriority 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 <= 2;
+    }
+  };
+
+} // namespace margelo::nitro

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

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

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

@@ -17,6 +17,8 @@
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `ScanFilter` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
+// Forward declaration of `AndroidConnectionPriority` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { enum class AndroidConnectionPriority; }
 // 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.
@@ -30,6 +32,7 @@ namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 #include "ScanFilter.hpp"
 #include <NitroModules/Null.hpp>
 #include <variant>
+#include "AndroidConnectionPriority.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
@@ -77,6 +80,7 @@ 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 bool requestConnectionPriority(const std::string& deviceId, AndroidConnectionPriority androidConnectionPriority) = 0;
       virtual void readRSSI(const std::string& deviceId, const std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>& callback) = 0;
       virtual void discoverServices(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual void discoverServicesWithCharacteristics(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.14.0",
+  "version": "1.15.1",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -119,5 +119,8 @@
       "ios",
       "android"
     ]
+  },
+  "allowScripts": {
+    "fsevents@2.3.3": true
   }
 }

package/src/__tests__/index.test.ts

@@ -8,6 +8,7 @@ const mockNativeInstance = {
   disconnect: jest.fn(),
   isConnected: jest.fn(),
   requestMTU: jest.fn(),
+  requestConnectionPriority: jest.fn(),
   readRSSI: jest.fn(),
   discoverServices: jest.fn(),
   discoverServicesWithCharacteristics: jest.fn(),
@@ -44,6 +45,11 @@ jest.mock('../specs/NativeBleNitro', () => ({
     LowPower: 2,
     Opportunistic: 3
   },
+  AndroidConnectionPriority: {
+    Balanced: 0,
+    High: 1,
+    LowPower: 2,
+  },
 }));
 
 jest.mock('../specs/NativeBleNitroFactory', () => ({
@@ -53,7 +59,7 @@ jest.mock('../specs/NativeBleNitroFactory', () => ({
   },
 }));
 
-import { BleNitro } from '../index';
+import { AndroidConnectionPriority, BleNitro } from '../index';
 
 // Get reference to the mocked module
 const mockNative = mockNativeInstance;
@@ -151,6 +157,30 @@ describe('BleNitro', () => {
     expect(result).toBe(deviceId);
   });
 
+  test('connect keeps positional autoConnectAndroid compatibility', async () => {
+    const deviceId = 'test-device-autoconnect';
+    mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void) => {
+      callback(true, id, '');
+    });
+
+    const result = await BleManager.connect(deviceId, undefined, true);
+
+    expect(mockNative.connect).toHaveBeenCalledWith(deviceId, expect.any(Function), undefined, true);
+    expect(result).toBe(deviceId);
+  });
+
+  test('requestConnectionPriority delegates to native with mapped priority', () => {
+    mockNative.requestConnectionPriority.mockReturnValueOnce(true);
+
+    const result = BleManager.requestConnectionPriority(
+      'test-device-priority',
+      AndroidConnectionPriority.High
+    );
+
+    expect(mockNative.requestConnectionPriority).toHaveBeenCalledWith('test-device-priority', 1);
+    expect(result).toBe(true);
+  });
+
   test('connect rejects on error', async () => {
     mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, _disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(false, '', 'Connection failed');
@@ -520,4 +550,4 @@ describe('BleNitro', () => {
       expect.any(Function)
     );
   });
-});
+});

package/src/index.ts

@@ -16,6 +16,7 @@ export {
   type BleNitroManagerOptions,
   BLEState,
   AndroidScanMode,
+  AndroidConnectionPriority,
   BleNitroManager,
   BleTimeoutError,
 } from "./manager";