@iternio/react-native-auto-play 0.1.18 → 0.2.0-alpha.2

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/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

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

@@ -19,7 +19,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   using namespace facebook;
 
   /**
-   * Represents the Java/Kotlin callback `(searchText: String) -> Unit`.
+   * Represents the Java/Kotlin callback `(text: String) -> Unit`.
    * This can be passed around between C++ and Java/Kotlin.
    */
   struct JFunc_void_std__string: public jni::JavaClass<JFunc_void_std__string> {
@@ -30,9 +30,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     /**
      * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
      */
-    void invoke(const std::string& searchText) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* searchText */)>("invoke");
-      method(self(), jni::make_jstring(searchText));
+    void invoke(const std::string& text) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* text */)>("invoke");
+      method(self(), jni::make_jstring(text));
     }
   };
 
@@ -41,7 +41,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
    */
   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) {
+    static jni::local_ref<JFunc_void_std__string::javaobject> fromCpp(const std::function<void(const std::string& /* text */)>& func) {
       return JFunc_void_std__string_cxx::newObjectCxxArgs(func);
     }
 
@@ -49,13 +49,13 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     /**
      * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_cxx` instance holds.
      */
-    void invoke_cxx(jni::alias_ref<jni::JString> searchText) {
-      _func(searchText->toStdString());
+    void invoke_cxx(jni::alias_ref<jni::JString> text) {
+      _func(text->toStdString());
     }
 
   public:
     [[nodiscard]]
-    inline const std::function<void(const std::string& /* searchText */)>& getFunction() const {
+    inline const std::function<void(const std::string& /* text */)>& getFunction() const {
       return _func;
     }
 
@@ -66,11 +66,11 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     }
 
   private:
-    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* searchText */)>& func): _func(func) { }
+    explicit JFunc_void_std__string_cxx(const std::function<void(const std::string& /* text */)>& func): _func(func) { }
 
   private:
     friend HybridBase;
-    std::function<void(const std::string& /* searchText */)> _func;
+    std::function<void(const std::string& /* text */)> _func;
   };
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -7,6 +7,8 @@
 
 #include "JHybridAndroidAutoTelemetrySpec.hpp"
 
+// Forward declaration of `PermissionRequestResult` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct PermissionRequestResult; }
 // Forward declaration of `Telemetry` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct Telemetry; }
 // Forward declaration of `NumericTelemetryItem` to properly resolve imports.
@@ -15,14 +17,21 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NumericTele
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VehicleTelemetryItem; }
 // Forward declaration of `StringTelemetryItem` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct StringTelemetryItem; }
+// Forward declaration of `BooleanTelemetryItem` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct BooleanTelemetryItem; }
 
 #include <functional>
 #include "JFunc_void.hpp"
 #include <NitroModules/JNICallable.hpp>
+#include "PermissionRequestResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JPermissionRequestResult.hpp"
+#include <string>
+#include <vector>
 #include "Telemetry.hpp"
 #include <optional>
-#include <string>
-#include "JFunc_void_std__optional_Telemetry__std__optional_std__string_.hpp"
+#include "JFunc_void_std__optional_Telemetry_.hpp"
 #include "JTelemetry.hpp"
 #include "NumericTelemetryItem.hpp"
 #include "JNumericTelemetryItem.hpp"
@@ -30,6 +39,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct StringTelem
 #include "JVehicleTelemetryItem.hpp"
 #include "StringTelemetryItem.hpp"
 #include "JStringTelemetryItem.hpp"
+#include "BooleanTelemetryItem.hpp"
+#include "JBooleanTelemetryItem.hpp"
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
@@ -63,9 +74,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   
 
   // Methods
-  std::function<void()> JHybridAndroidAutoTelemetrySpec::registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */, const std::optional<std::string>& /* error */)>& callback) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_Telemetry__std__optional_std__string_::javaobject> /* callback */)>("registerTelemetryListener_cxx");
-    auto __result = method(_javaPart, JFunc_void_std__optional_Telemetry__std__optional_std__string__cxx::fromCpp(callback));
+  std::function<void()> JHybridAndroidAutoTelemetrySpec::registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_Telemetry_::javaobject> /* callback */)>("registerTelemetryListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_Telemetry__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);
@@ -76,5 +87,30 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       }
     }();
   }
+  std::shared_ptr<Promise<PermissionRequestResult>> JHybridAndroidAutoTelemetrySpec::requestAutomotivePermissions(const std::vector<std::string>& permissions, const std::string& message, const std::string& grantButtonText, const std::optional<std::string>& cancelButtonText) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* permissions */, jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* grantButtonText */, jni::alias_ref<jni::JString> /* cancelButtonText */)>("requestAutomotivePermissions");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = permissions.size();
+      jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = permissions[__i];
+        auto __elementJni = jni::make_jstring(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(), jni::make_jstring(message), jni::make_jstring(grantButtonText), cancelButtonText.has_value() ? jni::make_jstring(cancelButtonText.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<PermissionRequestResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionRequestResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -54,7 +54,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
 
   public:
     // Methods
-    std::function<void()> registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */, const std::optional<std::string>& /* error */)>& callback) override;
+    std::function<void()> registerTelemetryListener(const std::function<void(const std::optional<Telemetry>& /* tlm */)>& callback) override;
+    std::shared_ptr<Promise<PermissionRequestResult>> requestAutomotivePermissions(const std::vector<std::string>& permissions, const std::string& message, const std::string& grantButtonText, const std::optional<std::string>& cancelButtonText) override;
 
   private:
     friend HybridBase;