@iternio/react-native-auto-play 0.1.2 → 0.1.4

package/lib/hooks/useFocusedEffect.d.ts

@@ -0,0 +1,9 @@
+/**
+ * An effect hook that only runs when the CarPlay/Android Auto screen is visible to the user and dependencies have changed.
+ * It behaves like `useEffect`, but the effect function is only executed if the screen is visible.
+ *
+ * @param moduleName The name of the root module to listen to for focus changes - one of AutoPlayModules or a cluster uuid.
+ * @param effect The effect function to run.
+ * @param deps An array of dependencies for the effect.
+ */
+export declare function useFocusedEffect(moduleName: string, effect: () => void | (() => void), deps: readonly unknown[]): void;

package/lib/hooks/useFocusedEffect.js

@@ -0,0 +1,32 @@
+import { useEffect, useRef, useState } from 'react';
+import { HybridAutoPlay } from '..';
+/**
+ * An effect hook that only runs when the CarPlay/Android Auto screen is visible to the user and dependencies have changed.
+ * It behaves like `useEffect`, but the effect function is only executed if the screen is visible.
+ *
+ * @param moduleName The name of the root module to listen to for focus changes - one of AutoPlayModules or a cluster uuid.
+ * @param effect The effect function to run.
+ * @param deps An array of dependencies for the effect.
+ */
+export function useFocusedEffect(moduleName, effect, deps) {
+    const [isFocused, setIsFocused] = useState(false);
+    const effectRef = useRef(effect);
+    useEffect(() => {
+        effectRef.current = effect;
+    }, [effect]);
+    useEffect(() => {
+        return HybridAutoPlay.addListenerRenderState(moduleName, (state) => {
+            if (state === 'willAppear' || state === 'willDisappear') {
+                // react on actual visibility changes only
+                return;
+            }
+            setIsFocused(state === 'didAppear');
+        });
+    }, [moduleName]);
+    useEffect(() => {
+        if (!isFocused) {
+            return;
+        }
+        return effectRef.current();
+    }, [isFocused, ...deps]);
+}

package/lib/hooks/useIsAutoPlayFocused.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export declare function useIsAutoPlayFocused(moduleName: string): boolean;

package/lib/hooks/useIsAutoPlayFocused.js

@@ -0,0 +1,20 @@
+import { useEffect, useState } from 'react';
+import { HybridAutoPlay } from '..';
+/**
+ * A hook to determine if the CarPlay/Android Auto screen is currently focused (visible).
+ *
+ * @param moduleName The name of the module to listen to.
+ * @returns `true` if the screen is focused, `false` otherwise.
+ */
+export function useIsAutoPlayFocused(moduleName) {
+    const [isFocused, setIsFocused] = useState(false);
+    useEffect(() => {
+        const remove = HybridAutoPlay.addListenerRenderState(moduleName, (state) => {
+            setIsFocused(state === 'didAppear');
+        });
+        return () => {
+            remove();
+        };
+    }, [moduleName]);
+    return isFocused;
+}

package/lib/index.d.ts

@@ -13,6 +13,7 @@ export declare enum AutoPlayModules {
 }
 export * from './components/SafeAreaView';
 export * from './hooks/useAndroidAutoTelemetry';
+export * from './hooks/useFocusedEffect';
 export * from './hooks/useMapTemplate';
 export * from './hooks/useSafeAreaInsets';
 export * from './hooks/useVoiceInput';

package/lib/index.js

@@ -18,6 +18,7 @@ export var AutoPlayModules;
 })(AutoPlayModules || (AutoPlayModules = {}));
 export * from './components/SafeAreaView';
 export * from './hooks/useAndroidAutoTelemetry';
+export * from './hooks/useFocusedEffect';
 export * from './hooks/useMapTemplate';
 export * from './hooks/useSafeAreaInsets';
 export * from './hooks/useVoiceInput';

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

@@ -11,6 +11,7 @@
 #include <functional>
 
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -37,7 +38,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
   public:
     static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
       return JFunc_void_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "AlertDismissalReason.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JAlertDismissalReason.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -39,7 +40,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_AlertDismissalReason that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_AlertDismissalReason_cxx final: public jni::HybridClass<JFunc_void_AlertDismissalReason_cxx, JFunc_void_AlertDismissalReason> {
