@iternio/react-native-auto-play 0.1.16 → 0.2.0-alpha.1

package/lib/hooks/useAndroidAutoTelemetry.js

@@ -8,8 +8,8 @@ import { HybridAndroidAutoTelemetry, HybridAutoPlay } from '..';
  * @param requestTelemetryPermissions If true, the telemetry permissions will be requested from the user. Can be set to false initially, in case other permissions need to be requested first, so the permission request dialogs do not overlap.
  * @param requiredPermissions The permissions to check.
  */
-export const useAndroidAutoTelemetry = ({ requestTelemetryPermissions = true, requiredPermissions, }) => {
-    const [permissionsGranted, setPermissionsGranted] = useState(false);
+export const useAndroidAutoTelemetry = ({ requestTelemetryPermissions = true, requiredPermissions, automotivePermissionRequest, }) => {
+    const [permissionsGranted, setPermissionsGranted] = useState(null);
     const [telemetry, setTelemetry] = useState(undefined);
     const [error, setError] = useState(undefined);
     const [isConnected, setIsConnected] = useState(false);
@@ -27,43 +27,71 @@ export const useAndroidAutoTelemetry = ({ requestTelemetryPermissions = true, re
             const state = await Promise.all(requiredPermissions.map((permission) => PermissionsAndroid.check(permission).catch(() => false)));
             setPermissionsGranted(state.every((granted) => granted));
         };
-        checkPermissions();
+        void checkPermissions();
     }, [requiredPermissions]);
     useEffect(() => {
         if (!isConnected || !permissionsGranted) {
             return;
         }
-        const remove = HybridAndroidAutoTelemetry?.registerTelemetryListener((tlm, errorMessage) => {
-            setError(errorMessage);
-            setTelemetry(tlm);
-        });
-        return () => {
-            remove?.();
-        };
+        try {
+            const remove = HybridAndroidAutoTelemetry?.registerTelemetryListener(setTelemetry);
+            return () => remove?.();
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                setError(`${e.name}: ${e.message}\n${e.stack ?? ''}`.trim());
+            }
+            else {
+                setError(String(e));
+            }
+        }
+        return;
     }, [isConnected, permissionsGranted]);
     useEffect(() => {
-        if (requestTelemetryPermissions && requiredPermissions.length > 0) {
-            // PermissionsAndroid is not aware of automotive permissions
-            PermissionsAndroid.requestMultiple(requiredPermissions)
-                .then((value) => {
-                const isGranted = requiredPermissions.every((permission) => value[permission] === 'granted');
+        if (!requestTelemetryPermissions || requiredPermissions.length === 0) {
+            return;
+        }
+        if (permissionsGranted !== false) {
+            // either wait for permission request to finish or do nothing in case permissions are granted already
+            return;
+        }
+        if (automotivePermissionRequest?.message != null) {
+            HybridAndroidAutoTelemetry?.requestAutomotivePermissions(requiredPermissions, automotivePermissionRequest.message, automotivePermissionRequest.grantButtonText, automotivePermissionRequest.cancelButtonText).then(({ granted, denied }) => {
+                const isGranted = granted.length === requiredPermissions.length;
+                setPermissionsGranted(isGranted);
                 if (!isGranted) {
-                    console.warn('*** Android Auto telemetry permissions not granted');
-                    return;
+                    setError(`Android Automotive permissions denied: [${denied.join(',')}]`);
                 }
-                setPermissionsGranted(true);
-            })
-                .catch((e) => console.error('*** Android Auto telemetry permissions error', e));
+            });
+            return;
         }
-        return;
-    }, [requestTelemetryPermissions, requiredPermissions]);
+        // PermissionsAndroid is not aware of Android Auto related permissions
+        PermissionsAndroid.requestMultiple(requiredPermissions)
+            .then((result) => {
+            const isGranted = requiredPermissions.every((permission) => result[permission] === 'granted');
+            if (!isGranted) {
+                console.warn('Android Auto telemetry permissions not granted');
+                return;
+            }
+            setPermissionsGranted(true);
+        })
+            .catch((e) => console.error('Android Auto telemetry permissions error', e));
+    }, [
+        requestTelemetryPermissions,
+        requiredPermissions,
+        permissionsGranted,
+        automotivePermissionRequest?.cancelButtonText,
+        automotivePermissionRequest?.grantButtonText,
+        automotivePermissionRequest?.message,
+    ]);
     return {
         /**
-         * True if the telemetry permissions are granted, false otherwise.
+         * null on pending permission check, True if the telemetry permissions are granted, false otherwise.
          */
         permissionsGranted,
         /**
-         * The telemetry data.
+         * The telemetry data, might be a partial update not containing all properties of the regular timed updates.
+         * For example gear changes are emitted immediately without all the other telemetry data.
          */
         telemetry,
         /**

package/lib/index.d.ts

@@ -25,12 +25,14 @@ export * from './templates/ListTemplate';
 export * from './templates/MapTemplate';
 export * from './templates/MessageTemplate';
 export * from './templates/SearchTemplate';
+export * from './templates/SignInTemplate';
 export * from './templates/Template';
 export * from './types/Button';
 export * from './types/Event';
 export * from './types/Image';
 export * from './types/Maneuver';
 export * from './types/RootComponent';
+export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';

package/lib/index.js

@@ -30,12 +30,14 @@ export * from './templates/ListTemplate';
 export * from './templates/MapTemplate';
 export * from './templates/MessageTemplate';
 export * from './templates/SearchTemplate';
+export * from './templates/SignInTemplate';
 export * from './templates/Template';
 export * from './types/Button';
 export * from './types/Event';
 export * from './types/Image';
 export * from './types/Maneuver';
 export * from './types/RootComponent';
+export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';

package/lib/specs/AndroidAutoTelemetry.nitro.d.ts

@@ -1,6 +1,10 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { CleanupCallback } from '../types/Event';
 import type { Telemetry } from '../types/Telemetry';
+type PermissionRequestResult = {
+    granted: Array<string>;
+    denied: Array<string>;
+};
 export interface AndroidAutoTelemetry extends HybridObject<{
     android: 'kotlin';
 }> {
@@ -11,5 +15,14 @@ export interface AndroidAutoTelemetry extends HybridObject<{
      * @returns callback to remove the listener
      * @namespace Android
      */
-    registerTelemetryListener(callback: (tlm?: Telemetry, error?: string) => void): CleanupCallback;
+    registerTelemetryListener(callback: (tlm?: Telemetry) => void): CleanupCallback;
+    /**
+     * Brings up a template to request specified permissions from the user
+     * @param permissions some of `AndroidAutoPermissions`
+     * @param message text shown on the template
+     * @param grantButtonText primary action button text
+     * @param cancelButtonText secondary action button text, if not specified button will not be shown
+     */
+    requestAutomotivePermissions(permissions: Array<string>, message: string, grantButtonText: string, cancelButtonText?: string): Promise<PermissionRequestResult>;
 }
