react-native-ble-nitro 1.3.0 → 1.4.0

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

@@ -0,0 +1,102 @@
+///
+/// JFunc_void_std__vector_BLEDevice_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "BLEDevice.hpp"
+#include <vector>
+#include <functional>
+#include "JBLEDevice.hpp"
+#include <string>
+#include "ManufacturerData.hpp"
+#include "JManufacturerData.hpp"
+#include "ManufacturerDataEntry.hpp"
+#include "JManufacturerDataEntry.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(restoredPeripherals: Array<BLEDevice>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_BLEDevice_: public jni::JavaClass<JFunc_void_std__vector_BLEDevice_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_BLEDevice_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_BLEDevice_` instance holds through JNI.
+     */
+    void invoke(const std::vector<BLEDevice>& restoredPeripherals) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JBLEDevice>> /* restoredPeripherals */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = restoredPeripherals.size();
+        jni::local_ref<jni::JArrayClass<JBLEDevice>> __array = jni::JArrayClass<JBLEDevice>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = restoredPeripherals[__i];
+          __array->setElement(__i, *JBLEDevice::fromCpp(__element));
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_BLEDevice_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  struct JFunc_void_std__vector_BLEDevice__cxx final: public jni::HybridClass<JFunc_void_std__vector_BLEDevice__cxx, JFunc_void_std__vector_BLEDevice_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_BLEDevice_::javaobject> fromCpp(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& func) {
+      return JFunc_void_std__vector_BLEDevice__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_BLEDevice__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JBLEDevice>> restoredPeripherals) {
+      _func([&]() {
+              size_t __size = restoredPeripherals->size();
+              std::vector<BLEDevice> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = restoredPeripherals->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/Func_void_std__vector_BLEDevice__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_BLEDevice__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_BLEDevice__cxx(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)> _func;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -42,11 +42,12 @@ namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 #include <optional>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
+#include <functional>
+#include "JFunc_void_std__vector_BLEDevice_.hpp"
 #include "ScanFilter.hpp"
 #include "JScanFilter.hpp"
 #include "AndroidScanMode.hpp"
 #include "JAndroidScanMode.hpp"
-#include <functional>
 #include "JFunc_void_std__optional_BLEDevice__std__optional_std__string_.hpp"
 #include "JFunc_void_bool_std__string_std__string.hpp"
 #include "JFunc_void_std__string_bool_std__string.hpp"
@@ -81,6 +82,10 @@ namespace margelo::nitro::co::zyke::ble {
   
 
   // Methods
+  void JHybridNativeBleNitroSpec::setRestoreStateCallback(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_BLEDevice_::javaobject> /* callback */)>("setRestoreStateCallback_cxx");
+    method(_javaPart, JFunc_void_std__vector_BLEDevice__cxx::fromCpp(callback));
+  }
   void JHybridNativeBleNitroSpec::startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JScanFilter> /* filter */, jni::alias_ref<JFunc_void_std__optional_BLEDevice__std__optional_std__string_::javaobject> /* callback */)>("startScan_cxx");
     method(_javaPart, JScanFilter::fromCpp(filter), JFunc_void_std__optional_BLEDevice__std__optional_std__string__cxx::fromCpp(callback));

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

@@ -53,6 +53,7 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Methods
+    void setRestoreStateCallback(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& callback) override;
     void startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) override;
     bool stopScan() override;
     bool isScanning() override;

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

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

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

@@ -40,6 +40,15 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   
 
   // Methods
+  abstract fun setRestoreStateCallback(callback: (restoredPeripherals: Array<BLEDevice>) -> Unit): Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun setRestoreStateCallback_cxx(callback: Func_void_std__vector_BLEDevice_): Unit {
+    val __result = setRestoreStateCallback(callback)
+    return __result
+  }
+  
   abstract fun startScan(filter: ScanFilter, callback: (device: BLEDevice?, error: String?) -> Unit): Unit
   
   @DoNotStrip

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

@@ -13,6 +13,14 @@
 
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
+  // pragma MARK: std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* _Nonnull swiftClosureWrapper) {
+    auto swiftClosure = BleNitro::Func_void_std__vector_BLEDevice_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<BLEDevice>& restoredPeripherals) mutable -> void {
+      swiftClosure.call(restoredPeripherals);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
   Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* _Nonnull swiftClosureWrapper) {
     auto swiftClosure = BleNitro::Func_void_std__optional_BLEDevice__std__optional_std__string_::fromUnsafe(swiftClosureWrapper);

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

@@ -54,6 +54,17 @@ namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
  */
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
+  // pragma MARK: std::vector<ManufacturerDataEntry>
+  /**
+   * Specialized version of `std::vector<ManufacturerDataEntry>`.
+   */
+  using std__vector_ManufacturerDataEntry_ = std::vector<ManufacturerDataEntry>;
+  inline std::vector<ManufacturerDataEntry> create_std__vector_ManufacturerDataEntry_(size_t size) {
+    std::vector<ManufacturerDataEntry> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::vector<std::string>
   /**
    * Specialized version of `std::vector<std::string>`.
@@ -65,17 +76,39 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::vector<ManufacturerDataEntry>
+  // pragma MARK: std::vector<BLEDevice>
   /**
-   * Specialized version of `std::vector<ManufacturerDataEntry>`.
+   * Specialized version of `std::vector<BLEDevice>`.
    */
-  using std__vector_ManufacturerDataEntry_ = std::vector<ManufacturerDataEntry>;
-  inline std::vector<ManufacturerDataEntry> create_std__vector_ManufacturerDataEntry_(size_t size) {
-    std::vector<ManufacturerDataEntry> vector;
+  using std__vector_BLEDevice_ = std::vector<BLEDevice>;
+  inline std::vector<BLEDevice> create_std__vector_BLEDevice_(size_t size) {
+    std::vector<BLEDevice> vector;
     vector.reserve(size);
     return vector;
   }
   
+  // pragma MARK: std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<BLEDevice>&)>`.
+   */
+  using Func_void_std__vector_BLEDevice_ = std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<BLEDevice>& / * restoredPeripherals * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_BLEDevice__Wrapper final {
+  public:
+    explicit Func_void_std__vector_BLEDevice__Wrapper(std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>&& func): _function(std::make_unique<std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>>(std::move(func))) {}
+    inline void call(std::vector<BLEDevice> restoredPeripherals) const {
+      _function->operator()(restoredPeripherals);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* _Nonnull swiftClosureWrapper);
+  inline Func_void_std__vector_BLEDevice__Wrapper wrap_Func_void_std__vector_BLEDevice_(Func_void_std__vector_BLEDevice_ value) {
+    return Func_void_std__vector_BLEDevice__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::optional<BLEDevice>
   /**
    * Specialized version of `std::optional<BLEDevice>`.
@@ -116,17 +149,6 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return Func_void_std__optional_BLEDevice__std__optional_std__string__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::vector<BLEDevice>
-  /**
-   * Specialized version of `std::vector<BLEDevice>`.
-   */
-  using std__vector_BLEDevice_ = std::vector<BLEDevice>;
-  inline std::vector<BLEDevice> create_std__vector_BLEDevice_(size_t size) {
-    std::vector<BLEDevice> vector;
-    vector.reserve(size);
-    return vector;
-  }
-  
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>
   /**
    * Specialized version of `std::function<void(bool, const std::string&, const std::string&)>`.

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

@@ -12,10 +12,6 @@
 // Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
 namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 
-// Forward declaration of `ScanFilter` to properly resolve imports.
-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 `BLEDevice` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `ManufacturerData` to properly resolve imports.
@@ -26,22 +22,26 @@ namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
 namespace NitroModules { class ArrayBuffer; }
 // Forward declaration of `ArrayBufferHolder` to properly resolve imports.
 namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `ScanFilter` to properly resolve imports.
+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 `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 <string>
-#include <vector>
-#include "AndroidScanMode.hpp"
 #include "BLEDevice.hpp"
-#include <optional>
+#include <vector>
 #include <functional>
+#include <string>
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
+#include "ScanFilter.hpp"
+#include "AndroidScanMode.hpp"
+#include <optional>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -87,6 +87,12 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Methods
+    inline void setRestoreStateCallback(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& callback) override {
+      auto __result = _swiftPart.setRestoreStateCallback(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void startScan(const ScanFilter& filter, const std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>& callback) override {
       auto __result = _swiftPart.startScan(filter, callback);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_std__vector_BLEDevice_.swift

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

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

@@ -14,6 +14,7 @@ public protocol HybridNativeBleNitroSpec_protocol: HybridObject {
   
 
   // Methods
+  func setRestoreStateCallback(callback: @escaping (_ restoredPeripherals: [BLEDevice]) -> Void) throws -> Void
   func startScan(filter: ScanFilter, callback: @escaping (_ device: BLEDevice?, _ error: String?) -> Void) throws -> Void
   func stopScan() throws -> Bool
   func isScanning() throws -> Bool

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

@@ -109,6 +109,28 @@ open class HybridNativeBleNitroSpec_cxx {
   
 
   // Methods
+  @inline(__always)
+  public final func setRestoreStateCallback(callback: bridge.Func_void_std__vector_BLEDevice_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setRestoreStateCallback(callback: { () -> ([BLEDevice]) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_BLEDevice_(callback)
+        return { (__restoredPeripherals: [BLEDevice]) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_BLEDevice_ in
+            var __vector = bridge.create_std__vector_BLEDevice_(__restoredPeripherals.count)
+            for __item in __restoredPeripherals {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }())
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func startScan(filter: ScanFilter, callback: bridge.Func_void_std__optional_BLEDevice__std__optional_std__string_) -> bridge.Result_void_ {
     do {

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

@@ -14,6 +14,7 @@ namespace margelo::nitro::co::zyke::ble {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("setRestoreStateCallback", &HybridNativeBleNitroSpec::setRestoreStateCallback);
       prototype.registerHybridMethod("startScan", &HybridNativeBleNitroSpec::startScan);
       prototype.registerHybridMethod("stopScan", &HybridNativeBleNitroSpec::stopScan);
       prototype.registerHybridMethod("isScanning", &HybridNativeBleNitroSpec::isScanning);

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

@@ -13,10 +13,10 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-// Forward declaration of `ScanFilter` to properly resolve imports.
-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 `ScanFilter` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 // Forward declaration of `BLEState` to properly resolve imports.
@@ -24,12 +24,12 @@ 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 <vector>
+#include <functional>
+#include "ScanFilter.hpp"
 #include <optional>
 #include <string>
-#include <functional>
-#include <vector>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
@@ -66,6 +66,7 @@ namespace margelo::nitro::co::zyke::ble {
 
     public:
       // Methods
+      virtual void setRestoreStateCallback(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,6 +15,14 @@
       "types": "./lib/index.d.ts",
       "default": "./src/index.ts"
     },
+    "./manager": {
+      "react-native": "./src/manager.ts",
+      "typescript": "./src/manager.ts",
+      "import": "./lib/manager.js",
+      "require": "./lib/commonjs/manager.js",
+      "types": "./lib/manager.d.ts",
+      "default": "./src/manager.ts"
+    },
     "./plugin": {
       "import": "./plugin/build/index.js",
       "require": "./plugin/build/index.js",