react-native-nitro-geolocation 1.2.6 → 1.3.0

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

@@ -0,0 +1,111 @@
+///
+/// JBackgroundHttpSyncResult.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 "BackgroundHttpSyncResult.hpp"
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundHttpSyncResult" and the the Kotlin data class "BackgroundHttpSyncResult".
+   */
+  struct JBackgroundHttpSyncResult final: public jni::JavaClass<JBackgroundHttpSyncResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundHttpSyncResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundHttpSyncResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundHttpSyncResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSuccess = clazz->getField<jboolean>("success");
+      jboolean success = this->getFieldValue(fieldSuccess);
+      static const auto fieldStatusCode = clazz->getField<jni::JDouble>("statusCode");
+      jni::local_ref<jni::JDouble> statusCode = this->getFieldValue(fieldStatusCode);
+      static const auto fieldSyncedLocationIds = clazz->getField<jni::JArrayClass<jni::JString>>("syncedLocationIds");
+      jni::local_ref<jni::JArrayClass<jni::JString>> syncedLocationIds = this->getFieldValue(fieldSyncedLocationIds);
+      static const auto fieldFailedLocationIds = clazz->getField<jni::JArrayClass<jni::JString>>("failedLocationIds");
+      jni::local_ref<jni::JArrayClass<jni::JString>> failedLocationIds = this->getFieldValue(fieldFailedLocationIds);
+      static const auto fieldError = clazz->getField<jni::JString>("error");
+      jni::local_ref<jni::JString> error = this->getFieldValue(fieldError);
+      return BackgroundHttpSyncResult(
+        static_cast<bool>(success),
+        statusCode != nullptr ? std::make_optional(statusCode->value()) : std::nullopt,
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(syncedLocationIds),
+        [&](auto&& __input) {
+          size_t __size = __input->size();
+          std::vector<std::string> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = __input->getElement(__i);
+            __vector.push_back(__element->toStdString());
+          }
+          return __vector;
+        }(failedLocationIds),
+        error != nullptr ? std::make_optional(error->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<JBackgroundHttpSyncResult::javaobject> fromCpp(const BackgroundHttpSyncResult& value) {
+      using JSignature = JBackgroundHttpSyncResult(jboolean, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JArrayClass<jni::JString>>, jni::alias_ref<jni::JArrayClass<jni::JString>>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.success,
+        value.statusCode.has_value() ? jni::JDouble::valueOf(value.statusCode.value()) : nullptr,
+        [&](auto&& __input) {
+          size_t __size = __input.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 = __input[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.syncedLocationIds),
+        [&](auto&& __input) {
+          size_t __size = __input.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 = __input[__i];
+            auto __elementJni = jni::make_jstring(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(value.failedLocationIds),
+        value.error.has_value() ? jni::make_jstring(value.error.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,110 @@
+///
+/// JBackgroundLocation.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 "BackgroundLocation.hpp"
+
+#include "BackgroundLocationSource.hpp"
+#include "BatterySnapshot.hpp"
+#include "DetectedActivity.hpp"
+#include "DetectedActivityType.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JBackgroundLocationSource.hpp"
+#include "JBatterySnapshot.hpp"
+#include "JDetectedActivity.hpp"
+#include "JDetectedActivityType.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include "JLocationProviderUsed.hpp"
+#include "JNullableDouble.hpp"
+#include "LocationProviderUsed.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundLocation" and the the Kotlin data class "BackgroundLocation".
+   */
+  struct JBackgroundLocation final: public jni::JavaClass<JBackgroundLocation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundLocation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundLocation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundLocation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldSource = clazz->getField<JBackgroundLocationSource>("source");
+      jni::local_ref<JBackgroundLocationSource> source = this->getFieldValue(fieldSource);
+      static const auto fieldIsFromBackground = clazz->getField<jboolean>("isFromBackground");
+      jboolean isFromBackground = this->getFieldValue(fieldIsFromBackground);
+      static const auto fieldProvider = clazz->getField<JLocationProviderUsed>("provider");
+      jni::local_ref<JLocationProviderUsed> provider = this->getFieldValue(fieldProvider);
+      static const auto fieldMocked = clazz->getField<jni::JBoolean>("mocked");
+      jni::local_ref<jni::JBoolean> mocked = this->getFieldValue(fieldMocked);
+      static const auto fieldRecordedAt = clazz->getField<double>("recordedAt");
+      double recordedAt = this->getFieldValue(fieldRecordedAt);
+      static const auto fieldActivity = clazz->getField<JDetectedActivity>("activity");
+      jni::local_ref<JDetectedActivity> activity = this->getFieldValue(fieldActivity);
+      static const auto fieldBattery = clazz->getField<JBatterySnapshot>("battery");
+      jni::local_ref<JBatterySnapshot> battery = this->getFieldValue(fieldBattery);
+      static const auto fieldCoords = clazz->getField<JGeolocationCoordinates>("coords");
+      jni::local_ref<JGeolocationCoordinates> coords = this->getFieldValue(fieldCoords);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return BackgroundLocation(
+        id != nullptr ? std::make_optional(id->toStdString()) : std::nullopt,
+        source->toCpp(),
+        static_cast<bool>(isFromBackground),
+        provider != nullptr ? std::make_optional(provider->toCpp()) : std::nullopt,
+        mocked != nullptr ? std::make_optional(static_cast<bool>(mocked->value())) : std::nullopt,
+        recordedAt,
+        activity != nullptr ? std::make_optional(activity->toCpp()) : std::nullopt,
+        battery != nullptr ? std::make_optional(battery->toCpp()) : std::nullopt,
+        coords->toCpp(),
+        timestamp
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBackgroundLocation::javaobject> fromCpp(const BackgroundLocation& value) {
+      using JSignature = JBackgroundLocation(jni::alias_ref<jni::JString>, jni::alias_ref<JBackgroundLocationSource>, jboolean, jni::alias_ref<JLocationProviderUsed>, jni::alias_ref<jni::JBoolean>, double, jni::alias_ref<JDetectedActivity>, jni::alias_ref<JBatterySnapshot>, jni::alias_ref<JGeolocationCoordinates>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.id.has_value() ? jni::make_jstring(value.id.value()) : nullptr,
+        JBackgroundLocationSource::fromCpp(value.source),
+        value.isFromBackground,
+        value.provider.has_value() ? JLocationProviderUsed::fromCpp(value.provider.value()) : nullptr,
+        value.mocked.has_value() ? jni::JBoolean::valueOf(value.mocked.value()) : nullptr,
+        value.recordedAt,
+        value.activity.has_value() ? JDetectedActivity::fromCpp(value.activity.value()) : nullptr,
+        value.battery.has_value() ? JBatterySnapshot::fromCpp(value.battery.value()) : nullptr,
+        JGeolocationCoordinates::fromCpp(value.coords),
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,162 @@
+///
+/// JBackgroundLocationOptions.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 "BackgroundLocationOptions.hpp"
+
+#include "ActivityRecognitionOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "AndroidBackgroundLocationOptions.hpp"
+#include "AndroidBackgroundProvider.hpp"
+#include "AndroidForegroundServiceOptions.hpp"
+#include "AndroidGranularity.hpp"
+#include "BackgroundHttpMethod.hpp"
+#include "BackgroundHttpSyncOptions.hpp"
+#include "BackgroundTrackingMode.hpp"
+#include "GeofenceTransition.hpp"
+#include "GeofencingOptions.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "IOSBackgroundActivityType.hpp"
+#include "IOSBackgroundLocationOptions.hpp"
+#include "JActivityRecognitionOptions.hpp"
+#include "JAndroidAccuracyPreset.hpp"
+#include "JAndroidBackgroundLocationOptions.hpp"
+#include "JAndroidBackgroundProvider.hpp"
+#include "JAndroidForegroundServiceOptions.hpp"
+#include "JAndroidGranularity.hpp"
+#include "JBackgroundHttpMethod.hpp"
+#include "JBackgroundHttpSyncOptions.hpp"
+#include "JBackgroundTrackingMode.hpp"
+#include "JGeofenceTransition.hpp"
+#include "JGeofencingOptions.hpp"
+#include "JIOSAccuracyPreset.hpp"
+#include "JIOSBackgroundActivityType.hpp"
+#include "JIOSBackgroundLocationOptions.hpp"
+#include "JLocationAccuracyOptions.hpp"
+#include "JVariant_NullType_Boolean_String_Double.hpp"
+#include "LocationAccuracyOptions.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 "BackgroundLocationOptions" and the the Kotlin data class "BackgroundLocationOptions".
+   */
+  struct JBackgroundLocationOptions final: public jni::JavaClass<JBackgroundLocationOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundLocationOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundLocationOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundLocationOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTrackingMode = clazz->getField<JBackgroundTrackingMode>("trackingMode");
+      jni::local_ref<JBackgroundTrackingMode> trackingMode = this->getFieldValue(fieldTrackingMode);
+      static const auto fieldAccuracy = clazz->getField<JLocationAccuracyOptions>("accuracy");
+      jni::local_ref<JLocationAccuracyOptions> accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldGranularity = clazz->getField<JAndroidGranularity>("granularity");
+      jni::local_ref<JAndroidGranularity> granularity = this->getFieldValue(fieldGranularity);
+      static const auto fieldInterval = clazz->getField<jni::JDouble>("interval");
+      jni::local_ref<jni::JDouble> interval = this->getFieldValue(fieldInterval);
+      static const auto fieldFastestInterval = clazz->getField<jni::JDouble>("fastestInterval");
+      jni::local_ref<jni::JDouble> fastestInterval = this->getFieldValue(fieldFastestInterval);
+      static const auto fieldDistanceFilter = clazz->getField<jni::JDouble>("distanceFilter");
+      jni::local_ref<jni::JDouble> distanceFilter = this->getFieldValue(fieldDistanceFilter);
+      static const auto fieldMaxUpdateDelay = clazz->getField<jni::JDouble>("maxUpdateDelay");
+      jni::local_ref<jni::JDouble> maxUpdateDelay = this->getFieldValue(fieldMaxUpdateDelay);
+      static const auto fieldWaitForAccurateLocation = clazz->getField<jni::JBoolean>("waitForAccurateLocation");
+      jni::local_ref<jni::JBoolean> waitForAccurateLocation = this->getFieldValue(fieldWaitForAccurateLocation);
+      static const auto fieldPersist = clazz->getField<jni::JBoolean>("persist");
+      jni::local_ref<jni::JBoolean> persist = this->getFieldValue(fieldPersist);
+      static const auto fieldMaxStoredLocations = clazz->getField<jni::JDouble>("maxStoredLocations");
+      jni::local_ref<jni::JDouble> maxStoredLocations = this->getFieldValue(fieldMaxStoredLocations);
+      static const auto fieldMaxStoredEvents = clazz->getField<jni::JDouble>("maxStoredEvents");
+      jni::local_ref<jni::JDouble> maxStoredEvents = this->getFieldValue(fieldMaxStoredEvents);
+      static const auto fieldStopOnTerminate = clazz->getField<jni::JBoolean>("stopOnTerminate");
+      jni::local_ref<jni::JBoolean> stopOnTerminate = this->getFieldValue(fieldStopOnTerminate);
+      static const auto fieldStartOnBoot = clazz->getField<jni::JBoolean>("startOnBoot");
+      jni::local_ref<jni::JBoolean> startOnBoot = this->getFieldValue(fieldStartOnBoot);
+      static const auto fieldAndroid = clazz->getField<JAndroidBackgroundLocationOptions>("android");
+      jni::local_ref<JAndroidBackgroundLocationOptions> android = this->getFieldValue(fieldAndroid);
+      static const auto fieldIos = clazz->getField<JIOSBackgroundLocationOptions>("ios");
+      jni::local_ref<JIOSBackgroundLocationOptions> ios = this->getFieldValue(fieldIos);
+      static const auto fieldGeofencing = clazz->getField<JGeofencingOptions>("geofencing");
+      jni::local_ref<JGeofencingOptions> geofencing = this->getFieldValue(fieldGeofencing);
+      static const auto fieldActivityRecognition = clazz->getField<JActivityRecognitionOptions>("activityRecognition");
+      jni::local_ref<JActivityRecognitionOptions> activityRecognition = this->getFieldValue(fieldActivityRecognition);
+      static const auto fieldSync = clazz->getField<JBackgroundHttpSyncOptions>("sync");
+      jni::local_ref<JBackgroundHttpSyncOptions> sync = this->getFieldValue(fieldSync);
+      return BackgroundLocationOptions(
+        trackingMode != nullptr ? std::make_optional(trackingMode->toCpp()) : std::nullopt,
+        accuracy != nullptr ? std::make_optional(accuracy->toCpp()) : std::nullopt,
+        granularity != nullptr ? std::make_optional(granularity->toCpp()) : std::nullopt,
+        interval != nullptr ? std::make_optional(interval->value()) : std::nullopt,
+        fastestInterval != nullptr ? std::make_optional(fastestInterval->value()) : std::nullopt,
+        distanceFilter != nullptr ? std::make_optional(distanceFilter->value()) : std::nullopt,
+        maxUpdateDelay != nullptr ? std::make_optional(maxUpdateDelay->value()) : std::nullopt,
+        waitForAccurateLocation != nullptr ? std::make_optional(static_cast<bool>(waitForAccurateLocation->value())) : std::nullopt,
+        persist != nullptr ? std::make_optional(static_cast<bool>(persist->value())) : std::nullopt,
+        maxStoredLocations != nullptr ? std::make_optional(maxStoredLocations->value()) : std::nullopt,
+        maxStoredEvents != nullptr ? std::make_optional(maxStoredEvents->value()) : std::nullopt,
+        stopOnTerminate != nullptr ? std::make_optional(static_cast<bool>(stopOnTerminate->value())) : std::nullopt,
+        startOnBoot != nullptr ? std::make_optional(static_cast<bool>(startOnBoot->value())) : std::nullopt,
+        android != nullptr ? std::make_optional(android->toCpp()) : std::nullopt,
+        ios != nullptr ? std::make_optional(ios->toCpp()) : std::nullopt,
+        geofencing != nullptr ? std::make_optional(geofencing->toCpp()) : std::nullopt,
+        activityRecognition != nullptr ? std::make_optional(activityRecognition->toCpp()) : std::nullopt,
+        sync != nullptr ? std::make_optional(sync->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<JBackgroundLocationOptions::javaobject> fromCpp(const BackgroundLocationOptions& value) {
+      using JSignature = JBackgroundLocationOptions(jni::alias_ref<JBackgroundTrackingMode>, jni::alias_ref<JLocationAccuracyOptions>, jni::alias_ref<JAndroidGranularity>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JAndroidBackgroundLocationOptions>, jni::alias_ref<JIOSBackgroundLocationOptions>, jni::alias_ref<JGeofencingOptions>, jni::alias_ref<JActivityRecognitionOptions>, jni::alias_ref<JBackgroundHttpSyncOptions>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.trackingMode.has_value() ? JBackgroundTrackingMode::fromCpp(value.trackingMode.value()) : nullptr,
+        value.accuracy.has_value() ? JLocationAccuracyOptions::fromCpp(value.accuracy.value()) : nullptr,
+        value.granularity.has_value() ? JAndroidGranularity::fromCpp(value.granularity.value()) : nullptr,
+        value.interval.has_value() ? jni::JDouble::valueOf(value.interval.value()) : nullptr,
+        value.fastestInterval.has_value() ? jni::JDouble::valueOf(value.fastestInterval.value()) : nullptr,
+        value.distanceFilter.has_value() ? jni::JDouble::valueOf(value.distanceFilter.value()) : nullptr,
+        value.maxUpdateDelay.has_value() ? jni::JDouble::valueOf(value.maxUpdateDelay.value()) : nullptr,
+        value.waitForAccurateLocation.has_value() ? jni::JBoolean::valueOf(value.waitForAccurateLocation.value()) : nullptr,
+        value.persist.has_value() ? jni::JBoolean::valueOf(value.persist.value()) : nullptr,
+        value.maxStoredLocations.has_value() ? jni::JDouble::valueOf(value.maxStoredLocations.value()) : nullptr,
+        value.maxStoredEvents.has_value() ? jni::JDouble::valueOf(value.maxStoredEvents.value()) : nullptr,
+        value.stopOnTerminate.has_value() ? jni::JBoolean::valueOf(value.stopOnTerminate.value()) : nullptr,
+        value.startOnBoot.has_value() ? jni::JBoolean::valueOf(value.startOnBoot.value()) : nullptr,
+        value.android.has_value() ? JAndroidBackgroundLocationOptions::fromCpp(value.android.value()) : nullptr,
+        value.ios.has_value() ? JIOSBackgroundLocationOptions::fromCpp(value.ios.value()) : nullptr,
+        value.geofencing.has_value() ? JGeofencingOptions::fromCpp(value.geofencing.value()) : nullptr,
+        value.activityRecognition.has_value() ? JActivityRecognitionOptions::fromCpp(value.activityRecognition.value()) : nullptr,
+        value.sync.has_value() ? JBackgroundHttpSyncOptions::fromCpp(value.sync.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,73 @@
+///
+/// JBackgroundLocationSource.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 "BackgroundLocationSource.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BackgroundLocationSource" and the the Kotlin enum "BackgroundLocationSource".
+   */
+  struct JBackgroundLocationSource final: public jni::JavaClass<JBackgroundLocationSource> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundLocationSource;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BackgroundLocationSource.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundLocationSource toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BackgroundLocationSource>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBackgroundLocationSource> fromCpp(BackgroundLocationSource value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case BackgroundLocationSource::UNKNOWN:
+          static const auto fieldUNKNOWN = clazz->getStaticField<JBackgroundLocationSource>("UNKNOWN");
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        case BackgroundLocationSource::FOREGROUNDSERVICE:
+          static const auto fieldFOREGROUNDSERVICE = clazz->getStaticField<JBackgroundLocationSource>("FOREGROUNDSERVICE");
+          return clazz->getStaticFieldValue(fieldFOREGROUNDSERVICE);
+        case BackgroundLocationSource::BACKGROUND:
+          static const auto fieldBACKGROUND = clazz->getStaticField<JBackgroundLocationSource>("BACKGROUND");
+          return clazz->getStaticFieldValue(fieldBACKGROUND);
+        case BackgroundLocationSource::SIGNIFICANTCHANGE:
+          static const auto fieldSIGNIFICANTCHANGE = clazz->getStaticField<JBackgroundLocationSource>("SIGNIFICANTCHANGE");
+          return clazz->getStaticFieldValue(fieldSIGNIFICANTCHANGE);
+        case BackgroundLocationSource::GEOFENCE:
+          static const auto fieldGEOFENCE = clazz->getStaticField<JBackgroundLocationSource>("GEOFENCE");
+          return clazz->getStaticFieldValue(fieldGEOFENCE);
+        case BackgroundLocationSource::DEFERRED:
+          static const auto fieldDEFERRED = clazz->getStaticField<JBackgroundLocationSource>("DEFERRED");
+          return clazz->getStaticFieldValue(fieldDEFERRED);
+        case BackgroundLocationSource::MANUAL:
+          static const auto fieldMANUAL = clazz->getStaticField<JBackgroundLocationSource>("MANUAL");
+          return clazz->getStaticFieldValue(fieldMANUAL);
+        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++/JBackgroundLocationState.hpp

@@ -0,0 +1,70 @@
+///
+/// JBackgroundLocationState.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 "BackgroundLocationState.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BackgroundLocationState" and the the Kotlin enum "BackgroundLocationState".
+   */
+  struct JBackgroundLocationState final: public jni::JavaClass<JBackgroundLocationState> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundLocationState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BackgroundLocationState.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundLocationState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BackgroundLocationState>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBackgroundLocationState> fromCpp(BackgroundLocationState value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case BackgroundLocationState::IDLE:
+          static const auto fieldIDLE = clazz->getStaticField<JBackgroundLocationState>("IDLE");
+          return clazz->getStaticFieldValue(fieldIDLE);
+        case BackgroundLocationState::STARTING:
+          static const auto fieldSTARTING = clazz->getStaticField<JBackgroundLocationState>("STARTING");
+          return clazz->getStaticFieldValue(fieldSTARTING);
+        case BackgroundLocationState::RUNNING:
+          static const auto fieldRUNNING = clazz->getStaticField<JBackgroundLocationState>("RUNNING");
+          return clazz->getStaticFieldValue(fieldRUNNING);
+        case BackgroundLocationState::STOPPING:
+          static const auto fieldSTOPPING = clazz->getStaticField<JBackgroundLocationState>("STOPPING");
+          return clazz->getStaticFieldValue(fieldSTOPPING);
+        case BackgroundLocationState::STOPPED:
+          static const auto fieldSTOPPED = clazz->getStaticField<JBackgroundLocationState>("STOPPED");
+          return clazz->getStaticFieldValue(fieldSTOPPED);
+        case BackgroundLocationState::ERROR:
+          static const auto fieldERROR = clazz->getStaticField<JBackgroundLocationState>("ERROR");
+          return clazz->getStaticFieldValue(fieldERROR);
+        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++/JBackgroundLocationStatus.hpp

@@ -0,0 +1,126 @@
+///
+/// JBackgroundLocationStatus.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 "BackgroundLocationStatus.hpp"
+
+#include "AccuracyAuthorization.hpp"
+#include "AndroidBackgroundLocationStatus.hpp"
+#include "BackgroundLocationState.hpp"
+#include "BackgroundPermissionStatus.hpp"
+#include "IOSBackgroundLocationStatus.hpp"
+#include "JAccuracyAuthorization.hpp"
+#include "JAndroidBackgroundLocationStatus.hpp"
+#include "JBackgroundLocationState.hpp"
+#include "JBackgroundPermissionStatus.hpp"
+#include "JIOSBackgroundLocationStatus.hpp"
+#include "JLocationError.hpp"
+#include "JLocationProviderStatus.hpp"
+#include "JPermissionStatus.hpp"
+#include "LocationError.hpp"
+#include "LocationProviderStatus.hpp"
+#include "PermissionStatus.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundLocationStatus" and the the Kotlin data class "BackgroundLocationStatus".
+   */
+  struct JBackgroundLocationStatus final: public jni::JavaClass<JBackgroundLocationStatus> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundLocationStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundLocationStatus by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundLocationStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldState = clazz->getField<JBackgroundLocationState>("state");
+      jni::local_ref<JBackgroundLocationState> state = this->getFieldValue(fieldState);
+      static const auto fieldIsRunning = clazz->getField<jboolean>("isRunning");
+      jboolean isRunning = this->getFieldValue(fieldIsRunning);
+      static const auto fieldIsConfigured = clazz->getField<jboolean>("isConfigured");
+      jboolean isConfigured = this->getFieldValue(fieldIsConfigured);
+      static const auto fieldForegroundPermission = clazz->getField<JPermissionStatus>("foregroundPermission");
+      jni::local_ref<JPermissionStatus> foregroundPermission = this->getFieldValue(fieldForegroundPermission);
+      static const auto fieldBackgroundPermission = clazz->getField<JBackgroundPermissionStatus>("backgroundPermission");
+      jni::local_ref<JBackgroundPermissionStatus> backgroundPermission = this->getFieldValue(fieldBackgroundPermission);
+      static const auto fieldAccuracyAuthorization = clazz->getField<JAccuracyAuthorization>("accuracyAuthorization");
+      jni::local_ref<JAccuracyAuthorization> accuracyAuthorization = this->getFieldValue(fieldAccuracyAuthorization);
+      static const auto fieldLocationServicesEnabled = clazz->getField<jboolean>("locationServicesEnabled");
+      jboolean locationServicesEnabled = this->getFieldValue(fieldLocationServicesEnabled);
+      static const auto fieldProviderStatus = clazz->getField<JLocationProviderStatus>("providerStatus");
+      jni::local_ref<JLocationProviderStatus> providerStatus = this->getFieldValue(fieldProviderStatus);
+      static const auto fieldStoredLocationCount = clazz->getField<double>("storedLocationCount");
+      double storedLocationCount = this->getFieldValue(fieldStoredLocationCount);
+      static const auto fieldStoredEventCount = clazz->getField<double>("storedEventCount");
+      double storedEventCount = this->getFieldValue(fieldStoredEventCount);
+      static const auto fieldGeofenceCount = clazz->getField<double>("geofenceCount");
+      double geofenceCount = this->getFieldValue(fieldGeofenceCount);
+      static const auto fieldAndroid = clazz->getField<JAndroidBackgroundLocationStatus>("android");
+      jni::local_ref<JAndroidBackgroundLocationStatus> android = this->getFieldValue(fieldAndroid);
+      static const auto fieldIos = clazz->getField<JIOSBackgroundLocationStatus>("ios");
+      jni::local_ref<JIOSBackgroundLocationStatus> ios = this->getFieldValue(fieldIos);
+      static const auto fieldLastError = clazz->getField<JLocationError>("lastError");
+      jni::local_ref<JLocationError> lastError = this->getFieldValue(fieldLastError);
+      return BackgroundLocationStatus(
+        state->toCpp(),
+        static_cast<bool>(isRunning),
+        static_cast<bool>(isConfigured),
+        foregroundPermission->toCpp(),
+        backgroundPermission->toCpp(),
+        accuracyAuthorization != nullptr ? std::make_optional(accuracyAuthorization->toCpp()) : std::nullopt,
+        static_cast<bool>(locationServicesEnabled),
+        providerStatus != nullptr ? std::make_optional(providerStatus->toCpp()) : std::nullopt,
+        storedLocationCount,
+        storedEventCount,
+        geofenceCount,
+        android != nullptr ? std::make_optional(android->toCpp()) : std::nullopt,
+        ios != nullptr ? std::make_optional(ios->toCpp()) : std::nullopt,
+        lastError != nullptr ? std::make_optional(lastError->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<JBackgroundLocationStatus::javaobject> fromCpp(const BackgroundLocationStatus& value) {
+      using JSignature = JBackgroundLocationStatus(jni::alias_ref<JBackgroundLocationState>, jboolean, jboolean, jni::alias_ref<JPermissionStatus>, jni::alias_ref<JBackgroundPermissionStatus>, jni::alias_ref<JAccuracyAuthorization>, jboolean, jni::alias_ref<JLocationProviderStatus>, double, double, double, jni::alias_ref<JAndroidBackgroundLocationStatus>, jni::alias_ref<JIOSBackgroundLocationStatus>, jni::alias_ref<JLocationError>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JBackgroundLocationState::fromCpp(value.state),
+        value.isRunning,
+        value.isConfigured,
+        JPermissionStatus::fromCpp(value.foregroundPermission),
+        JBackgroundPermissionStatus::fromCpp(value.backgroundPermission),
+        value.accuracyAuthorization.has_value() ? JAccuracyAuthorization::fromCpp(value.accuracyAuthorization.value()) : nullptr,
+        value.locationServicesEnabled,
+        value.providerStatus.has_value() ? JLocationProviderStatus::fromCpp(value.providerStatus.value()) : nullptr,
+        value.storedLocationCount,
+        value.storedEventCount,
+        value.geofenceCount,
+        value.android.has_value() ? JAndroidBackgroundLocationStatus::fromCpp(value.android.value()) : nullptr,
+        value.ios.has_value() ? JIOSBackgroundLocationStatus::fromCpp(value.ios.value()) : nullptr,
+        value.lastError.has_value() ? JLocationError::fromCpp(value.lastError.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation