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

package/lib/types/RootComponent.d.ts

@@ -19,6 +19,10 @@ export type RootComponentInitialProps = {
      * this is the initial color scheme, add onAppearanceDidChange on MapTemplate to get updates
      */
     colorScheme: ColorScheme;
+    /**
+     * the dimensions of the render surface, kept up to date when the host resizes the surface
+     * (e.g. head units running Android Auto windowed)
+     */
     window: WindowInformation;
 };
 export type AutoPlayClusterInitialProps = RootComponentInitialProps & {

package/lib/utils/NitroOptionsPanel.d.ts

@@ -0,0 +1,67 @@
+import type { ImageButton, TextButton } from '../types/Button';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from './NitroAction';
+import { type GridButton, type NitroGridButton } from './NitroGrid';
+import { type DefaultRow, type NitroSection, type RadioRow, type TextRow, type ToggleRow } from './NitroSection';
+/** @namespace iOS a whole button grid, same as GridTemplate's own grid. */
+export type OptionsPanelGridSection<T> = {
+    type: 'grid';
+    title?: string;
+    buttons: Array<GridButton<T>>;
+};
+export type ChargingConnector = 'ccs1' | 'ccs2' | 'j1772' | 'chaDeMo' | 'mennekes' | 'gbtDC' | 'gbtAC' | 'nacsDC' | 'nacsAC';
+/** @namespace iOS one outlet (`CPChargingStationConnection`) on a charging station. */
+export type ChargerOutlet<T> = {
+    connector: ChargingConnector;
+    /** volts */
+    voltage: number;
+    /** converted to megawatts on the native side above 1000 kW */
+    powerKw: number;
+    onPress?: (template: T) => void;
+};
+/** @namespace iOS a charging station's outlets — a station commonly has several (e.g. CCS2 + Type 2). */
+export type OptionsPanelChargerSection<T> = {
+    type: 'charger';
+    title?: string;
+    outlets: Array<ChargerOutlet<T>>;
+};
+/**
+ * @namespace iOS a full list: default/toggle/text rows mixed freely, or a mutually-exclusive
+ * radio group — the item array's own row types carry that distinction, not a section-level tag.
+ */
+export type OptionsPanelListSection<T> = {
+    type: 'list';
+    title?: string;
+    items: Array<DefaultRow<T> | ToggleRow<T> | TextRow> | Array<RadioRow<T>>;
+};
+/** one kind per section: list, grid, or charger outlet — CarPlay allows mixing kinds, but we don't need that yet. */
+export type OptionsPanelSection<T> = OptionsPanelListSection<T> | OptionsPanelGridSection<T> | OptionsPanelChargerSection<T>;
+export type OptionsPanelConfig<T> = {
+    title?: AutoText;
+    sections: Array<OptionsPanelSection<T>>;
+    /** @namespace iOS one primary `TextButton` plus one optional icon-only `ImageButton` — nothing more is supported. */
+    actions?: [TextButton<T>] | [TextButton<T>, ImageButton<T>];
+};
+export type NitroOptionsPanelGridSection = {
+    title?: string;
+    buttons: Array<NitroGridButton>;
+};
+export type NitroChargerOutlet = {
+    connector: ChargingConnector;
+    voltage: number;
+    powerKw: number;
+    onPress?: () => void;
+};
+export type NitroOptionsPanelChargerSection = {
+    title?: string;
+    outlets: Array<NitroChargerOutlet>;
+};
+export type NitroOptionsPanelSection = NitroSection | NitroOptionsPanelGridSection | NitroOptionsPanelChargerSection;
+export type NitroOptionsPanelConfig = {
+    title?: AutoText;
+    sections: Array<NitroOptionsPanelSection>;
+    actions?: Array<NitroAction>;
+};
+export declare const NitroOptionsPanelUtil: {
+    convert: <T>(template: T, config?: OptionsPanelConfig<T>) => NitroOptionsPanelConfig | undefined;
+};

package/lib/utils/NitroOptionsPanel.js

@@ -0,0 +1,48 @@
+import { NitroActionUtil } from './NitroAction';
+import { NitroGridUtil } from './NitroGrid';
+import { NitroSectionUtil, } from './NitroSection';
+const convertSection = (template, section) => {
+    if (section.type === 'grid') {
+        return {
+            title: section.title,
+            buttons: NitroGridUtil.convert(template, section.buttons),
+        };
+    }
+    if (section.type === 'charger') {
+        return {
+            title: section.title,
+            outlets: section.outlets.map((outlet) => ({
+                connector: outlet.connector,
+                voltage: outlet.voltage,
+                powerKw: outlet.powerKw,
+                onPress: outlet.onPress ? () => outlet.onPress?.(template) : undefined,
+            })),
+        };
+    }
+    // items is all-radio or all-default/toggle/text, never mixed — translate into MultiSection's
+    // default/radio shape to reuse NitroSectionUtil.convert's radio-validation logic as-is.
+    const isRadioGroup = section.items.length > 0 && section.items.every((item) => item.type === 'radio');
+    const multiSection = isRadioGroup
+        ? { type: 'radio', title: section.title ?? '', items: section.items }
+        : {
+            type: 'default',
+            title: section.title ?? '',
+            items: section.items,
+        };
+    const [nitroSection] = NitroSectionUtil.convert(template, [multiSection]) ?? [];
+    if (nitroSection == null) {
+        throw new Error('converting sections failed');
+    }
+    return nitroSection;
+};
+const convert = (template, config) => {
+    if (config == null) {
+        return undefined;
+    }
+    return {
+        title: config.title,
+        sections: config.sections.map((section) => convertSection(template, section)),
+        actions: NitroActionUtil.convert(template, config.actions),
+    };
+};
+export const NitroOptionsPanelUtil = { convert };

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"
+  }
+}