@iternio/react-native-auto-play 0.5.5 → 0.5.7

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

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

@@ -0,0 +1,91 @@
+///
+/// WindowInformation.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/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  /**
+   * A struct which can be represented as a JavaScript object (WindowInformation).
+   */
+  struct WindowInformation final {
+  public:
+    double width     SWIFT_PRIVATE;
+    double height     SWIFT_PRIVATE;
+    double scale     SWIFT_PRIVATE;
+
+  public:
+    WindowInformation() = default;
+    explicit WindowInformation(double width, double height, double scale): width(width), height(height), scale(scale) {}
+
+  public:
+    friend bool operator==(const WindowInformation& lhs, const WindowInformation& rhs) = default;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay
+
+namespace margelo::nitro {
+
+  // C++ WindowInformation <> JS WindowInformation (object)
+  template <>
+  struct JSIConverter<margelo::nitro::swe::iternio::reactnativeautoplay::WindowInformation> final {
+    static inline margelo::nitro::swe::iternio::reactnativeautoplay::WindowInformation fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::swe::iternio::reactnativeautoplay::WindowInformation(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "scale")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::swe::iternio::reactnativeautoplay::WindowInformation& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "width"), JSIConverter<double>::toJSI(runtime, arg.width));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "height"), JSIConverter<double>::toJSI(runtime, arg.height));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "scale"), JSIConverter<double>::toJSI(runtime, arg.scale));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "width")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "height")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "scale")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iternio/react-native-auto-play",
-  "version": "0.5.5",
+  "version": "0.5.7",
   "description": "Android Auto and Apple CarPlay for react-native",
   "main": "lib/index",
   "module": "lib/index",

package/src/components/WindowInformationWrapper.tsx

@@ -0,0 +1,30 @@
+import type React from 'react';
+import { createElement, useEffect, useState } from 'react';
+import { HybridAndroidWindowInformation } from '../hybrid/HybridAndroidWindowInformation';
+import type { RootComponentInitialProps } from '../types/RootComponent';
+
+/**
+ * Renders a user-provided root component and keeps its `window` prop up to date when the host
+ * recreates the render surface with new dimensions (some head units run Android Auto windowed
+ * and resize it at runtime), so consumers can simply read `props.window` without registering a
+ * listener themselves.
+ * On iOS this only passes the initial props through — CarPlay windows keep their size for the
+ * lifetime of a scene, so there is nothing to subscribe to.
+ */
+export function WindowInformationWrapper({
+  moduleName,
+  component,
+  componentProps,
+}: {
+  moduleName: string;
+  component: React.ComponentType<RootComponentInitialProps>;
+  componentProps: RootComponentInitialProps;
+}) {
+  const [window, setWindow] = useState(componentProps.window);
+
+  useEffect(() => {
+    return HybridAndroidWindowInformation?.addWindowInformationListener(moduleName, setWindow);
+  }, [moduleName]);
+
+  return createElement(component, { ...componentProps, window });
+}

package/src/hybrid/HybridAndroidWindowInformation.android.ts

@@ -0,0 +1,5 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { AndroidWindowInformation } from '../specs/AndroidWindowInformation.nitro';
+
+export const HybridAndroidWindowInformation: AndroidWindowInformation | null =
+  NitroModules.createHybridObject<AndroidWindowInformation>('AndroidWindowInformation');

package/src/hybrid/HybridAndroidWindowInformation.ts

@@ -0,0 +1,3 @@
+import type { AndroidWindowInformation } from '../specs/AndroidWindowInformation.nitro';
+
+export const HybridAndroidWindowInformation: AndroidWindowInformation | null = null;

package/src/index.ts

@@ -2,13 +2,14 @@ import { Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
+import { HybridAndroidWindowInformation } from './hybrid/HybridAndroidWindowInformation';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
 import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
 
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
 
-export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAndroidWindowInformation, HybridAutoPlay, HybridVoice };
 
 export const HybridAndroidAutomotive =
   Platform.OS === 'android'

package/src/scenes/AutoPlayCluster.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { AppRegistry, Platform } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { WindowInformationWrapper } from '../components/WindowInformationWrapper';
 import type { Cluster as NitroCluster, ZoomEvent } from '../specs/Cluster.nitro';
 import type { ColorScheme, RootComponentInitialProps } from '../types/RootComponent';
 import type { AutoAttributedString } from '../utils/NitroAttributedString';
@@ -62,7 +63,11 @@ class Cluster {
           React.createElement(SafeAreaInsetsProvider, {
             moduleName: clusterId,
             // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-            children: React.createElement(component, props),
+            children: React.createElement(WindowInformationWrapper, {
+              moduleName: clusterId,
+              component,
+              componentProps: props,
+            }),
           })
       );
 

package/src/specs/AndroidWindowInformation.nitro.ts

@@ -0,0 +1,24 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { CleanupCallback } from '../types/Event';
+import type { WindowInformation } from '../types/RootComponent';
+
+/**
+ * Android-only access to render-surface window dimensions. On iOS this module does not exist —
+ * use the platform-split `HybridAndroidWindowInformation` wrapper which resolves to `null` there.
+ */
+export interface AndroidWindowInformation extends HybridObject<{ android: 'kotlin' }> {
+  /**
+   * callback for window dimension changes, fired when the host recreates the render surface
+   * with a different size (some head units run Android Auto windowed and resize it at runtime).
+   * Root components rendered via a template's `component` prop do NOT need this — their
+   * `window` prop is kept up to date automatically. Use this listener only for
+   * size-dependent logic living outside a root component.
+   * Fires with the last known window information immediately if the surface is already initialized.
+   * @param moduleName one of @AutoPlayModules or a cluster scene uuid
+   * @namespace Android
+   */
+  addWindowInformationListener(
+    moduleName: string,
+    callback: (window: WindowInformation) => void
+  ): CleanupCallback;
+}

package/src/templates/MapTemplate.ts

@@ -4,6 +4,7 @@ import { NitroModules } from 'react-native-nitro-modules';
 import type { AutoText } from '..';
 import { MapTemplateProvider } from '../components/MapTemplateContext';
 import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
+import { WindowInformationWrapper } from '../components/WindowInformationWrapper';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import type { MapTemplate as NitroMapTemplate } from '../specs/MapTemplate.nitro';
 import type { ActionButtonAndroid, MapButton, MapPanButton } from '../types/Button';
@@ -196,7 +197,11 @@ export class MapTemplate extends Template<MapTemplateConfig, MapTemplateConfig['
           children: React.createElement(SafeAreaInsetsProvider, {
             moduleName: this.id,
             // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
-            children: React.createElement(component, props),
+            children: React.createElement(WindowInformationWrapper, {
+              moduleName: this.id,
+              component,
+              componentProps: props,
+            }),
           }),
         })
     );

package/src/types/RootComponent.ts

@@ -21,6 +21,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;
 };