react-native-ble-nitro 1.6.0 → 1.7.1

package/nitrogen/generated/android/BleNitro+autolinking.cmake

@@ -13,6 +13,12 @@
 # include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/BleNitro+autolinking.cmake)
 # ```
 
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_BLENITRO_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
 # Add all headers that were generated by Nitrogen
 include_directories(
   "../nitrogen/generated/shared/c++"
@@ -28,16 +34,15 @@ target_sources(
   ../nitrogen/generated/android/BleNitroOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeBleNitroFactorySpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeBleNitroFactorySpec.cpp
 )
 
-# Define a flag to check if we are building properly
-add_definitions(-DBUILDING_BLENITRO_WITH_GENERATED_CMAKE_PROJECT)
-
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
 # Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
- target_compile_definitions(
+target_compile_definitions(
   BleNitro PRIVATE
   -DFOLLY_NO_CONFIG=1
   -DFOLLY_HAVE_CLOCK_GETTIME=1

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -25,6 +25,7 @@
 #include "JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string.hpp"
 #include "JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JFunc_void_BLEState.hpp"
+#include "JHybridNativeBleNitroFactorySpec.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
@@ -46,6 +47,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JHybridNativeBleNitroFactorySpec::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
@@ -53,8 +55,15 @@ int initialize(JavaVM* vm) {
       []() -> std::shared_ptr<HybridObject> {
         static DefaultConstructableObject<JHybridNativeBleNitroSpec::javaobject> object("com/margelo/nitro/co/zyke/ble/BleNitroBleManager");
         auto instance = object.create();
-        auto globalRef = jni::make_global(instance);
-        return globalRef->cthis()->shared();
+        return instance->cthis()->shared();
+      }
+    );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "NativeBleNitroFactory",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridNativeBleNitroFactorySpec::javaobject> object("com/margelo/nitro/co/zyke/ble/BleNitroBleManagerFactory");
+        auto instance = object.create();
+        return instance->cthis()->shared();
       }
     );
   });

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

@@ -51,6 +51,8 @@ namespace margelo::nitro::co::zyke::ble {
       jni::local_ref<jni::JArrayClass<jni::JString>> serviceUUIDs = this->getFieldValue(fieldServiceUUIDs);
       static const auto fieldIsConnectable = clazz->getField<jboolean>("isConnectable");
       jboolean isConnectable = this->getFieldValue(fieldIsConnectable);
+      static const auto fieldIsConnected = clazz->getField<jboolean>("isConnected");
+      jboolean isConnected = this->getFieldValue(fieldIsConnected);
       return BLEDevice(
         id->toStdString(),
         name->toStdString(),
@@ -66,7 +68,8 @@ namespace margelo::nitro::co::zyke::ble {
           }
           return __vector;
         }(),
-        static_cast<bool>(isConnectable)
+        static_cast<bool>(isConnectable),
+        static_cast<bool>(isConnected)
       );
     }
 
@@ -90,7 +93,8 @@ namespace margelo::nitro::co::zyke::ble {
           }
           return __array;
         }(),
-        value.isConnectable
+        value.isConnectable,
+        value.isConnected
       );
     }
   };

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

@@ -28,7 +28,7 @@ namespace margelo::nitro::co::zyke::ble {
   using namespace facebook;
 
   /**
-   * Represents the Java/Kotlin callback `(restoredPeripherals: Array<BLEDevice>) -> Unit`.
+   * Represents the Java/Kotlin callback `(peripherals: 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_> {
@@ -39,13 +39,13 @@ namespace margelo::nitro::co::zyke::ble {
     /**
      * 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");
+    void invoke(const std::vector<BLEDevice>& peripherals) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JBLEDevice>> /* peripherals */)>("invoke");
       method(self(), [&]() {
-        size_t __size = restoredPeripherals.size();
+        size_t __size = peripherals.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];
+          const auto& __element = peripherals[__i];
           __array->setElement(__i, *JBLEDevice::fromCpp(__element));
         }
         return __array;