+export {};

package/lib/specs/SignInTemplate.nitro.d.ts

@@ -0,0 +1,12 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { NitroSignInTemplateConfig } from '../templates/SignInTemplate';
+import type { NitroTemplateConfig } from './AutoPlay.nitro';
+interface SignInTemplateConfig extends NitroTemplateConfig, NitroSignInTemplateConfig {
+}
+export interface SignInTemplate extends HybridObject<{
+    android: 'kotlin';
+}> {
+    createSignInTemplate(config: SignInTemplateConfig): void;
+    updateTemplate(templateId: string, config: SignInTemplateConfig): Promise<void>;
+}
+export {};

package/lib/templates/SignInTemplate.d.ts

@@ -0,0 +1,49 @@
+import type { ActionButton, AppButton, BackButton, CustomActionButtonAndroid, ImageButton } from '..';
+import type { SignInTemplate as NitroSignInTemplate } from '../specs/SignInTemplate.nitro';
+import { type SignInMethod } from '../types/SignInMethod';
+import { type NitroAction } from '../utils/NitroAction';
+import { Template, type TemplateConfig } from './Template';
+export declare const HybridSignInTemplate: NitroSignInTemplate | null;
+export interface NitroSignInTemplateConfig extends TemplateConfig {
+    title?: string;
+    additionalText?: string;
+    signInMethod?: SignInMethod;
+    headerActions?: Array<NitroAction>;
+    actions?: Array<NitroAction>;
+    instructions?: string;
+}
+export type SignInHeaderActions<T> = {
+    android: {
+        startHeaderAction?: AppButton | BackButton<T>;
+        /**
+         * Actions for the sign-in template.
+         * Note: Android Auto only allows 1 action with a custom title in the action strip.
+         */
+        endHeaderActions?: [CustomActionButtonAndroid<SignInTemplate>, ImageButton<SignInTemplate>] | [ImageButton<SignInTemplate>, CustomActionButtonAndroid<SignInTemplate>] | [CustomActionButtonAndroid<SignInTemplate>];
+    };
+};
+export type SignInTemplateConfig = Omit<NitroSignInTemplateConfig, 'headerActions' | 'actions' | 'signInMethod'> & {
+    headerActions?: SignInHeaderActions<SignInTemplate>;
+    actions?: Array<ActionButton<SignInTemplate>>;
+    signInMethod: SignInMethod;
+};
+export type SignInTemplateUpdateConfig = Omit<NitroSignInTemplateConfig, 'headerActions' | 'actions'> & {
+    headerActions?: SignInHeaderActions<SignInTemplate>;
+    actions?: Array<ActionButton<SignInTemplate>>;
+};
+/**
+ * A template for signing in to an account.
+ * @namespace Android
+ */
+export declare class SignInTemplate extends Template<SignInTemplateConfig, SignInHeaderActions<SignInTemplate>> {
+    private template;
+    constructor(config: SignInTemplateConfig);
+    /**
+     * Updates the template with new config. The config is merged with the current one,
+     * so if values are not provided, they will stay. To change values, they need to be overridden.
+     *
+     * @param updatedConfig - The updated config for the template.
+     * @returns A promise that resolves when the template is updated.
+     */
+    updateTemplate(updatedConfig: SignInTemplateUpdateConfig): Promise<void> | undefined;
+}

