react-native-ble-nitro 1.6.0 → 1.7.0

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(
@@ -57,6 +59,15 @@ int initialize(JavaVM* vm) {
         return globalRef->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();
+        auto globalRef = jni::make_global(instance);
+        return globalRef->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,6 +9,7 @@
 
 // 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 {
@@ -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* _Nonnull swiftUnsafePointer) {
+    BleNitro::HybridNativeBleNitroFactorySpec_cxx swiftPart = BleNitro::HybridNativeBleNitroFactorySpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::co::zyke::ble::HybridNativeBleNitroFactorySpecSwift>(swiftPart);
+  }
+  void* _Nonnull 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

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

@@ -16,6 +16,8 @@ namespace NitroModules { class ArrayBuffer; }
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+// Forward declaration of `HybridNativeBleNitroFactorySpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroFactorySpec; }
 // Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
 // Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
@@ -26,12 +28,15 @@ namespace margelo::nitro::co::zyke::ble { struct ManufacturerData; }
 namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridNativeBleNitroFactorySpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroFactorySpec_cxx; }
 // Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
 namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 
 // Include C++ defined types
 #include "BLEDevice.hpp"
 #include "BLEState.hpp"
+#include "HybridNativeBleNitroFactorySpec.hpp"
 #include "HybridNativeBleNitroSpec.hpp"
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
@@ -54,6 +59,15 @@ namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
  */
 namespace margelo::nitro::co::zyke::ble::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
+    return std::optional<std::string>(value);
+  }
+  
   // pragma MARK: std::vector<ManufacturerDataEntry>
   /**
    * Specialized version of `std::vector<ManufacturerDataEntry>`.
@@ -118,15 +132,6 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
     return std::optional<BLEDevice>(value);
   }
   
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) {
-    return std::optional<std::string>(value);
-  }
-  
   // pragma MARK: std::function<void(const std::optional<BLEDevice>& /* device */, const std::optional<std::string>& /* error */)>
   /**
    * Specialized version of `std::function<void(const std::optional<BLEDevice>&, const std::optional<std::string>&)>`.
@@ -460,5 +465,35 @@ namespace margelo::nitro::co::zyke::ble::bridge::swift {
   inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) {
     return Result<std::shared_ptr<Promise<void>>>::withError(error);
   }
+  
+  // pragma MARK: std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const std::vector<BLEDevice>& / * peripherals * /)>>`.
+   */
+  using std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______ = std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>;
+  inline std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>> create_std__optional_std__function_void_const_std__vector_BLEDevice______peripherals______(const std::function<void(const std::vector<BLEDevice>& /* peripherals */)>& value) {
+    return std::optional<std::function<void(const std::vector<BLEDevice>& /* peripherals */)>>(value);
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridNativeBleNitroFactorySpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridNativeBleNitroFactorySpec>`.
+   */
+  using std__shared_ptr_HybridNativeBleNitroFactorySpec_ = std::shared_ptr<HybridNativeBleNitroFactorySpec>;
+  std::shared_ptr<HybridNativeBleNitroFactorySpec> create_std__shared_ptr_HybridNativeBleNitroFactorySpec_(void* _Nonnull swiftUnsafePointer);
+  void* _Nonnull get_std__shared_ptr_HybridNativeBleNitroFactorySpec_(std__shared_ptr_HybridNativeBleNitroFactorySpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNativeBleNitroFactorySpec>
+  using std__weak_ptr_HybridNativeBleNitroFactorySpec_ = std::weak_ptr<HybridNativeBleNitroFactorySpec>;
+  inline std__weak_ptr_HybridNativeBleNitroFactorySpec_ weakify_std__shared_ptr_HybridNativeBleNitroFactorySpec_(const std::shared_ptr<HybridNativeBleNitroFactorySpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<HybridNativeBleNitroSpec>>
+  using Result_std__shared_ptr_HybridNativeBleNitroSpec__ = Result<std::shared_ptr<HybridNativeBleNitroSpec>>;
+  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::shared_ptr<HybridNativeBleNitroSpec>& value) {
+    return Result<std::shared_ptr<HybridNativeBleNitroSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridNativeBleNitroSpec__ create_Result_std__shared_ptr_HybridNativeBleNitroSpec__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<HybridNativeBleNitroSpec>>::withError(error);
+  }
 
 } // namespace margelo::nitro::co::zyke::ble::bridge::swift

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

@@ -16,6 +16,8 @@ namespace NitroModules { class ArrayBuffer; }
 namespace margelo::nitro::co::zyke::ble { struct BLEDevice; }
 // Forward declaration of `BLEState` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
+// Forward declaration of `HybridNativeBleNitroFactorySpec` to properly resolve imports.
+namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroFactorySpec; }
 // Forward declaration of `HybridNativeBleNitroSpec` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { class HybridNativeBleNitroSpec; }
 // Forward declaration of `ManufacturerDataEntry` to properly resolve imports.
@@ -31,6 +33,7 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 #include "AndroidScanMode.hpp"
 #include "BLEDevice.hpp"
 #include "BLEState.hpp"
+#include "HybridNativeBleNitroFactorySpec.hpp"
 #include "HybridNativeBleNitroSpec.hpp"
 #include "ManufacturerData.hpp"
 #include "ManufacturerDataEntry.hpp"
@@ -56,6 +59,8 @@ namespace margelo::nitro::co::zyke::ble { struct ScanFilter; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridNativeBleNitroFactorySpec_cxx` to properly resolve imports.
+namespace BleNitro { class HybridNativeBleNitroFactorySpec_cxx; }
 // Forward declaration of `HybridNativeBleNitroSpec_cxx` to properly resolve imports.
 namespace BleNitro { class HybridNativeBleNitroSpec_cxx; }
 

package/nitrogen/generated/ios/BleNitroAutolinking.mm

@@ -11,6 +11,7 @@
 #import <type_traits>
 
 #include "HybridNativeBleNitroSpecSwift.hpp"
+#include "HybridNativeBleNitroFactorySpecSwift.hpp"
 
 @interface BleNitroAutolinking : NSObject
 @end
@@ -28,6 +29,13 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NativeBleNitroFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridNativeBleNitroFactorySpec> hybridObject = BleNitro::BleNitroAutolinking::createNativeBleNitroFactory();
+      return hybridObject;
+    }
+  );
 }
 
 @end

package/nitrogen/generated/ios/BleNitroAutolinking.swift

@@ -22,4 +22,19 @@ public final class BleNitroAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  /**
+   * Creates an instance of a Swift class that implements `HybridNativeBleNitroFactorySpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridNativeBleNitroFactorySpec_cxx`)
+   *
+   * This is generated by Nitrogen and will initialize the class specified
+   * in the `"autolinking"` property of `nitro.json` (in this case, `BleNitroBleManagerFactory`).
+   */
+  public static func createNativeBleNitroFactory() -> bridge.std__shared_ptr_HybridNativeBleNitroFactorySpec_ {
+    let hybridObject = BleNitroBleManagerFactory()
+    return { () -> bridge.std__shared_ptr_HybridNativeBleNitroFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
 }