@iternio/react-native-auto-play 0.2.0-alpha.4 → 0.2.0-alpha.7

package/lib/specs/AutomotivePermissionRequestTemplate.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/templates/AutomotivePermissionRequestTemplate.d.ts

@@ -0,0 +1,23 @@
+import type { CustomActionButtonAndroid } from '../types/Button';
+import type { AutoText } from '../types/Text';
+import { type NitroAction } from '../utils/NitroAction';
+import { type HeaderActions, Template, type TemplateConfig } from './Template';
+export interface NitroAutomotivePermissionRequestTemplateConfig extends TemplateConfig {
+    headerActions?: Array<NitroAction>;
+    title: AutoText;
+    actions: Array<NitroAction>;
+}
+export type AutomotivePermissionRequestTemplateConfig = Omit<NitroAutomotivePermissionRequestTemplateConfig, 'headerActions' | 'buttons'> & {
+    /**
+     * action buttons, usually at the the top right on Android and a top bar on iOS
+     */
+    headerActions?: HeaderActions<AutomotivePermissionRequestTemplate>;
+    actions: [CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>] | [
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>,
+        CustomActionButtonAndroid<AutomotivePermissionRequestTemplate>
+    ];
+};
+export declare class AutomotivePermissionRequestTemplate extends Template<AutomotivePermissionRequestTemplateConfig, HeaderActions<AutomotivePermissionRequestTemplate>> {
+    private template;
+    constructor(config: AutomotivePermissionRequestTemplateConfig);
+}

package/lib/templates/AutomotivePermissionRequestTemplate.js

@@ -0,0 +1,18 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { NitroActionUtil } from '../utils/NitroAction';
+import { Template, } from './Template';
+const HybridAutomotivePermissionRequestTemplate = NitroModules.createHybridObject('AutomotivePermissionRequestTemplate');
+export class AutomotivePermissionRequestTemplate 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),
+        };
+        HybridAutomotivePermissionRequestTemplate.createAutomotivePermissionRequestTemplate(nitroConfig);
+    }
+}

package/lib/types/SignInMethod.d.ts