@@ -58,7 +58,7 @@ namespace margelo::nitro::co::zyke::ble {
    */
   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) {
+    static jni::local_ref<JFunc_void_std__vector_BLEDevice_::javaobject> fromCpp(const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& func) {
       return JFunc_void_std__vector_BLEDevice__cxx::newObjectCxxArgs(func);
     }
 
@@ -66,13 +66,13 @@ namespace margelo::nitro::co::zyke::ble {
     /**
      * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_BLEDevice__cxx` instance holds.
      */
-    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JBLEDevice>> restoredPeripherals) {
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JBLEDevice>> peripherals) {
       _func([&]() {
-              size_t __size = restoredPeripherals->size();
+              size_t __size = peripherals->size();
               std::vector<BLEDevice> __vector;
               __vector.reserve(__size);
               for (size_t __i = 0; __i < __size; __i++) {
-                auto __element = restoredPeripherals->getElement(__i);
+                auto __element = peripherals->getElement(__i);
                 __vector.push_back(__element->toCpp());
               }
               return __vector;
@@ -81,7 +81,7 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     [[nodiscard]]
-    inline const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& getFunction() const {
+    inline const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& getFunction() const {
       return _func;
     }
 
@@ -92,11 +92,11 @@ namespace margelo::nitro::co::zyke::ble {
     }
 
   private:
-    explicit JFunc_void_std__vector_BLEDevice__cxx(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& func): _func(func) { }
+    explicit JFunc_void_std__vector_BLEDevice__cxx(const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& func): _func(func) { }
 
   private:
     friend HybridBase;
-    std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)> _func;
+    std::function<void(const std::vector<BLEDevice>& /* peripherals */)> _func;
   };
 
 } // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,71 @@
+///
+/// JHybridNativeBleNitroFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNativeBleNitroFactorySpec.hpp"
+
+// Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
+// Forward declaration of `BLEDevice` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
+// Forward declaration of `ManufacturerData` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
+// Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { struct ManufacturerDataEntry; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <memory>
+#include "HybridNativeBleNitroSpec.hpp"
+#include "JHybridNativeBleNitroSpec.hpp"
+#include <string>
+#include <optional>
+#include "BLEDevice.hpp"
+#include <vector>
+#include <functional>
+#include "JFunc_void_std__vector_BLEDevice_.hpp"
+#include "JBLEDevice.hpp"
+#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 {
+
+  jni::local_ref<JHybridNativeBleNitroFactorySpec::jhybriddata> JHybridNativeBleNitroFactorySpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNativeBleNitroFactorySpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNativeBleNitroFactorySpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNativeBleNitroFactorySpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNativeBleNitroFactorySpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridNativeBleNitroSpec> JHybridNativeBleNitroFactorySpec::create(const std::optional<std::string>& nativeRestoreStateIdentifier, const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& restoreStateCallback) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridNativeBleNitroSpec::javaobject>(jni::alias_ref<jni::JString> /* nativeRestoreStateIdentifier */, jni::alias_ref<JFunc_void_std__vector_BLEDevice_::javaobject> /* restoreStateCallback */)>("create_cxx");
+    auto __result = method(_javaPart, nativeRestoreStateIdentifier.has_value() ? jni::make_jstring(nativeRestoreStateIdentifier.value()) : nullptr, restoreStateCallback.has_value() ? JFunc_void_std__vector_BLEDevice__cxx::fromCpp(restoreStateCallback.value()) : nullptr);
+    return __result->cthis()->shared_cast<JHybridNativeBleNitroSpec>();
+  }
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -0,0 +1,64 @@
+///
+/// HybridNativeBleNitroFactorySpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNativeBleNitroFactorySpec.hpp"
+
+
+
+
+namespace margelo::nitro::co::zyke::ble {
+
+  using namespace facebook;
+
+  class JHybridNativeBleNitroFactorySpec: public jni::HybridClass<JHybridNativeBleNitroFactorySpec, JHybridObject>,
+                                          public virtual HybridNativeBleNitroFactorySpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/co/zyke/ble/HybridNativeBleNitroFactorySpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNativeBleNitroFactorySpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNativeBleNitroFactorySpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNativeBleNitroFactorySpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridNativeBleNitroFactorySpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridNativeBleNitroSpec> create(const std::optional<std::string>& nativeRestoreStateIdentifier, const std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>& restoreStateCallback) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNativeBleNitroFactorySpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::co::zyke::ble

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

@@ -24,10 +24,11 @@ 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; }
 
+#include <string>
+#include <optional>
 #include "BLEDevice.hpp"
 #include <vector>
 #include "JBLEDevice.hpp"
-#include <string>
 #include "ManufacturerData.hpp"
 #include "JManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
@@ -39,7 +40,6 @@ namespace margelo::nitro::co::zyke::ble { enum class AndroidScanMode; }
 #include "JBLEState.hpp"
 #include "OperationResult.hpp"
 #include "JOperationResult.hpp"
-#include <optional>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include <functional>
@@ -80,7 +80,15 @@ namespace margelo::nitro::co::zyke::ble {
   }
 
   // Properties
-  
+  std::optional<std::string> JHybridNativeBleNitroSpec::getRestoreStateIdentifier() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getRestoreStateIdentifier");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridNativeBleNitroSpec::setRestoreStateIdentifier(const std::optional<std::string>& restoreStateIdentifier) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* restoreStateIdentifier */)>("setRestoreStateIdentifier");
+    method(_javaPart, restoreStateIdentifier.has_value() ? jni::make_jstring(restoreStateIdentifier.value()) : nullptr);
+  }
 
   // Methods
   void JHybridNativeBleNitroSpec::setRestoreStateCallback(const std::function<void(const std::vector<BLEDevice>& /* restoredPeripherals */)>& callback) {

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

@@ -49,7 +49,8 @@ namespace margelo::nitro::co::zyke::ble {
 
   public:
     // Properties
-    
+    std::optional<std::string> getRestoreStateIdentifier() override;
+    void setRestoreStateIdentifier(const std::optional<std::string>& restoreStateIdentifier) override;
 
   public:
     // Methods

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

@@ -38,7 +38,10 @@ data class BLEDevice
     val serviceUUIDs: Array<String>,
     @DoNotStrip
     @Keep
-    val isConnectable: Boolean
+    val isConnectable: Boolean,
+    @DoNotStrip
+    @Keep
+    val isConnected: Boolean
   ) {
   /* main constructor */
 }

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

@@ -15,7 +15,7 @@ import dalvik.annotation.optimization.FastNative
 
 
 /**
- * Represents the JavaScript callback `(restoredPeripherals: array) => void`.
+ * Represents the JavaScript callback `(peripherals: 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).
  */
@@ -29,11 +29,11 @@ fun interface Func_void_std__vector_BLEDevice_: (Array<BLEDevice>) -> Unit {
    */
   @DoNotStrip
   @Keep
-  override fun invoke(restoredPeripherals: Array<BLEDevice>): Unit
+  override fun invoke(peripherals: Array<BLEDevice>): Unit
 }
 
 /**
- * Represents the JavaScript callback `(restoredPeripherals: array) => void`.
+ * Represents the JavaScript callback `(peripherals: array) => void`.
  * This is implemented in C++, via a `std::function<...>`.
  * The callback might be coming from JS.
  */
@@ -57,15 +57,15 @@ class Func_void_std__vector_BLEDevice__cxx: Func_void_std__vector_BLEDevice_ {
 
   @DoNotStrip
   @Keep
-  override fun invoke(restoredPeripherals: Array<BLEDevice>): Unit
-    = invoke_cxx(restoredPeripherals)
+  override fun invoke(peripherals: Array<BLEDevice>): Unit
+    = invoke_cxx(peripherals)
 
   @FastNative
-  private external fun invoke_cxx(restoredPeripherals: Array<BLEDevice>): Unit
+  private external fun invoke_cxx(peripherals: Array<BLEDevice>): Unit
 }
 
 /**
- * Represents the JavaScript callback `(restoredPeripherals: array) => void`.
+ * Represents the JavaScript callback `(peripherals: array) => void`.
  * This is implemented in Java/Kotlin, via a `(Array<BLEDevice>) -> Unit`.
  * The callback is always coming from native.
  */
@@ -75,7 +75,7 @@ class Func_void_std__vector_BLEDevice__cxx: Func_void_std__vector_BLEDevice_ {
 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)
+  override fun invoke(peripherals: Array<BLEDevice>): Unit {
+    return this.function(peripherals)
   }
 }

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

