react-native-ble-nitro 1.0.0 → 1.2.0

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

@@ -15,24 +15,24 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
 
   // Methods
   func startScan(filter: ScanFilter, callback: @escaping (_ device: BLEDevice) -> Void) throws -> Void
-  func stopScan(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func isScanning(callback: @escaping (_ result: Bool) -> Void) throws -> Void
-  func getConnectedDevices(callback: @escaping (_ devices: [BLEDevice]) -> Void) throws -> Void
+  func stopScan() throws -> Bool
+  func isScanning() throws -> Bool
+  func getConnectedDevices(services: [String]) throws -> [BLEDevice]
   func connect(deviceId: String, callback: @escaping (_ success: Bool, _ deviceId: String, _ error: String) -> Void, disconnectCallback: ((_ deviceId: String, _ interrupted: Bool, _ error: String) -> Void)?) throws -> Void
   func disconnect(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func isConnected(deviceId: String, callback: @escaping (_ result: Bool) -> Void) throws -> Void
+  func isConnected(deviceId: String) throws -> Bool
+  func requestMTU(deviceId: String, mtu: Double) throws -> Double
   func discoverServices(deviceId: String, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func getServices(deviceId: String, callback: @escaping (_ result: [String]) -> Void) throws -> Void
-  func getCharacteristics(deviceId: String, serviceId: String, callback: @escaping (_ result: [String]) -> Void) throws -> Void
-  func readCharacteristic(deviceId: String, serviceId: String, characteristicId: String, callback: @escaping (_ success: Bool, _ data: [Double], _ error: String) -> Void) throws -> Void
-  func writeCharacteristic(deviceId: String, serviceId: String, characteristicId: String, data: [Double], withResponse: Bool, callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func subscribeToCharacteristic(deviceId: String, serviceId: String, characteristicId: String, updateCallback: @escaping (_ characteristicId: String, _ data: [Double]) -> Void, resultCallback: @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 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 isBluetoothEnabled(callback: @escaping (_ result: Bool) -> Void) throws -> Void
   func requestBluetoothEnable(callback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func state(callback: @escaping (_ state: BLEState) -> Void) throws -> Void
-  func subscribeToStateChange(stateCallback: @escaping (_ state: BLEState) -> Void, resultCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
-  func unsubscribeFromStateChange(resultCallback: @escaping (_ success: Bool, _ error: String) -> Void) throws -> Void
+  func state() throws -> BLEState
+  func subscribeToStateChange(stateCallback: @escaping (_ state: BLEState) -> Void) throws -> OperationResult
+  func unsubscribeFromStateChange() throws -> OperationResult
   func openSettings() throws -> Promise<Void>
 }
 

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

@@ -126,56 +126,44 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func stopScan(callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func stopScan() -> bridge.Result_bool_ {
     do {
-      try self.__implementation.stopScan(callback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(callback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.stopScan()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func isScanning(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
+  public final func isScanning() -> bridge.Result_bool_ {
     do {
-      try self.__implementation.isScanning(callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.isScanning()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getConnectedDevices(callback: bridge.Func_void_std__vector_BLEDevice_) -> bridge.Result_void_ {
+  public final func getConnectedDevices(services: bridge.std__vector_std__string_) -> bridge.Result_std__vector_BLEDevice__ {
     do {
-      try self.__implementation.getConnectedDevices(callback: { () -> ([BLEDevice]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_BLEDevice_(callback)
-        return { (__devices: [BLEDevice]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_BLEDevice_ in
-            var __vector = bridge.create_std__vector_BLEDevice_(__devices.count)
-            for __item in __devices {
-              __vector.push_back(__item)
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getConnectedDevices(services: services.map({ __item in String(__item) }))
+      let __resultCpp = { () -> bridge.std__vector_BLEDevice_ in
+        var __vector = bridge.create_std__vector_BLEDevice_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_BLEDevice__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_BLEDevice__(__exceptionPtr)
     }
   }
   
@@ -223,18 +211,26 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func isConnected(deviceId: std.string, callback: bridge.Func_void_bool) -> bridge.Result_void_ {
+  public final func isConnected(deviceId: std.string) -> bridge.Result_bool_ {
     do {
-      try self.__implementation.isConnected(deviceId: String(deviceId), callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.isConnected(deviceId: String(deviceId))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @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)
     }
   }
   
@@ -255,62 +251,48 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func getServices(deviceId: std.string, callback: bridge.Func_void_std__vector_std__string_) -> bridge.Result_void_ {
+  public final func getServices(deviceId: std.string) -> bridge.Result_std__vector_std__string__ {
     do {
-      try self.__implementation.getServices(deviceId: String(deviceId), callback: { () -> ([String]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_std__string_(callback)
-        return { (__result: [String]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_std__string_ in
-            var __vector = bridge.create_std__vector_std__string_(__result.count)
-            for __item in __result {
-              __vector.push_back(std.string(__item))
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getServices(deviceId: String(deviceId))
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(__result.count)
+        for __item in __result {
+          __vector.push_back(std.string(__item))
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func getCharacteristics(deviceId: std.string, serviceId: std.string, callback: bridge.Func_void_std__vector_std__string_) -> bridge.Result_void_ {
+  public final func getCharacteristics(deviceId: std.string, serviceId: std.string) -> bridge.Result_std__vector_std__string__ {
     do {
-      try self.__implementation.getCharacteristics(deviceId: String(deviceId), serviceId: String(serviceId), callback: { () -> ([String]) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_std__vector_std__string_(callback)
-        return { (__result: [String]) -> Void in
-          __wrappedFunction.call({ () -> bridge.std__vector_std__string_ in
-            var __vector = bridge.create_std__vector_std__string_(__result.count)
-            for __item in __result {
-              __vector.push_back(std.string(__item))
-            }
-            return __vector
-          }())
+      let __result = try self.__implementation.getCharacteristics(deviceId: String(deviceId), serviceId: String(serviceId))
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
+        var __vector = bridge.create_std__vector_std__string_(__result.count)
+        for __item in __result {
+          __vector.push_back(std.string(__item))
         }
-      }())
-      return bridge.create_Result_void_()
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
     }
   }
   
   @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_()
@@ -321,9 +303,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))
@@ -337,18 +319,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)
@@ -379,22 +355,6 @@ open class HybridNativeBleNitroSpec_cxx {
     }
   }
   
-  @inline(__always)
-  public final func isBluetoothEnabled(callback: bridge.Func_void_bool) -> bridge.Result_void_ {
-    do {
-      try self.__implementation.isBluetoothEnabled(callback: { () -> (Bool) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool(callback)
-        return { (__result: Bool) -> Void in
-          __wrappedFunction.call(__result)
-        }
-      }())
-      return bridge.create_Result_void_()
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
-    }
-  }
-  
   @inline(__always)
   public final func requestBluetoothEnable(callback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
     do {
@@ -412,55 +372,43 @@ open class HybridNativeBleNitroSpec_cxx {
   }
   
   @inline(__always)
-  public final func state(callback: bridge.Func_void_BLEState) -> bridge.Result_void_ {
+  public final func state() -> bridge.Result_BLEState_ {
     do {
-      try self.__implementation.state(callback: { () -> (BLEState) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_BLEState(callback)
-        return { (__state: BLEState) -> Void in
-          __wrappedFunction.call(__state.rawValue)
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.state()
+      let __resultCpp = __result
+      return bridge.create_Result_BLEState_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_BLEState_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func subscribeToStateChange(stateCallback: bridge.Func_void_BLEState, resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func subscribeToStateChange(stateCallback: bridge.Func_void_BLEState) -> bridge.Result_OperationResult_ {
     do {
-      try self.__implementation.subscribeToStateChange(stateCallback: { () -> (BLEState) -> Void in
+      let __result = try self.__implementation.subscribeToStateChange(stateCallback: { () -> (BLEState) -> Void in
         let __wrappedFunction = bridge.wrap_Func_void_BLEState(stateCallback)
         return { (__state: BLEState) -> Void in
           __wrappedFunction.call(__state.rawValue)
         }
-      }(), resultCallback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(resultCallback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
       }())
-      return bridge.create_Result_void_()
+      let __resultCpp = __result
+      return bridge.create_Result_OperationResult_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_OperationResult_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public final func unsubscribeFromStateChange(resultCallback: bridge.Func_void_bool_std__string) -> bridge.Result_void_ {
+  public final func unsubscribeFromStateChange() -> bridge.Result_OperationResult_ {
     do {
-      try self.__implementation.unsubscribeFromStateChange(resultCallback: { () -> (Bool, String) -> Void in
-        let __wrappedFunction = bridge.wrap_Func_void_bool_std__string(resultCallback)
-        return { (__success: Bool, __error: String) -> Void in
-          __wrappedFunction.call(__success, std.string(__error))
-        }
-      }())
-      return bridge.create_Result_void_()
+      let __result = try self.__implementation.unsubscribeFromStateChange()
+      let __resultCpp = __result
+      return bridge.create_Result_OperationResult_(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
+      return bridge.create_Result_OperationResult_(__exceptionPtr)
     }
   }
   

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/OperationResult.swift

@@ -0,0 +1,64 @@
+///
+/// OperationResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `OperationResult`, backed by a C++ struct.
+ */
+public typealias OperationResult = margelo.nitro.co.zyke.ble.OperationResult
+
+public extension OperationResult {
+  private typealias bridge = margelo.nitro.co.zyke.ble.bridge.swift
+
+  /**
+   * Create a new instance of `OperationResult`.
+   */
+  init(success: Bool, error: String?) {
+    self.init(success, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = error {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var success: Bool {
+    @inline(__always)
+    get {
+      return self.__success
+    }
+    @inline(__always)
+    set {
+      self.__success = newValue
+    }
+  }
+  
+  var error: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if let __unwrapped = self.__error.value {
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__error = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

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);
@@ -28,7 +29,6 @@ namespace margelo::nitro::co::zyke::ble {
       prototype.registerHybridMethod("writeCharacteristic", &HybridNativeBleNitroSpec::writeCharacteristic);
       prototype.registerHybridMethod("subscribeToCharacteristic", &HybridNativeBleNitroSpec::subscribeToCharacteristic);
       prototype.registerHybridMethod("unsubscribeFromCharacteristic", &HybridNativeBleNitroSpec::unsubscribeFromCharacteristic);
-      prototype.registerHybridMethod("isBluetoothEnabled", &HybridNativeBleNitroSpec::isBluetoothEnabled);
       prototype.registerHybridMethod("requestBluetoothEnable", &HybridNativeBleNitroSpec::requestBluetoothEnable);
       prototype.registerHybridMethod("state", &HybridNativeBleNitroSpec::state);
       prototype.registerHybridMethod("subscribeToStateChange", &HybridNativeBleNitroSpec::subscribeToStateChange);

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

@@ -17,16 +17,22 @@
 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.
+namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
 #include "ScanFilter.hpp"
 #include "BLEDevice.hpp"
 #include <functional>
-#include <string>
 #include <vector>
+#include <string>
 #include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
+#include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
@@ -61,24 +67,24 @@ 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 stopScan(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void isScanning(const std::function<void(bool /* result */)>& callback) = 0;
-      virtual void getConnectedDevices(const std::function<void(const std::vector<BLEDevice>& /* devices */)>& 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 void isConnected(const std::string& deviceId, const std::function<void(bool /* result */)>& 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 void getServices(const std::string& deviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) = 0;
-      virtual void getCharacteristics(const std::string& deviceId, const std::string& serviceId, const std::function<void(const std::vector<std::string>& /* result */)>& callback) = 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 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 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 isBluetoothEnabled(const std::function<void(bool /* result */)>& callback) = 0;
       virtual void requestBluetoothEnable(const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
-      virtual void state(const std::function<void(BLEState /* state */)>& callback) = 0;
-      virtual void subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback, const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
-      virtual void unsubscribeFromStateChange(const std::function<void(bool /* success */, const std::string& /* error */)>& resultCallback) = 0;
+      virtual BLEState state() = 0;
+      virtual OperationResult subscribeToStateChange(const std::function<void(BLEState /* state */)>& stateCallback) = 0;
+      virtual OperationResult unsubscribeFromStateChange() = 0;
       virtual std::shared_ptr<Promise<void>> openSettings() = 0;
 
     protected:

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;
     }
   };