package/lib/templates/SignInTemplate.js

@@ -0,0 +1,51 @@
+import { Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { SignInMethods } from '../types/SignInMethod';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { Template } from './Template';
+export const HybridSignInTemplate = Platform.OS === 'android'
+    ? NitroModules.createHybridObject('SignInTemplate')
+    : null;
+/**
+ * A template for signing in to an account.
+ * @namespace Android
+ */
+export class SignInTemplate extends Template {
+    template = this;
+    constructor(config) {
+        super(config);
+        const { headerActions, actions, ...rest } = config;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            actions: NitroActionUtil.convert(this.template, actions),
+        };
+        if (config.signInMethod.method === SignInMethods.PIN &&
+            (config.signInMethod.pin?.length > 12 || config.signInMethod.pin?.length < 1)) {
+            throw new Error('PIN must be 1-12 characters');
+        }
+        HybridSignInTemplate?.createSignInTemplate(nitroConfig);
+    }
+    /**
+     * Updates the template with new config. The config is merged with the current one,
+     * so if values are not provided, they will stay. To change values, they need to be overridden.
+     *
+     * @param updatedConfig - The updated config for the template.
+     * @returns A promise that resolves when the template is updated.
+     */
+    updateTemplate(updatedConfig) {
+        const { headerActions, actions, ...rest } = updatedConfig;
+        const nitroConfig = {
+            ...rest,
+            id: this.id,
+            headerActions: NitroActionUtil.convert(this.template, headerActions),
+            actions: NitroActionUtil.convert(this.template, actions),
+        };
+        if (nitroConfig.signInMethod?.method === SignInMethods.PIN &&
+            (nitroConfig.signInMethod.pin?.length > 12 || nitroConfig.signInMethod.pin?.length < 1)) {
+            throw new Error('PIN must be 1-12 characters');
+        }
+        return HybridSignInTemplate?.updateTemplate(this.id, nitroConfig);
+    }
+}

package/lib/types/SignInMethod.d.ts

