react-native-nitro-geolocation 1.2.6 → 1.3.0

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

@@ -0,0 +1,67 @@
+///
+/// JAndroidBackgroundLocationStatus.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 "AndroidBackgroundLocationStatus.hpp"
+
+#include "JPermissionStatus.hpp"
+#include "PermissionStatus.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AndroidBackgroundLocationStatus" and the the Kotlin data class "AndroidBackgroundLocationStatus".
+   */
+  struct JAndroidBackgroundLocationStatus final: public jni::JavaClass<JAndroidBackgroundLocationStatus> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AndroidBackgroundLocationStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AndroidBackgroundLocationStatus by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidBackgroundLocationStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIsForegroundServiceRunning = clazz->getField<jboolean>("isForegroundServiceRunning");
+      jboolean isForegroundServiceRunning = this->getFieldValue(fieldIsForegroundServiceRunning);
+      static const auto fieldIsIgnoringBatteryOptimizations = clazz->getField<jni::JBoolean>("isIgnoringBatteryOptimizations");
+      jni::local_ref<jni::JBoolean> isIgnoringBatteryOptimizations = this->getFieldValue(fieldIsIgnoringBatteryOptimizations);
+      static const auto fieldNotificationPermission = clazz->getField<JPermissionStatus>("notificationPermission");
+      jni::local_ref<JPermissionStatus> notificationPermission = this->getFieldValue(fieldNotificationPermission);
+      return AndroidBackgroundLocationStatus(
+        static_cast<bool>(isForegroundServiceRunning),
+        isIgnoringBatteryOptimizations != nullptr ? std::make_optional(static_cast<bool>(isIgnoringBatteryOptimizations->value())) : std::nullopt,
+        notificationPermission != nullptr ? std::make_optional(notificationPermission->toCpp()) : 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<JAndroidBackgroundLocationStatus::javaobject> fromCpp(const AndroidBackgroundLocationStatus& value) {
+      using JSignature = JAndroidBackgroundLocationStatus(jboolean, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JPermissionStatus>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.isForegroundServiceRunning,
+        value.isIgnoringBatteryOptimizations.has_value() ? jni::JBoolean::valueOf(value.isIgnoringBatteryOptimizations.value()) : nullptr,
+        value.notificationPermission.has_value() ? JPermissionStatus::fromCpp(value.notificationPermission.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

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

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

@@ -0,0 +1,90 @@
+///
+/// JAndroidForegroundServiceOptions.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 "AndroidForegroundServiceOptions.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "AndroidForegroundServiceOptions" and the the Kotlin data class "AndroidForegroundServiceOptions".
+   */
+  struct JAndroidForegroundServiceOptions final: public jni::JavaClass<JAndroidForegroundServiceOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AndroidForegroundServiceOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct AndroidForegroundServiceOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidForegroundServiceOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldNotificationId = clazz->getField<jni::JDouble>("notificationId");
+      jni::local_ref<jni::JDouble> notificationId = this->getFieldValue(fieldNotificationId);
+      static const auto fieldNotificationTitle = clazz->getField<jni::JString>("notificationTitle");
+      jni::local_ref<jni::JString> notificationTitle = this->getFieldValue(fieldNotificationTitle);
+      static const auto fieldNotificationText = clazz->getField<jni::JString>("notificationText");
+      jni::local_ref<jni::JString> notificationText = this->getFieldValue(fieldNotificationText);
+      static const auto fieldNotificationChannelId = clazz->getField<jni::JString>("notificationChannelId");
+      jni::local_ref<jni::JString> notificationChannelId = this->getFieldValue(fieldNotificationChannelId);
+      static const auto fieldNotificationChannelName = clazz->getField<jni::JString>("notificationChannelName");
+      jni::local_ref<jni::JString> notificationChannelName = this->getFieldValue(fieldNotificationChannelName);
+      static const auto fieldNotificationChannelDescription = clazz->getField<jni::JString>("notificationChannelDescription");
+      jni::local_ref<jni::JString> notificationChannelDescription = this->getFieldValue(fieldNotificationChannelDescription);
+      static const auto fieldNotificationIcon = clazz->getField<jni::JString>("notificationIcon");
+      jni::local_ref<jni::JString> notificationIcon = this->getFieldValue(fieldNotificationIcon);
+      static const auto fieldNotificationColor = clazz->getField<jni::JString>("notificationColor");
+      jni::local_ref<jni::JString> notificationColor = this->getFieldValue(fieldNotificationColor);
+      static const auto fieldStopActionTitle = clazz->getField<jni::JString>("stopActionTitle");
+      jni::local_ref<jni::JString> stopActionTitle = this->getFieldValue(fieldStopActionTitle);
+      return AndroidForegroundServiceOptions(
+        notificationId != nullptr ? std::make_optional(notificationId->value()) : std::nullopt,
+        notificationTitle->toStdString(),
+        notificationText->toStdString(),
+        notificationChannelId != nullptr ? std::make_optional(notificationChannelId->toStdString()) : std::nullopt,
+        notificationChannelName != nullptr ? std::make_optional(notificationChannelName->toStdString()) : std::nullopt,
+        notificationChannelDescription != nullptr ? std::make_optional(notificationChannelDescription->toStdString()) : std::nullopt,
+        notificationIcon != nullptr ? std::make_optional(notificationIcon->toStdString()) : std::nullopt,
+        notificationColor != nullptr ? std::make_optional(notificationColor->toStdString()) : std::nullopt,
+        stopActionTitle != nullptr ? std::make_optional(stopActionTitle->toStdString()) : 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<JAndroidForegroundServiceOptions::javaobject> fromCpp(const AndroidForegroundServiceOptions& value) {
+      using JSignature = JAndroidForegroundServiceOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, 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,
+        value.notificationId.has_value() ? jni::JDouble::valueOf(value.notificationId.value()) : nullptr,
+        jni::make_jstring(value.notificationTitle),
+        jni::make_jstring(value.notificationText),
+        value.notificationChannelId.has_value() ? jni::make_jstring(value.notificationChannelId.value()) : nullptr,
+        value.notificationChannelName.has_value() ? jni::make_jstring(value.notificationChannelName.value()) : nullptr,
+        value.notificationChannelDescription.has_value() ? jni::make_jstring(value.notificationChannelDescription.value()) : nullptr,
+        value.notificationIcon.has_value() ? jni::make_jstring(value.notificationIcon.value()) : nullptr,
+        value.notificationColor.has_value() ? jni::make_jstring(value.notificationColor.value()) : nullptr,
+        value.stopActionTitle.has_value() ? jni::make_jstring(value.stopActionTitle.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,129 @@
+///
+/// JBackgroundEventEnvelope.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 "BackgroundEventEnvelope.hpp"
+
+#include "BackgroundEventType.hpp"
+#include "BackgroundHttpSyncResult.hpp"
+#include "BackgroundLocation.hpp"
+#include "BackgroundLocationSource.hpp"
+#include "BatterySnapshot.hpp"
+#include "DetectedActivity.hpp"
+#include "DetectedActivityType.hpp"
+#include "GeofenceEvent.hpp"
+#include "GeofenceRegion.hpp"
+#include "GeofenceTransition.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JBackgroundEventType.hpp"
+#include "JBackgroundHttpSyncResult.hpp"
+#include "JBackgroundLocation.hpp"
+#include "JBackgroundLocationSource.hpp"
+#include "JBatterySnapshot.hpp"
+#include "JDetectedActivity.hpp"
+#include "JDetectedActivityType.hpp"
+#include "JGeofenceEvent.hpp"
+#include "JGeofenceRegion.hpp"
+#include "JGeofenceTransition.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include "JLocationError.hpp"
+#include "JLocationProviderStatus.hpp"
+#include "JLocationProviderUsed.hpp"
+#include "JNullableDouble.hpp"
+#include "JVariant_NullType_Boolean_String_Double.hpp"
+#include "LocationError.hpp"
+#include "LocationProviderStatus.hpp"
+#include "LocationProviderUsed.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundEventEnvelope" and the the Kotlin data class "BackgroundEventEnvelope".
+   */
+  struct JBackgroundEventEnvelope final: public jni::JavaClass<JBackgroundEventEnvelope> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundEventEnvelope;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundEventEnvelope by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundEventEnvelope toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLocation = clazz->getField<JBackgroundLocation>("location");
+      jni::local_ref<JBackgroundLocation> location = this->getFieldValue(fieldLocation);
+      static const auto fieldGeofence = clazz->getField<JGeofenceEvent>("geofence");
+      jni::local_ref<JGeofenceEvent> geofence = this->getFieldValue(fieldGeofence);
+      static const auto fieldActivity = clazz->getField<JDetectedActivity>("activity");
+      jni::local_ref<JDetectedActivity> activity = this->getFieldValue(fieldActivity);
+      static const auto fieldProviderStatus = clazz->getField<JLocationProviderStatus>("providerStatus");
+      jni::local_ref<JLocationProviderStatus> providerStatus = this->getFieldValue(fieldProviderStatus);
+      static const auto fieldResult = clazz->getField<JBackgroundHttpSyncResult>("result");
+      jni::local_ref<JBackgroundHttpSyncResult> result = this->getFieldValue(fieldResult);
+      static const auto fieldError = clazz->getField<JLocationError>("error");
+      jni::local_ref<JLocationError> error = this->getFieldValue(fieldError);
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldType = clazz->getField<JBackgroundEventType>("type");
+      jni::local_ref<JBackgroundEventType> type = this->getFieldValue(fieldType);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      static const auto fieldDeliveredToJS = clazz->getField<jboolean>("deliveredToJS");
+      jboolean deliveredToJS = this->getFieldValue(fieldDeliveredToJS);
+      return BackgroundEventEnvelope(
+        location != nullptr ? std::make_optional(location->toCpp()) : std::nullopt,
+        geofence != nullptr ? std::make_optional(geofence->toCpp()) : std::nullopt,
+        activity != nullptr ? std::make_optional(activity->toCpp()) : std::nullopt,
+        providerStatus != nullptr ? std::make_optional(providerStatus->toCpp()) : std::nullopt,
+        result != nullptr ? std::make_optional(result->toCpp()) : std::nullopt,
+        error != nullptr ? std::make_optional(error->toCpp()) : std::nullopt,
+        id->toStdString(),
+        type->toCpp(),
+        timestamp,
+        static_cast<bool>(deliveredToJS)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBackgroundEventEnvelope::javaobject> fromCpp(const BackgroundEventEnvelope& value) {
+      using JSignature = JBackgroundEventEnvelope(jni::alias_ref<JBackgroundLocation>, jni::alias_ref<JGeofenceEvent>, jni::alias_ref<JDetectedActivity>, jni::alias_ref<JLocationProviderStatus>, jni::alias_ref<JBackgroundHttpSyncResult>, jni::alias_ref<JLocationError>, jni::alias_ref<jni::JString>, jni::alias_ref<JBackgroundEventType>, double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.location.has_value() ? JBackgroundLocation::fromCpp(value.location.value()) : nullptr,
+        value.geofence.has_value() ? JGeofenceEvent::fromCpp(value.geofence.value()) : nullptr,
+        value.activity.has_value() ? JDetectedActivity::fromCpp(value.activity.value()) : nullptr,
+        value.providerStatus.has_value() ? JLocationProviderStatus::fromCpp(value.providerStatus.value()) : nullptr,
+        value.result.has_value() ? JBackgroundHttpSyncResult::fromCpp(value.result.value()) : nullptr,
+        value.error.has_value() ? JLocationError::fromCpp(value.error.value()) : nullptr,
+        jni::make_jstring(value.id),
+        JBackgroundEventType::fromCpp(value.type),
+        value.timestamp,
+        value.deliveredToJS
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,70 @@
+///
+/// JBackgroundEventType.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 "BackgroundEventType.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BackgroundEventType" and the the Kotlin enum "BackgroundEventType".
+   */
+  struct JBackgroundEventType final: public jni::JavaClass<JBackgroundEventType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundEventType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BackgroundEventType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundEventType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BackgroundEventType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBackgroundEventType> fromCpp(BackgroundEventType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case BackgroundEventType::ERROR:
+          static const auto fieldERROR = clazz->getStaticField<JBackgroundEventType>("ERROR");
+          return clazz->getStaticFieldValue(fieldERROR);
+        case BackgroundEventType::GEOFENCE:
+          static const auto fieldGEOFENCE = clazz->getStaticField<JBackgroundEventType>("GEOFENCE");
+          return clazz->getStaticFieldValue(fieldGEOFENCE);
+        case BackgroundEventType::LOCATION:
+          static const auto fieldLOCATION = clazz->getStaticField<JBackgroundEventType>("LOCATION");
+          return clazz->getStaticFieldValue(fieldLOCATION);
+        case BackgroundEventType::ACTIVITY:
+          static const auto fieldACTIVITY = clazz->getStaticField<JBackgroundEventType>("ACTIVITY");
+          return clazz->getStaticFieldValue(fieldACTIVITY);
+        case BackgroundEventType::PROVIDERCHANGE:
+          static const auto fieldPROVIDERCHANGE = clazz->getStaticField<JBackgroundEventType>("PROVIDERCHANGE");
+          return clazz->getStaticFieldValue(fieldPROVIDERCHANGE);
+        case BackgroundEventType::HTTPSYNC:
+          static const auto fieldHTTPSYNC = clazz->getStaticField<JBackgroundEventType>("HTTPSYNC");
+          return clazz->getStaticFieldValue(fieldHTTPSYNC);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

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

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

@@ -0,0 +1,131 @@
+///
+/// JBackgroundHttpSyncOptions.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 "BackgroundHttpSyncOptions.hpp"
+
+#include "BackgroundHttpMethod.hpp"
+#include "JBackgroundHttpMethod.hpp"
+#include "JVariant_NullType_Boolean_String_Double.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundHttpSyncOptions" and the the Kotlin data class "BackgroundHttpSyncOptions".
+   */
+  struct JBackgroundHttpSyncOptions final: public jni::JavaClass<JBackgroundHttpSyncOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundHttpSyncOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundHttpSyncOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundHttpSyncOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldMethod = clazz->getField<JBackgroundHttpMethod>("method");
+      jni::local_ref<JBackgroundHttpMethod> method = this->getFieldValue(fieldMethod);
+      static const auto fieldHeaders = clazz->getField<jni::JMap<jni::JString, jni::JString>>("headers");
+      jni::local_ref<jni::JMap<jni::JString, jni::JString>> headers = this->getFieldValue(fieldHeaders);
+      static const auto fieldBatch = clazz->getField<jni::JBoolean>("batch");
+      jni::local_ref<jni::JBoolean> batch = this->getFieldValue(fieldBatch);
+      static const auto fieldBatchSize = clazz->getField<jni::JDouble>("batchSize");
+      jni::local_ref<jni::JDouble> batchSize = this->getFieldValue(fieldBatchSize);
+      static const auto fieldSyncThreshold = clazz->getField<jni::JDouble>("syncThreshold");
+      jni::local_ref<jni::JDouble> syncThreshold = this->getFieldValue(fieldSyncThreshold);
+      static const auto fieldSyncInterval = clazz->getField<jni::JDouble>("syncInterval");
+      jni::local_ref<jni::JDouble> syncInterval = this->getFieldValue(fieldSyncInterval);
+      static const auto fieldRetry = clazz->getField<jni::JBoolean>("retry");
+      jni::local_ref<jni::JBoolean> retry = this->getFieldValue(fieldRetry);
+      static const auto fieldMaxRetries = clazz->getField<jni::JDouble>("maxRetries");
+      jni::local_ref<jni::JDouble> maxRetries = this->getFieldValue(fieldMaxRetries);
+      static const auto fieldBodyTemplate = clazz->getField<jni::JMap<jni::JString, JVariant_NullType_Boolean_String_Double>>("bodyTemplate");
+      jni::local_ref<jni::JMap<jni::JString, JVariant_NullType_Boolean_String_Double>> bodyTemplate = this->getFieldValue(fieldBodyTemplate);
+      static const auto fieldAutoClear = clazz->getField<jni::JBoolean>("autoClear");
+      jni::local_ref<jni::JBoolean> autoClear = this->getFieldValue(fieldAutoClear);
+      return BackgroundHttpSyncOptions(
+        url->toStdString(),
+        method != nullptr ? std::make_optional(method->toCpp()) : std::nullopt,
+        headers != nullptr ? std::make_optional([&]() {
+          std::unordered_map<std::string, std::string> __map;
+          __map.reserve(headers->size());
+          for (const auto& __entry : *headers) {
+            __map.emplace(__entry.first->toStdString(), __entry.second->toStdString());
+          }
+          return __map;
+        }()) : std::nullopt,
+        batch != nullptr ? std::make_optional(static_cast<bool>(batch->value())) : std::nullopt,
+        batchSize != nullptr ? std::make_optional(batchSize->value()) : std::nullopt,
+        syncThreshold != nullptr ? std::make_optional(syncThreshold->value()) : std::nullopt,
+        syncInterval != nullptr ? std::make_optional(syncInterval->value()) : std::nullopt,
+        retry != nullptr ? std::make_optional(static_cast<bool>(retry->value())) : std::nullopt,
+        maxRetries != nullptr ? std::make_optional(maxRetries->value()) : std::nullopt,
+        bodyTemplate != nullptr ? std::make_optional([&]() {
+          std::unordered_map<std::string, std::variant<nitro::NullType, bool, std::string, double>> __map;
+          __map.reserve(bodyTemplate->size());
+          for (const auto& __entry : *bodyTemplate) {
+            __map.emplace(__entry.first->toStdString(), __entry.second->toCpp());
+          }
+          return __map;
+        }()) : std::nullopt,
+        autoClear != nullptr ? std::make_optional(static_cast<bool>(autoClear->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<JBackgroundHttpSyncOptions::javaobject> fromCpp(const BackgroundHttpSyncOptions& value) {
+      using JSignature = JBackgroundHttpSyncOptions(jni::alias_ref<jni::JString>, jni::alias_ref<JBackgroundHttpMethod>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JMap<jni::JString, JVariant_NullType_Boolean_String_Double>>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.url),
+        value.method.has_value() ? JBackgroundHttpMethod::fromCpp(value.method.value()) : nullptr,
+        value.headers.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, jni::JString>> {
+          auto __map = jni::JHashMap<jni::JString, jni::JString>::create(value.headers.value().size());
+          for (const auto& __entry : value.headers.value()) {
+            __map->put(jni::make_jstring(__entry.first), jni::make_jstring(__entry.second));
+          }
+          return __map;
+        }() : nullptr,
+        value.batch.has_value() ? jni::JBoolean::valueOf(value.batch.value()) : nullptr,
+        value.batchSize.has_value() ? jni::JDouble::valueOf(value.batchSize.value()) : nullptr,
+        value.syncThreshold.has_value() ? jni::JDouble::valueOf(value.syncThreshold.value()) : nullptr,
+        value.syncInterval.has_value() ? jni::JDouble::valueOf(value.syncInterval.value()) : nullptr,
+        value.retry.has_value() ? jni::JBoolean::valueOf(value.retry.value()) : nullptr,
+        value.maxRetries.has_value() ? jni::JDouble::valueOf(value.maxRetries.value()) : nullptr,
+        value.bodyTemplate.has_value() ? [&]() -> jni::local_ref<jni::JMap<jni::JString, JVariant_NullType_Boolean_String_Double>> {
+          auto __map = jni::JHashMap<jni::JString, JVariant_NullType_Boolean_String_Double>::create(value.bodyTemplate.value().size());
+          for (const auto& __entry : value.bodyTemplate.value()) {
+            __map->put(jni::make_jstring(__entry.first), JVariant_NullType_Boolean_String_Double::fromCpp(__entry.second));
+          }
+          return __map;
+        }() : nullptr,
+        value.autoClear.has_value() ? jni::JBoolean::valueOf(value.autoClear.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation