@iternio/react-native-auto-play 0.5.8 → 0.5.10

package/nitro.json

@@ -29,6 +29,12 @@
         "language": "swift"
       }
     },
+    "AndroidWindowInformation": {
+      "android": {
+        "implementationClassName": "HybridAndroidWindowInformation",
+        "language": "kotlin"
+      }
+    },
     "AndroidAutoTelemetry": {
       "android": {
         "implementationClassName": "HybridAndroidAutoTelemetry",

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

@@ -35,6 +35,7 @@ target_sources(
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/shared/c++/HybridAndroidAutoTelemetrySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridAndroidWindowInformationSpec.cpp
   ../nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
   ../nitrogen/generated/shared/c++/HybridCarPlayDashboardSpec.cpp
   ../nitrogen/generated/shared/c++/HybridClusterSpec.cpp
@@ -49,6 +50,7 @@ target_sources(
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
+  ../nitrogen/generated/android/c++/JHybridAndroidWindowInformationSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
   ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage_RemoteImage.cpp
   ../nitrogen/generated/android/c++/JHybridClusterSpec.cpp

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -21,6 +21,8 @@
 #include "JFunc_void_AppFocusState.hpp"
 #include "JHybridAndroidAutoTelemetrySpec.hpp"
 #include "JFunc_void_std__optional_Telemetry_.hpp"
+#include "JHybridAndroidWindowInformationSpec.hpp"
+#include "JFunc_void_WindowInformation.hpp"
 #include "JHybridAutoPlaySpec.hpp"
 #include "JFunc_void_VisibilityState.hpp"
 #include "JFunc_void_std__optional_Location__std__optional_std__string_.hpp"
@@ -74,6 +76,14 @@ struct JHybridAutoPlaySpecImpl: public jni::JavaClass<JHybridAutoPlaySpecImpl, J
     return javaPart->getJHybridAutoPlaySpec();
   }
 };
+struct JHybridAndroidWindowInformationSpecImpl: public jni::JavaClass<JHybridAndroidWindowInformationSpecImpl, JHybridAndroidWindowInformationSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidWindowInformation;";
+  static std::shared_ptr<JHybridAndroidWindowInformationSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridAndroidWindowInformationSpecImpl::javaobject()>();
+    jni::local_ref<JHybridAndroidWindowInformationSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridAndroidWindowInformationSpec();
+  }
+};
 struct JHybridAndroidAutoTelemetrySpecImpl: public jni::JavaClass<JHybridAndroidAutoTelemetrySpecImpl, JHybridAndroidAutoTelemetrySpec::JavaPart> {
   static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidAutoTelemetry;";
   static std::shared_ptr<JHybridAndroidAutoTelemetrySpec> create() {
@@ -166,6 +176,8 @@ void registerAllNatives() {
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_AppFocusState_cxx::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidAutoTelemetrySpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Telemetry__cxx::registerNatives();
+  margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidWindowInformationSpec::CxxPart::registerNatives();
+  margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_WindowInformation_cxx::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAutoPlaySpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_VisibilityState_cxx::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Location__std__optional_std__string__cxx::registerNatives();
@@ -207,6 +219,12 @@ void registerAllNatives() {
       return JHybridAutoPlaySpecImpl::create();
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "AndroidWindowInformation",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridAndroidWindowInformationSpecImpl::create();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "AndroidAutoTelemetry",
     []() -> std::shared_ptr<HybridObject> {

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_WindowInformation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "WindowInformation.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JWindowInformation.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(window: WindowInformation) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_WindowInformation: public jni::JavaClass<JFunc_void_WindowInformation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_WindowInformation;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_WindowInformation` instance holds through JNI.
+     */
+    void invoke(const WindowInformation& window) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JWindowInformation> /* window */)>("invoke");
+      method(self(), JWindowInformation::fromCpp(window));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_WindowInformation that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_WindowInformation_cxx final: public jni::HybridClass<JFunc_void_WindowInformation_cxx, JFunc_void_WindowInformation> {
+  public:
+    static jni::local_ref<JFunc_void_WindowInformation::javaobject> fromCpp(const std::function<void(const WindowInformation& /* window */)>& func) {
+      return JFunc_void_WindowInformation_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_WindowInformation_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JWindowInformation> window) {
+      _func(window->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const WindowInformation& /* window */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_WindowInformation_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_WindowInformation_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_WindowInformation_cxx(const std::function<void(const WindowInformation& /* window */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const WindowInformation& /* window */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,68 @@
+///
+/// JHybridAndroidWindowInformationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridAndroidWindowInformationSpec.hpp"
+
+// Forward declaration of `WindowInformation` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct WindowInformation; }
+
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <string>
+#include "WindowInformation.hpp"
+#include "JFunc_void_WindowInformation.hpp"
+#include "JWindowInformation.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  std::shared_ptr<JHybridAndroidWindowInformationSpec> JHybridAndroidWindowInformationSpec::JavaPart::getJHybridAndroidWindowInformationSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridAndroidWindowInformationSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridAndroidWindowInformationSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridAndroidWindowInformationSpec::CxxPart::jhybriddata> JHybridAndroidWindowInformationSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridAndroidWindowInformationSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridAndroidWindowInformationSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridAndroidWindowInformationSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridAndroidWindowInformationSpec>(castJavaPart);
+  }
+
+  void JHybridAndroidWindowInformationSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridAndroidWindowInformationSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::function<void()> JHybridAndroidWindowInformationSpec::addWindowInformationListener(const std::string& moduleName, const std::function<void(const WindowInformation& /* window */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<jni::JString> /* moduleName */, jni::alias_ref<JFunc_void_WindowInformation::javaobject> /* callback */)>("addWindowInformationListener_cxx");
+    auto __result = method(_javaPart, jni::make_jstring(moduleName), JFunc_void_WindowInformation_cxx::fromCpp(callback));
+    return [&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }();
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,63 @@
+///
+/// HybridAndroidWindowInformationSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAndroidWindowInformationSpec.hpp"
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  class JHybridAndroidWindowInformationSpec: public virtual HybridAndroidWindowInformationSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidWindowInformationSpec;";
+      std::shared_ptr<JHybridAndroidWindowInformationSpec> getJHybridAndroidWindowInformationSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidWindowInformationSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridAndroidWindowInformationSpec(const jni::local_ref<JHybridAndroidWindowInformationSpec::JavaPart>& javaPart):
+      HybridObject(HybridAndroidWindowInformationSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridAndroidWindowInformationSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridAndroidWindowInformationSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::function<void()> addWindowInformationListener(const std::string& moduleName, const std::function<void(const WindowInformation& /* window */)>& callback) override;
+
+  private:
+    jni::global_ref<JHybridAndroidWindowInformationSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,65 @@
+///
+/// JWindowInformation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "WindowInformation.hpp"
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "WindowInformation" and the the Kotlin data class "WindowInformation".
+   */
+  struct JWindowInformation final: public jni::JavaClass<JWindowInformation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/WindowInformation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct WindowInformation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    WindowInformation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      static const auto fieldScale = clazz->getField<double>("scale");
+      double scale = this->getFieldValue(fieldScale);
+      return WindowInformation(
+        width,
+        height,
+        scale
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JWindowInformation::javaobject> fromCpp(const WindowInformation& value) {
+      using JSignature = JWindowInformation(double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.width,
+        value.height,
+        value.scale
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_WindowInformation.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_WindowInformation.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(window: struct) => 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_WindowInformation: (WindowInformation) -> 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(window: WindowInformation): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(window: struct) => 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_WindowInformation_cxx: Func_void_WindowInformation {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(window: WindowInformation): Unit
+    = invoke_cxx(window)
+
+  @FastNative
+  private external fun invoke_cxx(window: WindowInformation): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(window: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(WindowInformation) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_WindowInformation_java(private val function: (WindowInformation) -> Unit): Func_void_WindowInformation {
+  @DoNotStrip
+  @Keep
+  override fun invoke(window: WindowInformation): Unit {
+    return this.function(window)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidWindowInformationSpec.kt

@@ -0,0 +1,59 @@
+///
+/// HybridAndroidWindowInformationSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the AndroidWindowInformation HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of AndroidWindowInformation.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridAndroidWindowInformationSpec: HybridObject() {
+  // Properties
+  
+
+  // Methods
+  abstract fun addWindowInformationListener(moduleName: String, callback: (window: WindowInformation) -> Unit): () -> Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun addWindowInformationListener_cxx(moduleName: String, callback: Func_void_WindowInformation): Func_void {
+    val __result = addWindowInformationListener(moduleName, callback)
+    return Func_void_java(__result)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject AndroidWindowInformation]"
+  }
+
+  // C++ backing class
+  @DoNotStrip
+  @Keep
+  protected open class CxxPart(javaPart: HybridAndroidWindowInformationSpec): HybridObject.CxxPart(javaPart) {
+    // C++ JHybridAndroidWindowInformationSpec::CxxPart::initHybrid(...)
+    external override fun initHybrid(): HybridData
+  }
+  override fun createCxxPart(): CxxPart {
+    return CxxPart(this)
+  }
+
+  companion object {
+    protected const val TAG = "HybridAndroidWindowInformationSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/WindowInformation.kt

@@ -0,0 +1,61 @@
+///
+/// WindowInformation.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "WindowInformation".
+ */
+@DoNotStrip
+@Keep
+data class WindowInformation(
+  @DoNotStrip
+  @Keep
+  val width: Double,
+  @DoNotStrip
+  @Keep
+  val height: Double,
+  @DoNotStrip
+  @Keep
+  val scale: Double
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is WindowInformation) return false
+    return Objects.deepEquals(this.width, other.width)
+      && Objects.deepEquals(this.height, other.height)
+      && Objects.deepEquals(this.scale, other.scale)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      width,
+      height,
+      scale
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(width: Double, height: Double, scale: Double): WindowInformation {
+      return WindowInformation(width, height, scale)
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+///
+/// HybridAndroidWindowInformationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridAndroidWindowInformationSpec.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  void HybridAndroidWindowInformationSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("addWindowInformationListener", &HybridAndroidWindowInformationSpec::addWindowInformationListener);
+    });
+  }
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,65 @@
+///
+/// HybridAndroidWindowInformationSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `WindowInformation` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct WindowInformation; }
+
+#include <functional>
+#include <string>
+#include "WindowInformation.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `AndroidWindowInformation`
+   * Inherit this class to create instances of `HybridAndroidWindowInformationSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridAndroidWindowInformation: public HybridAndroidWindowInformationSpec {
+   * public:
+   *   HybridAndroidWindowInformation(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridAndroidWindowInformationSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridAndroidWindowInformationSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridAndroidWindowInformationSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::function<void()> addWindowInformationListener(const std::string& moduleName, const std::function<void(const WindowInformation& /* window */)>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "AndroidWindowInformation";
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay