@onekeyfe/react-native-device-utils 6.7.0-2 → 6.7.0-21

package/lib/typescript/src/ReactNativeDeviceUtils.nitro.d.ts

@@ -9,6 +9,35 @@ export interface DualScreenInfoRect {
     width: number;
     height: number;
 }
+/**
+ * Extra room, in points beyond the safe area, that content near the window
+ * corners must leave for system window controls (the iPadOS window controls in
+ * the top-leading corner, for example). All zero when no controls are shown.
+ */
+export interface WindowControlsInsets {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+/** App commands in the iPadOS menu bar that JS performs. */
+export type MainMenuCommand = 'about' | 'preferences' | 'lockNow';
+export interface MainMenuLink {
+    title: string;
+    url: string;
+}
+/**
+ * Localized content of the custom main menu (the iPadOS menu bar). Help links
+ * open in the system browser natively; the other items notify JS. An empty
+ * `aboutTitle` removes the About item and empty `helpLinks` remove the Help
+ * menu.
+ */
+export interface MainMenuConfig {
+    aboutTitle: string;
+    preferencesTitle: string;
+    lockNowTitle: string;
+    helpLinks: MainMenuLink[];
+}
 export interface LaunchOptions {
     launchType: string;
     deepLink?: string;
@@ -43,6 +72,23 @@ export interface ReactNativeDeviceUtils extends HybridObject<{
     addSpanningChangedListener(callback: (isSpanning: boolean) => void): number;
     removeSpanningChangedListener(id: number): void;
     setUserInterfaceStyle(style: UserInterfaceStyle): void;
+    /**
+     * Window-controls insets of the app's main window, for content that adapts
+     * horizontally (a header row beside the controls). iOS 26+ reads UIKit's
+     * safe area with horizontal corner adaptation; Android and older iOS return
+     * all zeros. Listeners fire on the main thread when the value changes.
+     */
+    getWindowControlsInsets(): WindowControlsInsets;
+    addWindowControlsInsetsChangedListener(callback: (insets: WindowControlsInsets) => void): number;
+    removeWindowControlsInsetsChangedListener(id: number): void;
+    /**
+     * Replaces the custom main menu content and rebuilds the menu bar. The menu
+     * only shows on iPadOS (and in windows with a menu bar); Android ignores it.
+     */
+    setMainMenuConfig(config: MainMenuConfig): void;
+    /** Listeners fire on the main thread when the user picks an app command. */
+    addMainMenuCommandListener(callback: (command: MainMenuCommand) => void): number;
+    removeMainMenuCommandListener(id: number): void;
     getLaunchOptions(): Promise<LaunchOptions>;
     clearLaunchOptions(): Promise<boolean>;
     getDeviceToken(): Promise<string>;

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_MainMenuCommand.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 "MainMenuCommand.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JMainMenuCommand.hpp"
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(command: MainMenuCommand) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_MainMenuCommand: public jni::JavaClass<JFunc_void_MainMenuCommand> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/Func_void_MainMenuCommand;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_MainMenuCommand` instance holds through JNI.
+     */
+    void invoke(MainMenuCommand command) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JMainMenuCommand> /* command */)>("invoke");
+      method(self(), JMainMenuCommand::fromCpp(command));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_MainMenuCommand that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_MainMenuCommand_cxx final: public jni::HybridClass<JFunc_void_MainMenuCommand_cxx, JFunc_void_MainMenuCommand> {
+  public:
+    static jni::local_ref<JFunc_void_MainMenuCommand::javaobject> fromCpp(const std::function<void(MainMenuCommand /* command */)>& func) {
+      return JFunc_void_MainMenuCommand_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_MainMenuCommand_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JMainMenuCommand> command) {
+      _func(command->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(MainMenuCommand /* command */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/Func_void_MainMenuCommand_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_MainMenuCommand_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_MainMenuCommand_cxx(const std::function<void(MainMenuCommand /* command */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(MainMenuCommand /* command */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_WindowControlsInsets.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 "WindowControlsInsets.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JWindowControlsInsets.hpp"
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(insets: WindowControlsInsets) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_WindowControlsInsets: public jni::JavaClass<JFunc_void_WindowControlsInsets> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/Func_void_WindowControlsInsets;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_WindowControlsInsets` instance holds through JNI.
+     */
+    void invoke(const WindowControlsInsets& insets) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JWindowControlsInsets> /* insets */)>("invoke");
+      method(self(), JWindowControlsInsets::fromCpp(insets));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_WindowControlsInsets that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_WindowControlsInsets_cxx final: public jni::HybridClass<JFunc_void_WindowControlsInsets_cxx, JFunc_void_WindowControlsInsets> {
+  public:
+    static jni::local_ref<JFunc_void_WindowControlsInsets::javaobject> fromCpp(const std::function<void(const WindowControlsInsets& /* insets */)>& func) {
+      return JFunc_void_WindowControlsInsets_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_WindowControlsInsets_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JWindowControlsInsets> insets) {
+      _func(insets->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const WindowControlsInsets& /* insets */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/Func_void_WindowControlsInsets_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_WindowControlsInsets_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_WindowControlsInsets_cxx(const std::function<void(const WindowControlsInsets& /* insets */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const WindowControlsInsets& /* insets */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

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

@@ -9,6 +9,8 @@
 
 // Forward declaration of `DualScreenInfoRect` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { struct DualScreenInfoRect; }
+// Forward declaration of `WindowControlsInsets` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct WindowControlsInsets; }
 // Forward declaration of `LaunchOptions` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { struct LaunchOptions; }
 // Forward declaration of `WebViewPackageInfo` to properly resolve imports.
@@ -21,12 +23,20 @@ namespace margelo::nitro::reactnativedeviceutils { enum class AndroidChannel; }
 namespace margelo::nitro::reactnativedeviceutils { enum class InstallerPackageName; }
 // Forward declaration of `UserInterfaceStyle` to properly resolve imports.
 namespace margelo::nitro::reactnativedeviceutils { enum class UserInterfaceStyle; }
+// Forward declaration of `MainMenuConfig` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct MainMenuConfig; }
+// Forward declaration of `MainMenuLink` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { struct MainMenuLink; }
+// Forward declaration of `MainMenuCommand` to properly resolve imports.
+namespace margelo::nitro::reactnativedeviceutils { enum class MainMenuCommand; }
 
 #include "DualScreenInfoRect.hpp"
 #include <vector>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JDualScreenInfoRect.hpp"
+#include "WindowControlsInsets.hpp"
+#include "JWindowControlsInsets.hpp"
 #include "LaunchOptions.hpp"
 #include "JLaunchOptions.hpp"
 #include <string>
@@ -47,6 +57,14 @@ namespace margelo::nitro::reactnativedeviceutils { enum class UserInterfaceStyle
 #include <NitroModules/JNICallable.hpp>
 #include "UserInterfaceStyle.hpp"
 #include "JUserInterfaceStyle.hpp"
+#include "JFunc_void_WindowControlsInsets.hpp"
+#include "MainMenuConfig.hpp"
+#include "JMainMenuConfig.hpp"
+#include "MainMenuLink.hpp"
+#include "JMainMenuLink.hpp"
+#include "MainMenuCommand.hpp"
+#include "JFunc_void_MainMenuCommand.hpp"
+#include "JMainMenuCommand.hpp"
 
 namespace margelo::nitro::reactnativedeviceutils {
 
@@ -157,6 +175,33 @@ namespace margelo::nitro::reactnativedeviceutils {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JUserInterfaceStyle> /* style */)>("setUserInterfaceStyle");
     method(_javaPart, JUserInterfaceStyle::fromCpp(style));
   }
+  WindowControlsInsets JHybridReactNativeDeviceUtilsSpec::getWindowControlsInsets() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JWindowControlsInsets>()>("getWindowControlsInsets");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  double JHybridReactNativeDeviceUtilsSpec::addWindowControlsInsetsChangedListener(const std::function<void(const WindowControlsInsets& /* insets */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_WindowControlsInsets::javaobject> /* callback */)>("addWindowControlsInsetsChangedListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_WindowControlsInsets_cxx::fromCpp(callback));
+    return __result;
+  }
+  void JHybridReactNativeDeviceUtilsSpec::removeWindowControlsInsetsChangedListener(double id) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* id */)>("removeWindowControlsInsetsChangedListener");
+    method(_javaPart, id);
+  }
+  void JHybridReactNativeDeviceUtilsSpec::setMainMenuConfig(const MainMenuConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JMainMenuConfig> /* config */)>("setMainMenuConfig");
+    method(_javaPart, JMainMenuConfig::fromCpp(config));
+  }
+  double JHybridReactNativeDeviceUtilsSpec::addMainMenuCommandListener(const std::function<void(MainMenuCommand /* command */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_MainMenuCommand::javaobject> /* callback */)>("addMainMenuCommandListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_MainMenuCommand_cxx::fromCpp(callback));
+    return __result;
+  }
+  void JHybridReactNativeDeviceUtilsSpec::removeMainMenuCommandListener(double id) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* id */)>("removeMainMenuCommandListener");
+    method(_javaPart, id);
+  }
   std::shared_ptr<Promise<LaunchOptions>> JHybridReactNativeDeviceUtilsSpec::getLaunchOptions() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getLaunchOptions");
     auto __result = method(_javaPart);

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

@@ -64,6 +64,12 @@ namespace margelo::nitro::reactnativedeviceutils {
     double addSpanningChangedListener(const std::function<void(bool /* isSpanning */)>& callback) override;
     void removeSpanningChangedListener(double id) override;
     void setUserInterfaceStyle(UserInterfaceStyle style) override;
+    WindowControlsInsets getWindowControlsInsets() override;
+    double addWindowControlsInsetsChangedListener(const std::function<void(const WindowControlsInsets& /* insets */)>& callback) override;
+    void removeWindowControlsInsetsChangedListener(double id) override;
+    void setMainMenuConfig(const MainMenuConfig& config) override;
+    double addMainMenuCommandListener(const std::function<void(MainMenuCommand /* command */)>& callback) override;
+    void removeMainMenuCommandListener(double id) override;
     std::shared_ptr<Promise<LaunchOptions>> getLaunchOptions() override;
     std::shared_ptr<Promise<bool>> clearLaunchOptions() override;
     std::shared_ptr<Promise<std::string>> getDeviceToken() override;

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

@@ -0,0 +1,61 @@
+///
+/// JMainMenuCommand.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 "MainMenuCommand.hpp"
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "MainMenuCommand" and the Kotlin enum "MainMenuCommand".
+   */
+  struct JMainMenuCommand final: public jni::JavaClass<JMainMenuCommand> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/MainMenuCommand;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum MainMenuCommand.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MainMenuCommand toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<MainMenuCommand>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JMainMenuCommand> fromCpp(MainMenuCommand value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case MainMenuCommand::ABOUT:
+          static const auto fieldABOUT = clazz->getStaticField<JMainMenuCommand>("ABOUT");
+          return clazz->getStaticFieldValue(fieldABOUT);
+        case MainMenuCommand::PREFERENCES:
+          static const auto fieldPREFERENCES = clazz->getStaticField<JMainMenuCommand>("PREFERENCES");
+          return clazz->getStaticFieldValue(fieldPREFERENCES);
+        case MainMenuCommand::LOCKNOW:
+          static const auto fieldLOCKNOW = clazz->getStaticField<JMainMenuCommand>("LOCKNOW");
+          return clazz->getStaticFieldValue(fieldLOCKNOW);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

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

@@ -0,0 +1,90 @@
+///
+/// JMainMenuConfig.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 "MainMenuConfig.hpp"
+
+#include "JMainMenuLink.hpp"
+#include "MainMenuLink.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MainMenuConfig" and the Kotlin data class "MainMenuConfig".
+   */
+  struct JMainMenuConfig final: public jni::JavaClass<JMainMenuConfig> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/MainMenuConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MainMenuConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MainMenuConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAboutTitle = clazz->getField<jni::JString>("aboutTitle");
+      jni::local_ref<jni::JString> aboutTitle = this->getFieldValue(fieldAboutTitle);
+      static const auto fieldPreferencesTitle = clazz->getField<jni::JString>("preferencesTitle");
+      jni::local_ref<jni::JString> preferencesTitle = this->getFieldValue(fieldPreferencesTitle);
+      static const auto fieldLockNowTitle = clazz->getField<jni::JString>("lockNowTitle");
+      jni::local_ref<jni::JString> lockNowTitle = this->getFieldValue(fieldLockNowTitle);
+      static const auto fieldHelpLinks = clazz->getField<jni::JArrayClass<JMainMenuLink>>("helpLinks");
+      jni::local_ref<jni::JArrayClass<JMainMenuLink>> helpLinks = this->getFieldValue(fieldHelpLinks);
+      return MainMenuConfig(
+        aboutTitle->toStdString(),
+        preferencesTitle->toStdString(),
+        lockNowTitle->toStdString(),
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<MainMenuLink> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(helpLinks)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMainMenuConfig::javaobject> fromCpp(const MainMenuConfig& value) {
+      using JSignature = JMainMenuConfig(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayClass<JMainMenuLink>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.aboutTitle),
+        jni::make_jstring(value.preferencesTitle),
+        jni::make_jstring(value.lockNowTitle),
+        [&](auto&& __input) {
+          size_t __size = __input.size();
+          jni::local_ref<jni::JArrayClass<JMainMenuLink>> __array = jni::JArrayClass<JMainMenuLink>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = __input[__i];
+            auto __elementJni = JMainMenuLink::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.helpLinks)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

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

@@ -0,0 +1,61 @@
+///
+/// JMainMenuLink.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 "MainMenuLink.hpp"
+
+#include <string>
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MainMenuLink" and the Kotlin data class "MainMenuLink".
+   */
+  struct JMainMenuLink final: public jni::JavaClass<JMainMenuLink> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/MainMenuLink;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MainMenuLink by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MainMenuLink toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTitle = clazz->getField<jni::JString>("title");
+      jni::local_ref<jni::JString> title = this->getFieldValue(fieldTitle);
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      return MainMenuLink(
+        title->toStdString(),
+        url->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JMainMenuLink::javaobject> fromCpp(const MainMenuLink& value) {
+      using JSignature = JMainMenuLink(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.title),
+        jni::make_jstring(value.url)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

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

@@ -0,0 +1,69 @@
+///
+/// JWindowControlsInsets.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 "WindowControlsInsets.hpp"
+
+
+
+namespace margelo::nitro::reactnativedeviceutils {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "WindowControlsInsets" and the Kotlin data class "WindowControlsInsets".
+   */
+  struct JWindowControlsInsets final: public jni::JavaClass<JWindowControlsInsets> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/reactnativedeviceutils/WindowControlsInsets;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct WindowControlsInsets by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    WindowControlsInsets toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTop = clazz->getField<double>("top");
+      double top = this->getFieldValue(fieldTop);
+      static const auto fieldLeft = clazz->getField<double>("left");
+      double left = this->getFieldValue(fieldLeft);
+      static const auto fieldBottom = clazz->getField<double>("bottom");
+      double bottom = this->getFieldValue(fieldBottom);
+      static const auto fieldRight = clazz->getField<double>("right");
+      double right = this->getFieldValue(fieldRight);
+      return WindowControlsInsets(
+        top,
+        left,
+        bottom,
+        right
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JWindowControlsInsets::javaobject> fromCpp(const WindowControlsInsets& value) {
+      using JSignature = JWindowControlsInsets(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.top,
+        value.left,
+        value.bottom,
+        value.right
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativedeviceutils

package/nitrogen/generated/android/kotlin/com/margelo/nitro/reactnativedeviceutils/Func_void_MainMenuCommand.kt

@@ -0,0 +1,78 @@
+///
+/// Func_void_MainMenuCommand.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.reactnativedeviceutils
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript callback `(command: enum) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_MainMenuCommand: (MainMenuCommand) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(command: MainMenuCommand): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(command: enum) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_MainMenuCommand_cxx: Func_void_MainMenuCommand {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(command: MainMenuCommand): Unit
+    = invoke_cxx(command)
+
+  private external fun invoke_cxx(command: MainMenuCommand): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(command: enum) => void`.
+ * This is implemented in Java/Kotlin, via a `(MainMenuCommand) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_MainMenuCommand_java(private val function: (MainMenuCommand) -> Unit): Func_void_MainMenuCommand {
+  @DoNotStrip
+  @Keep
+  override fun invoke(command: MainMenuCommand): Unit {
+    return this.function(command)
+  }
+}