@@ -0,0 +1,38 @@
+export declare enum SignInMethods {
+    QR = 0,
+    PROVIDER = 1,
+    PIN = 2,
+    INPUT = 3
+}
+export type PinSignIn = {
+    method: SignInMethods.PIN;
+    /**
+     * PIN code for sign-in. Must be 1-12 characters.
+     */
+    pin: string;
+};
+export declare enum KeyboardType {
+    DEFAULT = 0,
+    EMAIL = 1,
+    PHONE = 2,
+    NUMBER = 3
+}
+export declare enum TextInputType {
+    PASSWORD = 0,
+    DEFAULT = 1
+}
+export type InputSignIn = {
+    method: SignInMethods.INPUT;
+    keyboardType?: KeyboardType;
+    hint?: string;
+    defaultValue?: string;
+    errorMessage?: string;
+    callback: (text: string) => void;
+    showKeyboardByDefault?: boolean;
+    inputType: TextInputType;
+};
+export type QrSignIn = {
+    method: SignInMethods.QR;
+    url: string;
+};
+export type SignInMethod = QrSignIn | PinSignIn | InputSignIn;

package/lib/types/SignInMethod.js

@@ -0,0 +1,19 @@
+export var SignInMethods;
+(function (SignInMethods) {
+    SignInMethods[SignInMethods["QR"] = 0] = "QR";
+    SignInMethods[SignInMethods["PROVIDER"] = 1] = "PROVIDER";
+    SignInMethods[SignInMethods["PIN"] = 2] = "PIN";
+    SignInMethods[SignInMethods["INPUT"] = 3] = "INPUT";
+})(SignInMethods || (SignInMethods = {}));
+export var KeyboardType;
+(function (KeyboardType) {
+    KeyboardType[KeyboardType["DEFAULT"] = 0] = "DEFAULT";
+    KeyboardType[KeyboardType["EMAIL"] = 1] = "EMAIL";
+    KeyboardType[KeyboardType["PHONE"] = 2] = "PHONE";
+    KeyboardType[KeyboardType["NUMBER"] = 3] = "NUMBER";
+})(KeyboardType || (KeyboardType = {}));
+export var TextInputType;
+(function (TextInputType) {
+    TextInputType[TextInputType["PASSWORD"] = 0] = "PASSWORD";
+    TextInputType[TextInputType["DEFAULT"] = 1] = "DEFAULT";
+})(TextInputType || (TextInputType = {}));

package/lib/types/Telemetry.d.ts

@@ -30,11 +30,24 @@ type StringTelemetryItem = {
     timestamp: number;
     value: string;
 };
+type BooleanTelemetryItem = {
+    /**
+     * timestamp in seconds when the value was received on native side
+     */
+    timestamp: number;
+    value: boolean;
+};
 type VehicleTelemetryItem = {
     name?: StringTelemetryItem;
     year?: NumericTelemetryItem;
     manufacturer?: StringTelemetryItem;
 };
+export declare enum VehicleGear {
+    Neutral = 1,
+    Reverse = 2,
+    Park = 4,
+    Drive = 8
+}
 export type Telemetry = {
     /**
      * Speed in km/h
@@ -60,5 +73,19 @@ export type Telemetry = {
      * Vehicle information
      */
     vehicle?: VehicleTelemetryItem;
+    /**
+     * one of VehicleGear enum
+     */
+    selectedGear?: NumericTelemetryItem;
+    /**
+     * Outside temperature in celsius.
+     */
+    envOutsideTemperature?: NumericTelemetryItem;
+    evChargePortConnected?: BooleanTelemetryItem;
+    /**
+     * EV instantaneous charge rate in kW.
+     */
+    evBatteryInstantaneousChargeRate?: NumericTelemetryItem;
+    parkingBrakeOn?: BooleanTelemetryItem;
 };
 export {};

package/lib/types/Telemetry.js

@@ -12,3 +12,10 @@ export var AndroidAutomotiveTelemetryPermissions;
     AndroidAutomotiveTelemetryPermissions["ExteriorEnvironment"] = "android.car.permission.CAR_EXTERIOR_ENVIRONMENT";
     AndroidAutomotiveTelemetryPermissions["EnergyPorts"] = "android.car.permission.CAR_ENERGY_PORTS";
 })(AndroidAutomotiveTelemetryPermissions || (AndroidAutomotiveTelemetryPermissions = {}));