+  class JFunc_void_AlertDismissalReason_cxx final: public jni::HybridClass<JFunc_void_AlertDismissalReason_cxx, JFunc_void_AlertDismissalReason> {
   public:
     static jni::local_ref<JFunc_void_AlertDismissalReason::javaobject> fromCpp(const std::function<void(AlertDismissalReason /* reason */)>& func) {
       return JFunc_void_AlertDismissalReason_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "ColorScheme.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JColorScheme.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -39,7 +40,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_ColorScheme that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_ColorScheme_cxx final: public jni::HybridClass<JFunc_void_ColorScheme_cxx, JFunc_void_ColorScheme> {
+  class JFunc_void_ColorScheme_cxx final: public jni::HybridClass<JFunc_void_ColorScheme_cxx, JFunc_void_ColorScheme> {
   public:
     static jni::local_ref<JFunc_void_ColorScheme::javaobject> fromCpp(const std::function<void(ColorScheme /* colorScheme */)>& func) {
       return JFunc_void_ColorScheme_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "Point.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JPoint.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -39,7 +40,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_Point that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_Point_cxx final: public jni::HybridClass<JFunc_void_Point_cxx, JFunc_void_Point> {
+  class JFunc_void_Point_cxx final: public jni::HybridClass<JFunc_void_Point_cxx, JFunc_void_Point> {
   public:
     static jni::local_ref<JFunc_void_Point::javaobject> fromCpp(const std::function<void(const Point& /* center */)>& func) {
       return JFunc_void_Point_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "Point.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JPoint.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -39,7 +40,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_Point_double that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_Point_double_cxx final: public jni::HybridClass<JFunc_void_Point_double_cxx, JFunc_void_Point_double> {
+  class JFunc_void_Point_double_cxx final: public jni::HybridClass<JFunc_void_Point_double_cxx, JFunc_void_Point_double> {
   public:
     static jni::local_ref<JFunc_void_Point_double::javaobject> fromCpp(const std::function<void(const Point& /* center */, double /* scale */)>& func) {
       return JFunc_void_Point_double_cxx::newObjectCxxArgs(func);

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

@@ -13,6 +13,7 @@
 #include "Point.hpp"
 #include <optional>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JPoint.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -40,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_Point_std__optional_Point_ that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_Point_std__optional_Point__cxx final: public jni::HybridClass<JFunc_void_Point_std__optional_Point__cxx, JFunc_void_Point_std__optional_Point_> {
+  class JFunc_void_Point_std__optional_Point__cxx final: public jni::HybridClass<JFunc_void_Point_std__optional_Point__cxx, JFunc_void_Point_std__optional_Point_> {
   public:
     static jni::local_ref<JFunc_void_Point_std__optional_Point_::javaobject> fromCpp(const std::function<void(const Point& /* translation */, const std::optional<Point>& /* velocity */)>& func) {
       return JFunc_void_Point_std__optional_Point__cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "SafeAreaInsets.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JSafeAreaInsets.hpp"
 #include <optional>
 
@@ -40,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_SafeAreaInsets that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_SafeAreaInsets_cxx final: public jni::HybridClass<JFunc_void_SafeAreaInsets_cxx, JFunc_void_SafeAreaInsets> {
+  class JFunc_void_SafeAreaInsets_cxx final: public jni::HybridClass<JFunc_void_SafeAreaInsets_cxx, JFunc_void_SafeAreaInsets> {
   public:
     static jni::local_ref<JFunc_void_SafeAreaInsets::javaobject> fromCpp(const std::function<void(const SafeAreaInsets& /* insets */)>& func) {
       return JFunc_void_SafeAreaInsets_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "VisibilityState.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JVisibilityState.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -39,7 +40,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_VisibilityState that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_VisibilityState_cxx final: public jni::HybridClass<JFunc_void_VisibilityState_cxx, JFunc_void_VisibilityState> {
+  class JFunc_void_VisibilityState_cxx final: public jni::HybridClass<JFunc_void_VisibilityState_cxx, JFunc_void_VisibilityState> {
   public:
     static jni::local_ref<JFunc_void_VisibilityState::javaobject> fromCpp(const std::function<void(VisibilityState /* payload */)>& func) {
       return JFunc_void_VisibilityState_cxx::newObjectCxxArgs(func);

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

@@ -11,6 +11,7 @@
 #include <functional>
 
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -37,7 +38,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_bool that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
+  class JFunc_void_bool_cxx final: public jni::HybridClass<JFunc_void_bool_cxx, JFunc_void_bool> {
   public:
     static jni::local_ref<JFunc_void_bool::javaobject> fromCpp(const std::function<void(bool /* isPanningInterfaceVisible */)>& func) {
       return JFunc_void_bool_cxx::newObjectCxxArgs(func);

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

@@ -14,6 +14,7 @@
 #include <optional>
 #include <string>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JLocation.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -41,7 +42,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__optional_Location__std__optional_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__optional_Location__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_Location__std__optional_std__string__cxx, JFunc_void_std__optional_Location__std__optional_std__string_> {
+  class JFunc_void_std__optional_Location__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_Location__std__optional_std__string__cxx, JFunc_void_std__optional_Location__std__optional_std__string_> {
   public:
     static jni::local_ref<JFunc_void_std__optional_Location__std__optional_std__string_::javaobject> fromCpp(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& func) {
       return JFunc_void_std__optional_Location__std__optional_std__string__cxx::newObjectCxxArgs(func);

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

@@ -14,6 +14,7 @@
 #include <optional>
 #include <string>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JTelemetry.hpp"
 #include "NumericTelemetryItem.hpp"
 #include "JNumericTelemetryItem.hpp"
@@ -47,7 +48,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__optional_Telemetry__std__optional_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx, JFunc_void_std__optional_Telemetry__std__optional_std__string_> {
+  class JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx final: public jni::HybridClass<JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx, JFunc_void_std__optional_Telemetry__std__optional_std__string_> {
   public:
     static jni::local_ref<JFunc_void_std__optional_Telemetry__std__optional_std__string_::javaobject> fromCpp(const std::function<void(const std::optional<Telemetry>& /* tlm */, const std::optional<std::string>& /* error */)>& func) {
       return JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include <optional>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -38,7 +39,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__optional_bool_ that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__optional_bool__cxx final: public jni::HybridClass<JFunc_void_std__optional_bool__cxx, JFunc_void_std__optional_bool_> {
+  class JFunc_void_std__optional_bool__cxx final: public jni::HybridClass<JFunc_void_std__optional_bool__cxx, JFunc_void_std__optional_bool_> {
   public:
     static jni::local_ref<JFunc_void_std__optional_bool_::javaobject> fromCpp(const std::function<void(std::optional<bool> /* animated */)>& func) {
       return JFunc_void_std__optional_bool__cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include <string>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -38,7 +39,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__string that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
+  class JFunc_void_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_cxx, JFunc_void_std__string> {
   public:
     static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* searchText */)>& func) {
       return JFunc_void_std__string_cxx::newObjectCxxArgs(func);

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

@@ -13,6 +13,7 @@
 #include <string>
 #include "ColorScheme.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JColorScheme.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -40,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__string_ColorScheme that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__string_ColorScheme_cxx final: public jni::HybridClass<JFunc_void_std__string_ColorScheme_cxx, JFunc_void_std__string_ColorScheme> {
+  class JFunc_void_std__string_ColorScheme_cxx final: public jni::HybridClass<JFunc_void_std__string_ColorScheme_cxx, JFunc_void_std__string_ColorScheme> {
   public:
     static jni::local_ref<JFunc_void_std__string_ColorScheme::javaobject> fromCpp(const std::function<void(const std::string& /* clusterId */, ColorScheme /* payload */)>& func) {
       return JFunc_void_std__string_ColorScheme_cxx::newObjectCxxArgs(func);

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

@@ -13,6 +13,7 @@
 #include <string>
 #include "ZoomEvent.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JZoomEvent.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -40,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__string_ZoomEvent that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__string_ZoomEvent_cxx final: public jni::HybridClass<JFunc_void_std__string_ZoomEvent_cxx, JFunc_void_std__string_ZoomEvent> {
+  class JFunc_void_std__string_ZoomEvent_cxx final: public jni::HybridClass<JFunc_void_std__string_ZoomEvent_cxx, JFunc_void_std__string_ZoomEvent> {
   public:
     static jni::local_ref<JFunc_void_std__string_ZoomEvent::javaobject> fromCpp(const std::function<void(const std::string& /* clusterId */, ZoomEvent /* payload */)>& func) {
       return JFunc_void_std__string_ZoomEvent_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include <string>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -38,7 +39,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__string_bool that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__string_bool_cxx final: public jni::HybridClass<JFunc_void_std__string_bool_cxx, JFunc_void_std__string_bool> {
+  class JFunc_void_std__string_bool_cxx final: public jni::HybridClass<JFunc_void_std__string_bool_cxx, JFunc_void_std__string_bool> {
   public:
     static jni::local_ref<JFunc_void_std__string_bool::javaobject> fromCpp(const std::function<void(const std::string& /* clusterId */, bool /* payload */)>& func) {
       return JFunc_void_std__string_bool_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include <string>
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -38,7 +39,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   /**
    * An implementation of Func_void_std__string_std__string that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_std__string_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_std__string_cxx, JFunc_void_std__string_std__string> {
+  class JFunc_void_std__string_std__string_cxx final: public jni::HybridClass<JFunc_void_std__string_std__string_cxx, JFunc_void_std__string_std__string> {
   public:
     static jni::local_ref<JFunc_void_std__string_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* tripId */, const std::string& /* routeId */)>& func) {
       return JFunc_void_std__string_std__string_cxx::newObjectCxxArgs(func);

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

@@ -43,6 +43,7 @@
 #include "NitroGridButton.hpp"
 #include "NitroMapButton.hpp"
 #include "NitroMapButtonType.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include <functional>
 #include <optional>
 #include <string>
@@ -98,9 +99,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             return downcast->cthis()->getFunction();
           } else {
             auto onWillAppearRef = jni::make_global(onWillAppear);
-            return [onWillAppearRef](std::optional<bool> animated) -> void {
-              return onWillAppearRef->invoke(animated);
-            };
+            return JNICallable<JFunc_void_std__optional_bool_, void(std::optional<bool>)>(std::move(onWillAppearRef));
           }
         }()) : std::nullopt,
         onWillDisappear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
@@ -109,9 +108,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             return downcast->cthis()->getFunction();
           } else {
             auto onWillDisappearRef = jni::make_global(onWillDisappear);
-            return [onWillDisappearRef](std::optional<bool> animated) -> void {
-              return onWillDisappearRef->invoke(animated);
-            };
+            return JNICallable<JFunc_void_std__optional_bool_, void(std::optional<bool>)>(std::move(onWillDisappearRef));
           }
         }()) : std::nullopt,
         onDidAppear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
@@ -120,9 +117,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             return downcast->cthis()->getFunction();
           } else {
             auto onDidAppearRef = jni::make_global(onDidAppear);
-            return [onDidAppearRef](std::optional<bool> animated) -> void {
-              return onDidAppearRef->invoke(animated);
-            };
+            return JNICallable<JFunc_void_std__optional_bool_, void(std::optional<bool>)>(std::move(onDidAppearRef));
           }
         }()) : std::nullopt,
         onDidDisappear != nullptr ? std::make_optional([&]() -> std::function<void(std::optional<bool> /* animated */)> {
@@ -131,9 +126,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             return downcast->cthis()->getFunction();
           } else {
             auto onDidDisappearRef = jni::make_global(onDidDisappear);
-            return [onDidDisappearRef](std::optional<bool> animated) -> void {
-              return onDidDisappearRef->invoke(animated);
-            };
+            return JNICallable<JFunc_void_std__optional_bool_, void(std::optional<bool>)>(std::move(onDidDisappearRef));
           }
         }()) : std::nullopt,
         onPopped != nullptr ? std::make_optional([&]() -> std::function<void()> {
@@ -142,9 +135,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             return downcast->cthis()->getFunction();
           } else {
             auto onPoppedRef = jni::make_global(onPopped);
-            return [onPoppedRef]() -> void {
-              return onPoppedRef->invoke();
-            };
+            return JNICallable<JFunc_void, void()>(std::move(onPoppedRef));
           }
         }()) : std::nullopt,
         autoDismissMs != nullptr ? std::make_optional(autoDismissMs->value()) : std::nullopt,

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

@@ -18,6 +18,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct StringTelem
 
 #include <functional>
 #include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "Telemetry.hpp"
 #include <optional>
 #include <string>
@@ -71,9 +72,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }

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

@@ -32,6 +32,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 
 #include <functional>
 #include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "EventName.hpp"
@@ -106,9 +107,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -121,9 +120,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -136,9 +133,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -226,9 +221,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }

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

@@ -26,6 +26,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 
 #include <functional>
 #include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "ClusterEventName.hpp"
@@ -95,9 +96,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -138,9 +137,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -153,9 +150,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -168,9 +163,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }
@@ -183,9 +176,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return [__resultRef]() -> void {
-          return __resultRef->invoke();
-        };
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
       }
     }();
   }

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

@@ -46,6 +46,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include <optional>
 #include <functional>
 #include "JFunc_void_std__optional_bool_.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "JFunc_void.hpp"
 #include "NitroAction.hpp"
 #include <vector>

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

@@ -50,6 +50,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include <optional>
 #include <functional>
 #include "JFunc_void_std__optional_bool_.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "JFunc_void.hpp"
 #include "NitroAction.hpp"
 #include <vector>

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

@@ -50,6 +50,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include <optional>
 #include <functional>
 #include "JFunc_void_std__optional_bool_.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "JFunc_void.hpp"
 #include "NitroAction.hpp"
 #include <vector>

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

@@ -99,6 +99,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct TripConfig;
 #include <string>
 #include <functional>
 #include "JFunc_void_std__string.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "MapTemplateConfig.hpp"

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

@@ -42,6 +42,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include <optional>
 #include <functional>
 #include "JFunc_void_std__optional_bool_.hpp"
+#include <NitroModules/JNICallable.hpp>
 #include "JFunc_void.hpp"
 #include "NitroAction.hpp"
 #include <vector>