@@ -0,0 +1,57 @@
+///
+/// HybridNativeBleNitroFactorySpec.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.*
+
+/**
+ * A Kotlin class representing the NativeBleNitroFactory HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NativeBleNitroFactory.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNativeBleNitroFactorySpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  
+
+  // Methods
+  abstract fun create(nativeRestoreStateIdentifier: String?, restoreStateCallback: ((peripherals: Array<BLEDevice>) -> Unit)?): HybridNativeBleNitroSpec
+  
+  @DoNotStrip
+  @Keep
+  private fun create_cxx(nativeRestoreStateIdentifier: String?, restoreStateCallback: Func_void_std__vector_BLEDevice_?): HybridNativeBleNitroSpec {
+    val __result = create(nativeRestoreStateIdentifier, restoreStateCallback?.let { it })
+    return __result
+  }
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "HybridNativeBleNitroFactorySpec"
+  }
+}

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

@@ -37,7 +37,11 @@ abstract class HybridNativeBleNitroSpec: HybridObject() {
   }
 
   // Properties
-  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var restoreStateIdentifier: String?
 
   // Methods
   abstract fun setRestoreStateCallback(callback: (restoredPeripherals: Array<BLEDevice>) -> Unit): Unit

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

@@ -9,12 +9,13 @@
 
 // Include C++ implementation defined types
 #include "BleNitro-Swift-Cxx-Umbrella.hpp"
+#include "HybridNativeBleNitroFactorySpecSwift.hpp"
 #include "HybridNativeBleNitroSpecSwift.hpp"
 
 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) {
+  Func_void_std__vector_BLEDevice_ create_Func_void_std__vector_BLEDevice_(void* NON_NULL swiftClosureWrapper) noexcept {
     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);
@@ -22,7 +23,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // 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) {
+  Func_void_std__optional_BLEDevice__std__optional_std__string_ create_Func_void_std__optional_BLEDevice__std__optional_std__string_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__optional_BLEDevice__std__optional_std__string_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::optional<BLEDevice>& device, const std::optional<std::string>& error) mutable -> void {
       swiftClosure.call(device, error);
@@ -30,7 +31,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>
-  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__string_std__string create_Func_void_bool_std__string_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__string_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& deviceId, const std::string& error) mutable -> void {
       swiftClosure.call(success, deviceId, error);
@@ -38,7 +39,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>
-  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__string_bool_std__string create_Func_void_std__string_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__string_bool_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::string& deviceId, bool interrupted, const std::string& error) mutable -> void {
       swiftClosure.call(deviceId, interrupted, error);
@@ -46,7 +47,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::string& /* error */)>
-  Func_void_bool_std__string create_Func_void_bool_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__string create_Func_void_bool_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::string& error) mutable -> void {
       swiftClosure.call(success, error);
@@ -54,7 +55,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, double /* rssi */, const std::string& /* error */)>
-  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_double_std__string create_Func_void_bool_double_std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_double_std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, double rssi, const std::string& error) mutable -> void {
       swiftClosure.call(success, rssi, error);
@@ -62,7 +63,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(bool /* success */, const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* error */)>
-  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* _Nonnull swiftClosureWrapper) {
+  Func_void_bool_std__shared_ptr_ArrayBuffer__std__string create_Func_void_bool_std__shared_ptr_ArrayBuffer__std__string(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_bool_std__shared_ptr_ArrayBuffer__std__string::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](bool success, const std::shared_ptr<ArrayBuffer>& data, const std::string& error) mutable -> void {
       swiftClosure.call(success, ArrayBufferHolder(data), error);
@@ -70,7 +71,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::string& /* characteristicId */, const std::shared_ptr<ArrayBuffer>& /* data */)>
-  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__string_std__shared_ptr_ArrayBuffer_ create_Func_void_std__string_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__string_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::string& characteristicId, const std::shared_ptr<ArrayBuffer>& data) mutable -> void {
       swiftClosure.call(characteristicId, ArrayBufferHolder(data));
@@ -78,7 +79,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(BLEState /* state */)>
-  Func_void_BLEState create_Func_void_BLEState(void* _Nonnull swiftClosureWrapper) {
+  Func_void_BLEState create_Func_void_BLEState(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_BLEState::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](BLEState state) mutable -> void {
       swiftClosure.call(static_cast<int>(state));
@@ -86,7 +87,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void()>
-  Func_void create_Func_void(void* _Nonnull swiftClosureWrapper) {
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)]() mutable -> void {
       swiftClosure.call();
@@ -94,7 +95,7 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull swiftClosureWrapper) {
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = BleNitro::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
     return [swiftClosure = std::move(swiftClosure)](const std::exception_ptr& error) mutable -> void {
       swiftClosure.call(error);
@@ -102,11 +103,11 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   }
   
   // pragma MARK: std::shared_ptr<HybridNativeBleNitroSpec>
-  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* _Nonnull swiftUnsafePointer) {
+  std::shared_ptr<HybridNativeBleNitroSpec> create_std__shared_ptr_HybridNativeBleNitroSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     BleNitro::HybridNativeBleNitroSpec_cxx swiftPart = BleNitro::HybridNativeBleNitroSpec_cxx::fromUnsafe(swiftUnsafePointer);
     return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(swiftPart);
   }
-  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType) {
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroSpec_(std__shared_ptr_HybridNativeBleNitroSpec_ cppType) {
     std::shared_ptr<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridNativeBleNitroSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
@@ -116,5 +117,21 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     BleNitro::HybridNativeBleNitroSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
+  
+  // pragma MARK: std::shared_ptr<HybridNativeBleNitroFactorySpec>
+  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    BleNitro::HybridNativeBleNitroFactorySpec_cxx swiftPart = BleNitro::HybridNativeBleNitroFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType) {
+    std::shared_ptr<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridNativeBleNitroFactorySpec\" is not implemented in Swift!");
+    }
+    #endif
+    BleNitro::HybridNativeBleNitroFactorySpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
 
 } // namespace margelo::nitro::co::zyke::ble::bridge::swift