@@ -18,6 +18,7 @@ export type GoogleSignIn = {
     method: SignInMethods.GOOGLE;
     serverClientId: string;
     callback: (error?: string, signInAccount?: GoogleSignInAccount) => void;
+    signInButtonText: string;
 };
 export type PinSignIn = {
     method: SignInMethods.PIN;

package/nitro.json

@@ -16,6 +16,9 @@
     "AndroidAutoTelemetry": {
       "kotlin": "HybridAndroidAutoTelemetry"
     },
+    "AndroidAutomotive": {
+      "kotlin": "HybridAndroidAutomotive"
+    },
     "SignInTemplate": {
       "kotlin": "HybridSignInTemplate"
     },

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

@@ -33,6 +33,7 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp
   # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/shared/c++/HybridAndroidAutoTelemetrySpec.cpp
   ../nitrogen/generated/shared/c++/HybridAutoPlaySpec.cpp
   ../nitrogen/generated/shared/c++/HybridCarPlayDashboardSpec.cpp
@@ -45,6 +46,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridSearchTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSignInTemplateSpec.cpp
   # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
   ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
   ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage.cpp

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -15,8 +15,11 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
-#include "JHybridAndroidAutoTelemetrySpec.hpp"
+#include "JHybridAndroidAutomotiveSpec.hpp"
 #include "JFunc_void.hpp"
+#include "JFunc_void_ActiveCarUxRestrictions.hpp"
+#include "JFunc_void_AppFocusState.hpp"
+#include "JHybridAndroidAutoTelemetrySpec.hpp"
 #include "JFunc_void_std__optional_Telemetry_.hpp"
 #include "JHybridAutoPlaySpec.hpp"
 #include "JFunc_void_VisibilityState.hpp"
@@ -54,8 +57,11 @@ int initialize(JavaVM* vm) {
 
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
-    margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidAutoTelemetrySpec::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidAutomotiveSpec::registerNatives();
     margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_cxx::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_ActiveCarUxRestrictions_cxx::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_AppFocusState_cxx::registerNatives();
+    margelo::nitro::swe::iternio::reactnativeautoplay::JHybridAndroidAutoTelemetrySpec::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();
@@ -100,6 +106,14 @@ int initialize(JavaVM* vm) {
         return instance->cthis()->shared();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "AndroidAutomotive",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridAndroidAutomotiveSpec::javaobject> object("com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAndroidAutomotive");
+        auto instance = object.create();
+        return instance->cthis()->shared();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "SignInTemplate",
       []() -> std::shared_ptr<HybridObject> {

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

@@ -0,0 +1,89 @@
+///
+/// JActiveCarUxRestrictions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ActiveCarUxRestrictions.hpp"
+
+#include "CarUxRestrictions.hpp"
+#include "JCarUxRestrictions.hpp"
+#include <vector>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ActiveCarUxRestrictions" and the the Kotlin data class "ActiveCarUxRestrictions".
+   */
+  struct JActiveCarUxRestrictions final: public jni::JavaClass<JActiveCarUxRestrictions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/ActiveCarUxRestrictions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ActiveCarUxRestrictions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ActiveCarUxRestrictions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMaxContentDepth = clazz->getField<double>("maxContentDepth");
+      double maxContentDepth = this->getFieldValue(fieldMaxContentDepth);
+      static const auto fieldMaxCumulativeContentItems = clazz->getField<double>("maxCumulativeContentItems");
+      double maxCumulativeContentItems = this->getFieldValue(fieldMaxCumulativeContentItems);
+      static const auto fieldMaxRestrictedStringLength = clazz->getField<double>("maxRestrictedStringLength");
+      double maxRestrictedStringLength = this->getFieldValue(fieldMaxRestrictedStringLength);
+      static const auto fieldActiveRestrictions = clazz->getField<jni::JArrayClass<JCarUxRestrictions>>("activeRestrictions");
+      jni::local_ref<jni::JArrayClass<JCarUxRestrictions>> activeRestrictions = this->getFieldValue(fieldActiveRestrictions);
+      return ActiveCarUxRestrictions(
+        maxContentDepth,
+        maxCumulativeContentItems,
+        maxRestrictedStringLength,
+        [&]() {
+          size_t __size = activeRestrictions->size();
+          std::vector<CarUxRestrictions> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = activeRestrictions->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JActiveCarUxRestrictions::javaobject> fromCpp(const ActiveCarUxRestrictions& value) {
+      using JSignature = JActiveCarUxRestrictions(double, double, double, jni::alias_ref<jni::JArrayClass<JCarUxRestrictions>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.maxContentDepth,
+        value.maxCumulativeContentItems,
+        value.maxRestrictedStringLength,
+        [&]() {
+          size_t __size = value.activeRestrictions.size();
+          jni::local_ref<jni::JArrayClass<JCarUxRestrictions>> __array = jni::JArrayClass<JCarUxRestrictions>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.activeRestrictions[__i];
+            auto __elementJni = JCarUxRestrictions::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

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

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

@@ -0,0 +1,82 @@
+///
+/// JCarUxRestrictions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "CarUxRestrictions.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "CarUxRestrictions" and the the Kotlin enum "CarUxRestrictions".
+   */
+  struct JCarUxRestrictions final: public jni::JavaClass<JCarUxRestrictions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/CarUxRestrictions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum CarUxRestrictions.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CarUxRestrictions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<CarUxRestrictions>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JCarUxRestrictions> fromCpp(CarUxRestrictions value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case CarUxRestrictions::UX_RESTRICTIONS_FULLY_RESTRICTED:
+          static const auto fieldUX_RESTRICTIONS_FULLY_RESTRICTED = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_FULLY_RESTRICTED");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_FULLY_RESTRICTED);
+        case CarUxRestrictions::UX_RESTRICTIONS_LIMIT_CONTENT:
+          static const auto fieldUX_RESTRICTIONS_LIMIT_CONTENT = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_LIMIT_CONTENT");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_LIMIT_CONTENT);
+        case CarUxRestrictions::UX_RESTRICTIONS_LIMIT_STRING_LENGTH:
+          static const auto fieldUX_RESTRICTIONS_LIMIT_STRING_LENGTH = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_LIMIT_STRING_LENGTH");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_LIMIT_STRING_LENGTH);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_DIALPAD:
+          static const auto fieldUX_RESTRICTIONS_NO_DIALPAD = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_DIALPAD");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_DIALPAD);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_FILTERING:
+          static const auto fieldUX_RESTRICTIONS_NO_FILTERING = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_FILTERING");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_FILTERING);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_KEYBOARD:
+          static const auto fieldUX_RESTRICTIONS_NO_KEYBOARD = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_KEYBOARD");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_KEYBOARD);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_SETUP:
+          static const auto fieldUX_RESTRICTIONS_NO_SETUP = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_SETUP");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_SETUP);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_TEXT_MESSAGE:
+          static const auto fieldUX_RESTRICTIONS_NO_TEXT_MESSAGE = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_TEXT_MESSAGE");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_TEXT_MESSAGE);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_VIDEO:
+          static const auto fieldUX_RESTRICTIONS_NO_VIDEO = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_VIDEO");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_VIDEO);
+        case CarUxRestrictions::UX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION:
+          static const auto fieldUX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION = clazz->getStaticField<JCarUxRestrictions>("UX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION");
+          return clazz->getStaticFieldValue(fieldUX_RESTRICTIONS_NO_VOICE_TRANSCRIPTION);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_ActiveCarUxRestrictions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "ActiveCarUxRestrictions.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JActiveCarUxRestrictions.hpp"
+#include "CarUxRestrictions.hpp"
+#include <vector>
+#include "JCarUxRestrictions.hpp"
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(restrictions: ActiveCarUxRestrictions) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_ActiveCarUxRestrictions: public jni::JavaClass<JFunc_void_ActiveCarUxRestrictions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_ActiveCarUxRestrictions;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_ActiveCarUxRestrictions` instance holds through JNI.
+     */
+    void invoke(const ActiveCarUxRestrictions& restrictions) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JActiveCarUxRestrictions> /* restrictions */)>("invoke");
+      method(self(), JActiveCarUxRestrictions::fromCpp(restrictions));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_ActiveCarUxRestrictions that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_ActiveCarUxRestrictions_cxx final: public jni::HybridClass<JFunc_void_ActiveCarUxRestrictions_cxx, JFunc_void_ActiveCarUxRestrictions> {
+  public:
+    static jni::local_ref<JFunc_void_ActiveCarUxRestrictions::javaobject> fromCpp(const std::function<void(const ActiveCarUxRestrictions& /* restrictions */)>& func) {
+      return JFunc_void_ActiveCarUxRestrictions_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_ActiveCarUxRestrictions_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JActiveCarUxRestrictions> restrictions) {
+      _func(restrictions->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const ActiveCarUxRestrictions& /* restrictions */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_ActiveCarUxRestrictions_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_ActiveCarUxRestrictions_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_ActiveCarUxRestrictions_cxx(const std::function<void(const ActiveCarUxRestrictions& /* restrictions */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const ActiveCarUxRestrictions& /* restrictions */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_AppFocusState.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "AppFocusState.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JAppFocusState.hpp"
+#include <optional>
+
+namespace margelo::nitro::swe::iternio::reactnativeautoplay {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(state: AppFocusState) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_AppFocusState: public jni::JavaClass<JFunc_void_AppFocusState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_AppFocusState;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_AppFocusState` instance holds through JNI.
+     */
+    void invoke(const AppFocusState& state) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAppFocusState> /* state */)>("invoke");
+      method(self(), JAppFocusState::fromCpp(state));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_AppFocusState that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_AppFocusState_cxx final: public jni::HybridClass<JFunc_void_AppFocusState_cxx, JFunc_void_AppFocusState> {
+  public:
+    static jni::local_ref<JFunc_void_AppFocusState::javaobject> fromCpp(const std::function<void(const AppFocusState& /* state */)>& func) {
+      return JFunc_void_AppFocusState_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_AppFocusState_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JAppFocusState> state) {
+      _func(state->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const AppFocusState& /* state */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/Func_void_AppFocusState_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_AppFocusState_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_AppFocusState_cxx(const std::function<void(const AppFocusState& /* state */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const AppFocusState& /* state */)> _func;
+  };
+
+} // namespace margelo::nitro::swe::iternio::reactnativeautoplay

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

@@ -45,6 +45,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       jni::local_ref<jni::JString> serverClientId = this->getFieldValue(fieldServerClientId);
       static const auto fieldCallback = clazz->getField<JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_::javaobject>("callback");
       jni::local_ref<JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_::javaobject> callback = this->getFieldValue(fieldCallback);
+      static const auto fieldSignInButtonText = clazz->getField<jni::JString>("signInButtonText");
+      jni::local_ref<jni::JString> signInButtonText = this->getFieldValue(fieldSignInButtonText);
       return GoogleSignIn(
         method->toCpp(),
         serverClientId->toStdString(),
@@ -56,7 +58,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
             auto callbackRef = jni::make_global(callback);
             return JNICallable<JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_, void(std::optional<std::string>, std::optional<GoogleSignInAccount>)>(std::move(callbackRef));
           }
-        }()
+        }(),
+        signInButtonText->toStdString()
       );
     }
 
@@ -66,14 +69,15 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
      */
     [[maybe_unused]]
     static jni::local_ref<JGoogleSignIn::javaobject> fromCpp(const GoogleSignIn& value) {
-      using JSignature = JGoogleSignIn(jni::alias_ref<JSignInMethods>, jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_::javaobject>);
+      using JSignature = JGoogleSignIn(jni::alias_ref<JSignInMethods>, jni::alias_ref<jni::JString>, jni::alias_ref<JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_::javaobject>, jni::alias_ref<jni::JString>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         JSignInMethods::fromCpp(value.method),
         jni::make_jstring(value.serverClientId),
-        JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount__cxx::fromCpp(value.callback)
+        JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount__cxx::fromCpp(value.callback),
+        jni::make_jstring(value.signInButtonText)
       );
     }
   };