react-native-nitro-geolocation 1.2.5 → 1.3.0

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

@@ -0,0 +1,89 @@
+///
+/// HybridNitroBackgroundLocationSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroBackgroundLocationSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  class JHybridNitroBackgroundLocationSpec: public virtual HybridNitroBackgroundLocationSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/HybridNitroBackgroundLocationSpec;";
+      std::shared_ptr<JHybridNitroBackgroundLocationSpec> getJHybridNitroBackgroundLocationSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/HybridNitroBackgroundLocationSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroBackgroundLocationSpec(const jni::local_ref<JHybridNitroBackgroundLocationSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroBackgroundLocationSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroBackgroundLocationSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroBackgroundLocationSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<BackgroundPermissionResult>> checkBackgroundPermission() override;
+    std::shared_ptr<Promise<BackgroundPermissionResult>> requestBackgroundPermission() override;
+    std::shared_ptr<Promise<void>> openAppLocationSettings() override;
+    std::shared_ptr<Promise<void>> configureBackgroundLocation(const BackgroundLocationOptions& options) override;
+    std::shared_ptr<Promise<std::optional<BackgroundLocationOptions>>> getBackgroundConfiguration() override;
+    std::shared_ptr<Promise<void>> startBackgroundLocation(const std::optional<BackgroundLocationOptions>& options) override;
+    std::shared_ptr<Promise<void>> stopBackgroundLocation() override;
+    std::shared_ptr<Promise<void>> resetBackgroundLocation() override;
+    std::shared_ptr<Promise<BackgroundLocationStatus>> getBackgroundLocationStatus() override;
+    std::string addBackgroundEventListener(const std::function<void(const BackgroundEventEnvelope& /* event */)>& listener) override;
+    void removeBackgroundEventListener(const std::string& token) override;
+    std::string addBackgroundLocationListener(const std::function<void(const BackgroundLocation& /* location */)>& listener) override;
+    void removeBackgroundLocationListener(const std::string& token) override;
+    std::string addBackgroundErrorListener(const std::function<void(const LocationError& /* error */)>& listener) override;
+    void removeBackgroundErrorListener(const std::string& token) override;
+    std::shared_ptr<Promise<std::vector<StoredBackgroundLocation>>> getStoredBackgroundLocations(const std::optional<GetStoredBackgroundLocationsOptions>& options) override;
+    std::shared_ptr<Promise<void>> clearStoredBackgroundLocations(const std::optional<std::vector<std::string>>& ids) override;
+    std::shared_ptr<Promise<void>> markStoredBackgroundLocationsDelivered(const std::vector<std::string>& ids) override;
+    std::shared_ptr<Promise<std::vector<StoredBackgroundEventEnvelope>>> getStoredBackgroundEvents(const std::optional<GetStoredBackgroundEventsOptions>& options) override;
+    std::shared_ptr<Promise<void>> clearStoredBackgroundEvents(const std::optional<std::vector<std::string>>& ids) override;
+    std::shared_ptr<Promise<void>> markStoredBackgroundEventsDelivered(const std::vector<std::string>& ids) override;
+    std::shared_ptr<Promise<void>> addGeofences(const std::vector<GeofenceRegion>& regions, const std::optional<GeofencingOptions>& options) override;
+    std::shared_ptr<Promise<void>> removeGeofences(const std::optional<std::vector<std::string>>& identifiers) override;
+    std::shared_ptr<Promise<std::vector<GeofenceRegion>>> getRegisteredGeofences() override;
+    std::shared_ptr<Promise<void>> startActivityRecognition(const std::optional<ActivityRecognitionOptions>& options) override;
+    std::shared_ptr<Promise<void>> stopActivityRecognition() override;
+    std::shared_ptr<Promise<BackgroundHttpSyncResult>> syncStoredLocations() override;
+
+  private:
+    jni::global_ref<JHybridNitroBackgroundLocationSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,67 @@
+///
+/// JIOSBackgroundActivityType.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 "IOSBackgroundActivityType.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSBackgroundActivityType" and the the Kotlin enum "IOSBackgroundActivityType".
+   */
+  struct JIOSBackgroundActivityType final: public jni::JavaClass<JIOSBackgroundActivityType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/IOSBackgroundActivityType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSBackgroundActivityType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSBackgroundActivityType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSBackgroundActivityType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSBackgroundActivityType> fromCpp(IOSBackgroundActivityType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case IOSBackgroundActivityType::OTHER:
+          static const auto fieldOTHER = clazz->getStaticField<JIOSBackgroundActivityType>("OTHER");
+          return clazz->getStaticFieldValue(fieldOTHER);
+        case IOSBackgroundActivityType::AUTOMOTIVENAVIGATION:
+          static const auto fieldAUTOMOTIVENAVIGATION = clazz->getStaticField<JIOSBackgroundActivityType>("AUTOMOTIVENAVIGATION");
+          return clazz->getStaticFieldValue(fieldAUTOMOTIVENAVIGATION);
+        case IOSBackgroundActivityType::FITNESS:
+          static const auto fieldFITNESS = clazz->getStaticField<JIOSBackgroundActivityType>("FITNESS");
+          return clazz->getStaticFieldValue(fieldFITNESS);
+        case IOSBackgroundActivityType::OTHERNAVIGATION:
+          static const auto fieldOTHERNAVIGATION = clazz->getStaticField<JIOSBackgroundActivityType>("OTHERNAVIGATION");
+          return clazz->getStaticFieldValue(fieldOTHERNAVIGATION);
+        case IOSBackgroundActivityType::AIRBORNE:
+          static const auto fieldAIRBORNE = clazz->getStaticField<JIOSBackgroundActivityType>("AIRBORNE");
+          return clazz->getStaticFieldValue(fieldAIRBORNE);
+        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++/JIOSBackgroundLocationOptions.hpp

@@ -0,0 +1,79 @@
+///
+/// JIOSBackgroundLocationOptions.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 "IOSBackgroundLocationOptions.hpp"
+
+#include "IOSBackgroundActivityType.hpp"
+#include "JIOSBackgroundActivityType.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "IOSBackgroundLocationOptions" and the the Kotlin data class "IOSBackgroundLocationOptions".
+   */
+  struct JIOSBackgroundLocationOptions final: public jni::JavaClass<JIOSBackgroundLocationOptions> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/IOSBackgroundLocationOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct IOSBackgroundLocationOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSBackgroundLocationOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldActivityType = clazz->getField<JIOSBackgroundActivityType>("activityType");
+      jni::local_ref<JIOSBackgroundActivityType> activityType = this->getFieldValue(fieldActivityType);
+      static const auto fieldPausesLocationUpdatesAutomatically = clazz->getField<jni::JBoolean>("pausesLocationUpdatesAutomatically");
+      jni::local_ref<jni::JBoolean> pausesLocationUpdatesAutomatically = this->getFieldValue(fieldPausesLocationUpdatesAutomatically);
+      static const auto fieldShowsBackgroundLocationIndicator = clazz->getField<jni::JBoolean>("showsBackgroundLocationIndicator");
+      jni::local_ref<jni::JBoolean> showsBackgroundLocationIndicator = this->getFieldValue(fieldShowsBackgroundLocationIndicator);
+      static const auto fieldUseSignificantChanges = clazz->getField<jni::JBoolean>("useSignificantChanges");
+      jni::local_ref<jni::JBoolean> useSignificantChanges = this->getFieldValue(fieldUseSignificantChanges);
+      static const auto fieldDeferredUpdatesDistance = clazz->getField<jni::JDouble>("deferredUpdatesDistance");
+      jni::local_ref<jni::JDouble> deferredUpdatesDistance = this->getFieldValue(fieldDeferredUpdatesDistance);
+      static const auto fieldDeferredUpdatesInterval = clazz->getField<jni::JDouble>("deferredUpdatesInterval");
+      jni::local_ref<jni::JDouble> deferredUpdatesInterval = this->getFieldValue(fieldDeferredUpdatesInterval);
+      return IOSBackgroundLocationOptions(
+        activityType != nullptr ? std::make_optional(activityType->toCpp()) : std::nullopt,
+        pausesLocationUpdatesAutomatically != nullptr ? std::make_optional(static_cast<bool>(pausesLocationUpdatesAutomatically->value())) : std::nullopt,
+        showsBackgroundLocationIndicator != nullptr ? std::make_optional(static_cast<bool>(showsBackgroundLocationIndicator->value())) : std::nullopt,
+        useSignificantChanges != nullptr ? std::make_optional(static_cast<bool>(useSignificantChanges->value())) : std::nullopt,
+        deferredUpdatesDistance != nullptr ? std::make_optional(deferredUpdatesDistance->value()) : std::nullopt,
+        deferredUpdatesInterval != nullptr ? std::make_optional(deferredUpdatesInterval->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<JIOSBackgroundLocationOptions::javaobject> fromCpp(const IOSBackgroundLocationOptions& value) {
+      using JSignature = JIOSBackgroundLocationOptions(jni::alias_ref<JIOSBackgroundActivityType>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.activityType.has_value() ? JIOSBackgroundActivityType::fromCpp(value.activityType.value()) : nullptr,
+        value.pausesLocationUpdatesAutomatically.has_value() ? jni::JBoolean::valueOf(value.pausesLocationUpdatesAutomatically.value()) : nullptr,
+        value.showsBackgroundLocationIndicator.has_value() ? jni::JBoolean::valueOf(value.showsBackgroundLocationIndicator.value()) : nullptr,
+        value.useSignificantChanges.has_value() ? jni::JBoolean::valueOf(value.useSignificantChanges.value()) : nullptr,
+        value.deferredUpdatesDistance.has_value() ? jni::JDouble::valueOf(value.deferredUpdatesDistance.value()) : nullptr,
+        value.deferredUpdatesInterval.has_value() ? jni::JDouble::valueOf(value.deferredUpdatesInterval.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,61 @@
+///
+/// JIOSBackgroundLocationStatus.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 "IOSBackgroundLocationStatus.hpp"
+
+
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "IOSBackgroundLocationStatus" and the the Kotlin data class "IOSBackgroundLocationStatus".
+   */
+  struct JIOSBackgroundLocationStatus final: public jni::JavaClass<JIOSBackgroundLocationStatus> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/IOSBackgroundLocationStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct IOSBackgroundLocationStatus by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSBackgroundLocationStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAllowsBackgroundLocationUpdates = clazz->getField<jboolean>("allowsBackgroundLocationUpdates");
+      jboolean allowsBackgroundLocationUpdates = this->getFieldValue(fieldAllowsBackgroundLocationUpdates);
+      static const auto fieldSignificantChangesEnabled = clazz->getField<jboolean>("significantChangesEnabled");
+      jboolean significantChangesEnabled = this->getFieldValue(fieldSignificantChangesEnabled);
+      return IOSBackgroundLocationStatus(
+        static_cast<bool>(allowsBackgroundLocationUpdates),
+        static_cast<bool>(significantChangesEnabled)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JIOSBackgroundLocationStatus::javaobject> fromCpp(const IOSBackgroundLocationStatus& value) {
+      using JSignature = JIOSBackgroundLocationStatus(jboolean, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.allowsBackgroundLocationUpdates,
+        value.significantChangesEnabled
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -41,6 +41,8 @@ namespace margelo::nitro::nitrogeolocation {
       jni::local_ref<jni::JBoolean> networkAvailable = this->getFieldValue(fieldNetworkAvailable);
       static const auto fieldPassiveAvailable = clazz->getField<jni::JBoolean>("passiveAvailable");
       jni::local_ref<jni::JBoolean> passiveAvailable = this->getFieldValue(fieldPassiveAvailable);
+      static const auto fieldGooglePlayServicesAvailable = clazz->getField<jni::JBoolean>("googlePlayServicesAvailable");
+      jni::local_ref<jni::JBoolean> googlePlayServicesAvailable = this->getFieldValue(fieldGooglePlayServicesAvailable);
       static const auto fieldGoogleLocationAccuracyEnabled = clazz->getField<jni::JBoolean>("googleLocationAccuracyEnabled");
       jni::local_ref<jni::JBoolean> googleLocationAccuracyEnabled = this->getFieldValue(fieldGoogleLocationAccuracyEnabled);
       return LocationProviderStatus(
@@ -49,6 +51,7 @@ namespace margelo::nitro::nitrogeolocation {
         gpsAvailable != nullptr ? std::make_optional(static_cast<bool>(gpsAvailable->value())) : std::nullopt,
         networkAvailable != nullptr ? std::make_optional(static_cast<bool>(networkAvailable->value())) : std::nullopt,
         passiveAvailable != nullptr ? std::make_optional(static_cast<bool>(passiveAvailable->value())) : std::nullopt,
+        googlePlayServicesAvailable != nullptr ? std::make_optional(static_cast<bool>(googlePlayServicesAvailable->value())) : std::nullopt,
         googleLocationAccuracyEnabled != nullptr ? std::make_optional(static_cast<bool>(googleLocationAccuracyEnabled->value())) : std::nullopt
       );
     }
@@ -59,7 +62,7 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JLocationProviderStatus::javaobject> fromCpp(const LocationProviderStatus& value) {
-      using JSignature = JLocationProviderStatus(jboolean, jboolean, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>);
+      using JSignature = JLocationProviderStatus(jboolean, jboolean, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -69,6 +72,7 @@ namespace margelo::nitro::nitrogeolocation {
         value.gpsAvailable.has_value() ? jni::JBoolean::valueOf(value.gpsAvailable.value()) : nullptr,
         value.networkAvailable.has_value() ? jni::JBoolean::valueOf(value.networkAvailable.value()) : nullptr,
         value.passiveAvailable.has_value() ? jni::JBoolean::valueOf(value.passiveAvailable.value()) : nullptr,
+        value.googlePlayServicesAvailable.has_value() ? jni::JBoolean::valueOf(value.googlePlayServicesAvailable.value()) : nullptr,
         value.googleLocationAccuracyEnabled.has_value() ? jni::JBoolean::valueOf(value.googleLocationAccuracyEnabled.value()) : nullptr
       );
     }

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

@@ -0,0 +1,115 @@
+///
+/// JStoredBackgroundEventEnvelope.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 "StoredBackgroundEventEnvelope.hpp"
+
+#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 "JBackgroundEventEnvelope.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 "StoredBackgroundEventEnvelope" and the the Kotlin data class "StoredBackgroundEventEnvelope".
+   */
+  struct JStoredBackgroundEventEnvelope final: public jni::JavaClass<JStoredBackgroundEventEnvelope> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/StoredBackgroundEventEnvelope;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct StoredBackgroundEventEnvelope by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    StoredBackgroundEventEnvelope toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldEvent = clazz->getField<JBackgroundEventEnvelope>("event");
+      jni::local_ref<JBackgroundEventEnvelope> event = this->getFieldValue(fieldEvent);
+      static const auto fieldCreatedAt = clazz->getField<double>("createdAt");
+      double createdAt = this->getFieldValue(fieldCreatedAt);
+      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 StoredBackgroundEventEnvelope(
+        event->toCpp(),
+        createdAt,
+        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<JStoredBackgroundEventEnvelope::javaobject> fromCpp(const StoredBackgroundEventEnvelope& value) {
+      using JSignature = JStoredBackgroundEventEnvelope(jni::alias_ref<JBackgroundEventEnvelope>, double, 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,
+        JBackgroundEventEnvelope::fromCpp(value.event),
+        value.createdAt,
+        jni::make_jstring(value.id),
+        JBackgroundEventType::fromCpp(value.type),
+        value.timestamp,
+        value.deliveredToJS
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,122 @@
+///
+/// JStoredBackgroundLocation.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 "StoredBackgroundLocation.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 "StoredBackgroundLocation" and the the Kotlin data class "StoredBackgroundLocation".
+   */
+  struct JStoredBackgroundLocation final: public jni::JavaClass<JStoredBackgroundLocation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/StoredBackgroundLocation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct StoredBackgroundLocation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    StoredBackgroundLocation 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 fieldDeliveredToJS = clazz->getField<jboolean>("deliveredToJS");
+      jboolean deliveredToJS = this->getFieldValue(fieldDeliveredToJS);
+      static const auto fieldSynced = clazz->getField<jboolean>("synced");
+      jboolean synced = this->getFieldValue(fieldSynced);
+      static const auto fieldCreatedAt = clazz->getField<double>("createdAt");
+      double createdAt = this->getFieldValue(fieldCreatedAt);
+      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 StoredBackgroundLocation(
+        id->toStdString(),
+        static_cast<bool>(deliveredToJS),
+        static_cast<bool>(synced),
+        createdAt,
+        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<JStoredBackgroundLocation::javaobject> fromCpp(const StoredBackgroundLocation& value) {
+      using JSignature = JStoredBackgroundLocation(jni::alias_ref<jni::JString>, jboolean, jboolean, double, 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,
+        jni::make_jstring(value.id),
+        value.deliveredToJS,
+        value.synced,
+        value.createdAt,
+        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++/JVariant_NullType_Boolean_String_Double.cpp

@@ -0,0 +1,34 @@
+///
+/// JVariant_NullType_Boolean_String_Double.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_Boolean_String_Double.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+  /**
+   * Converts JVariant_NullType_Boolean_String_Double to std::variant<nitro::NullType, bool, std::string, double>
+   */
+  std::variant<nitro::NullType, bool, std::string, double> JVariant_NullType_Boolean_String_Double::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_Boolean_String_Double_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_Boolean_String_Double_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_Boolean_String_Double_impl::Second::javaClassStatic())) {
+      // It's a `bool`
+      auto jniValue = static_cast<const JVariant_NullType_Boolean_String_Double_impl::Second*>(this)->getValue();
+      return static_cast<bool>(jniValue);
+    } else if (isInstanceOf(JVariant_NullType_Boolean_String_Double_impl::Third::javaClassStatic())) {
+      // It's a `std::string`
+      auto jniValue = static_cast<const JVariant_NullType_Boolean_String_Double_impl::Third*>(this)->getValue();
+      return jniValue->toStdString();
+    } else if (isInstanceOf(JVariant_NullType_Boolean_String_Double_impl::Fourth::javaClassStatic())) {
+      // It's a `double`
+      auto jniValue = static_cast<const JVariant_NullType_Boolean_String_Double_impl::Fourth*>(this)->getValue();
+      return jniValue;
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::nitrogeolocation