+export var VehicleGear;
+(function (VehicleGear) {
+    VehicleGear[VehicleGear["Neutral"] = 1] = "Neutral";
+    VehicleGear[VehicleGear["Reverse"] = 2] = "Reverse";
+    VehicleGear[VehicleGear["Park"] = 4] = "Park";
+    VehicleGear[VehicleGear["Drive"] = 8] = "Drive";
+})(VehicleGear || (VehicleGear = {}));

package/nitro.json

@@ -16,6 +16,9 @@
     "AndroidAutoTelemetry": {
       "kotlin": "HybridAndroidAutoTelemetry"
     },
+    "SignInTemplate": {
+      "kotlin": "HybridSignInTemplate"
+    },
     "ListTemplate": {
       "kotlin": "HybridListTemplate",
       "swift": "HybridListTemplate"

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

@@ -43,6 +43,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridMapTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridMessageTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSearchTemplateSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridSignInTemplateSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
   ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
@@ -57,6 +58,8 @@ target_sources(
   ../nitrogen/generated/android/c++/JVariant_PreferredImageLane_ImageLane.cpp
   ../nitrogen/generated/android/c++/JHybridMessageTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridSignInTemplateSpec.cpp
+  ../nitrogen/generated/android/c++/JVariant_QrSignIn_PinSignIn_InputSignIn.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -17,7 +17,7 @@
 
 #include "JHybridAndroidAutoTelemetrySpec.hpp"
 #include "JFunc_void.hpp"
-#include "JFunc_void_std__optional_Telemetry__std__optional_std__string_.hpp"
+#include "JFunc_void_std__optional_Telemetry_.hpp"
 #include "JHybridAutoPlaySpec.hpp"
 #include "JFunc_void_VisibilityState.hpp"
 #include "JFunc_void_std__optional_Location__std__optional_std__string_.hpp"
@@ -41,6 +41,7 @@
 #include "JFunc_void_std__string_std__string.hpp"
 #include "JHybridMessageTemplateSpec.hpp"
 #include "JHybridSearchTemplateSpec.hpp"
+#include "JHybridSignInTemplateSpec.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -54,7 +55,7 @@ int initialize(JavaVM* vm) {
     // Register native JNI methods
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidAutoTelemetrySpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_cxx::registerNatives();
-    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_Telemetry__cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAutoPlaySpec::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();
@@ -78,6 +79,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__string_std__string_cxx::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridMessageTemplateSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSearchTemplateSpec::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSignInTemplateSpec::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
@@ -96,6 +98,14 @@ int initialize(JavaVM* vm) {
         return instance->cthis()->shared();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "SignInTemplate",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridSignInTemplateSpec::javaobject> object("com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridSignInTemplate");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "ListTemplate",
       []() -> std::shared_ptr<HybridObject> {

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

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

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

@@ -0,0 +1,87 @@
+///
+/// JFunc_void_std__optional_Telemetry_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "Telemetry.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTelemetry.hpp"
+#include "NumericTelemetryItem.hpp"
+#include "JNumericTelemetryItem.hpp"
+#include "VehicleTelemetryItem.hpp"
+#include "JVehicleTelemetryItem.hpp"
+#include "StringTelemetryItem.hpp"
+#include "JStringTelemetryItem.hpp"
+#include <string>
+#include "BooleanTelemetryItem.hpp"
+#include "JBooleanTelemetryItem.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(tlm: Telemetry?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_Telemetry_: public jni::JavaClass<JFunc_void_std__optional_Telemetry_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_std__optional_Telemetry_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_Telemetry_` instance holds through JNI.
+     */
+    void invoke(const std::optional<Telemetry>& tlm) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JTelemetry> /* tlm */)>("invoke");
+      method(self(), tlm.has_value() ? JTelemetry::fromCpp(tlm.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_Telemetry_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__optional_Telemetry__cxx final: public jni::HybridClass<JFunc_void_std__optional_Telemetry__cxx, JFunc_void_std__optional_Telemetry_> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_Telemetry_::javaobject> fromCpp(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& func) {
+      return JFunc_void_std__optional_Telemetry__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_Telemetry__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JTelemetry> tlm) {
+      _func(tlm != nullptr ? std::make_optional(tlm->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<Telemetry>& /* tlm */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_std__optional_Telemetry__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_Telemetry__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_Telemetry__cxx(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<Telemetry>& /* tlm */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay