react-native-nitro-geolocation 1.1.4 → 1.2.0

package/ios/NitroGeolocationCompat.swift

@@ -3,7 +3,7 @@ import CoreLocation
 class NitroGeolocationCompat: HybridNitroGeolocationCompatSpec {
     // MARK: - Properties
 
-    private var configuration: RNConfigurationInternal = RNConfigurationInternal(
+    private var configuration: CompatGeolocationConfigurationInternal = CompatGeolocationConfigurationInternal(
         skipPermissionRequests: false,
         authorizationLevel: nil,
         enableBackgroundLocationUpdates: nil,
@@ -14,11 +14,11 @@ class NitroGeolocationCompat: HybridNitroGeolocationCompatSpec {
 
     // MARK: - Public API
 
-    public func setRNConfiguration(config: RNConfigurationInternal) throws {
+    public func setRNConfiguration(config: CompatGeolocationConfigurationInternal) throws {
         configuration = config
     }
 
-    public func requestAuthorization(success: (() -> Void)?, error: ((GeolocationError) -> Void)?)
+    public func requestAuthorization(success: (() -> Void)?, error: ((CompatGeolocationError) -> Void)?)
         throws
     {
         let authType = determineAuthorizationType()
@@ -35,8 +35,8 @@ class NitroGeolocationCompat: HybridNitroGeolocationCompatSpec {
     }
 
     public func getCurrentPosition(
-        success: @escaping (GeolocationResponse) -> Void, error: ((GeolocationError) -> Void)?,
-        options: GeolocationOptions?
+        success: @escaping (CompatGeolocationResponse) -> Void, error: ((CompatGeolocationError) -> Void)?,
+        options: CompatGeolocationOptions?
     ) throws {
         // Fast path: check cached location immediately (no dispatch overhead!)
         let parsedOptions = LocationManager.ParsedOptions.parse(from: options)
@@ -52,8 +52,8 @@ class NitroGeolocationCompat: HybridNitroGeolocationCompatSpec {
     }
 
     public func watchPosition(
-        success: @escaping (GeolocationResponse) -> Void, error: ((GeolocationError) -> Void)?,
-        options: GeolocationOptions?
+        success: @escaping (CompatGeolocationResponse) -> Void, error: ((CompatGeolocationError) -> Void)?,
+        options: CompatGeolocationOptions?
     ) throws -> Double {
         return locationManager.watchPosition(success: success, error: error, options: options)
     }

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

@@ -0,0 +1,61 @@
+///
+/// JAccuracyAuthorization.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 "AccuracyAuthorization.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AccuracyAuthorization" and the the Kotlin enum "AccuracyAuthorization".
+   */
+  struct JAccuracyAuthorization final: public jni::JavaClass<JAccuracyAuthorization> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AccuracyAuthorization;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AccuracyAuthorization.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AccuracyAuthorization toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AccuracyAuthorization>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAccuracyAuthorization> fromCpp(AccuracyAuthorization value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AccuracyAuthorization::REDUCED:
+          static const auto fieldREDUCED = clazz->getStaticField<JAccuracyAuthorization>("REDUCED");
+          return clazz->getStaticFieldValue(fieldREDUCED);
+        case AccuracyAuthorization::FULL:
+          static const auto fieldFULL = clazz->getStaticField<JAccuracyAuthorization>("FULL");
+          return clazz->getStaticFieldValue(fieldFULL);
+        case AccuracyAuthorization::UNKNOWN:
+          static const auto fieldUNKNOWN = clazz->getStaticField<JAccuracyAuthorization>("UNKNOWN");
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        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++/JAndroidAccuracyPreset.hpp

@@ -0,0 +1,64 @@
+///
+/// JAndroidAccuracyPreset.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 "AndroidAccuracyPreset.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidAccuracyPreset" and the the Kotlin enum "AndroidAccuracyPreset".
+   */
+  struct JAndroidAccuracyPreset final: public jni::JavaClass<JAndroidAccuracyPreset> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AndroidAccuracyPreset;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidAccuracyPreset.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidAccuracyPreset toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidAccuracyPreset>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidAccuracyPreset> fromCpp(AndroidAccuracyPreset value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidAccuracyPreset::HIGH:
+          static const auto fieldHIGH = clazz->getStaticField<JAndroidAccuracyPreset>("HIGH");
+          return clazz->getStaticFieldValue(fieldHIGH);
+        case AndroidAccuracyPreset::BALANCED:
+          static const auto fieldBALANCED = clazz->getStaticField<JAndroidAccuracyPreset>("BALANCED");
+          return clazz->getStaticFieldValue(fieldBALANCED);
+        case AndroidAccuracyPreset::LOW:
+          static const auto fieldLOW = clazz->getStaticField<JAndroidAccuracyPreset>("LOW");
+          return clazz->getStaticFieldValue(fieldLOW);
+        case AndroidAccuracyPreset::PASSIVE:
+          static const auto fieldPASSIVE = clazz->getStaticField<JAndroidAccuracyPreset>("PASSIVE");
+          return clazz->getStaticFieldValue(fieldPASSIVE);
+        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++/JAndroidGranularity.hpp

@@ -0,0 +1,61 @@
+///
+/// JAndroidGranularity.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 "AndroidGranularity.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidGranularity" and the the Kotlin enum "AndroidGranularity".
+   */
+  struct JAndroidGranularity final: public jni::JavaClass<JAndroidGranularity> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AndroidGranularity;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidGranularity.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidGranularity toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidGranularity>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidGranularity> fromCpp(AndroidGranularity value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidGranularity::PERMISSION:
+          static const auto fieldPERMISSION = clazz->getStaticField<JAndroidGranularity>("PERMISSION");
+          return clazz->getStaticFieldValue(fieldPERMISSION);
+        case AndroidGranularity::COARSE:
+          static const auto fieldCOARSE = clazz->getStaticField<JAndroidGranularity>("COARSE");
+          return clazz->getStaticFieldValue(fieldCOARSE);
+        case AndroidGranularity::FINE:
+          static const auto fieldFINE = clazz->getStaticField<JAndroidGranularity>("FINE");
+          return clazz->getStaticFieldValue(fieldFINE);
+        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++/{JRNConfigurationInternal.hpp → JCompatGeolocationConfigurationInternal.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JRNConfigurationInternal.hpp
+/// JCompatGeolocationConfigurationInternal.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include "RNConfigurationInternal.hpp"
+#include "CompatGeolocationConfigurationInternal.hpp"
 
 #include "AuthorizationLevelInternal.hpp"
 #include "JAuthorizationLevelInternal.hpp"
@@ -21,19 +21,19 @@ namespace margelo::nitro::nitrogeolocation {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "RNConfigurationInternal" and the the Kotlin data class "RNConfigurationInternal".
+   * The C++ JNI bridge between the C++ struct "CompatGeolocationConfigurationInternal" and the the Kotlin data class "CompatGeolocationConfigurationInternal".
    */
-  struct JRNConfigurationInternal final: public jni::JavaClass<JRNConfigurationInternal> {
+  struct JCompatGeolocationConfigurationInternal final: public jni::JavaClass<JCompatGeolocationConfigurationInternal> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/RNConfigurationInternal;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/CompatGeolocationConfigurationInternal;";
 
   public:
     /**
-     * Convert this Java/Kotlin-based struct to the C++ struct RNConfigurationInternal by copying all values to C++.
+     * Convert this Java/Kotlin-based struct to the C++ struct CompatGeolocationConfigurationInternal by copying all values to C++.
      */
     [[maybe_unused]]
     [[nodiscard]]
-    RNConfigurationInternal toCpp() const {
+    CompatGeolocationConfigurationInternal toCpp() const {
       static const auto clazz = javaClassStatic();
       static const auto fieldSkipPermissionRequests = clazz->getField<jboolean>("skipPermissionRequests");
       jboolean skipPermissionRequests = this->getFieldValue(fieldSkipPermissionRequests);
@@ -43,7 +43,7 @@ namespace margelo::nitro::nitrogeolocation {
       jni::local_ref<jni::JBoolean> enableBackgroundLocationUpdates = this->getFieldValue(fieldEnableBackgroundLocationUpdates);
       static const auto fieldLocationProvider = clazz->getField<JLocationProviderInternal>("locationProvider");
       jni::local_ref<JLocationProviderInternal> locationProvider = this->getFieldValue(fieldLocationProvider);
-      return RNConfigurationInternal(
+      return CompatGeolocationConfigurationInternal(
         static_cast<bool>(skipPermissionRequests),
         authorizationLevel != nullptr ? std::make_optional(authorizationLevel->toCpp()) : std::nullopt,
         enableBackgroundLocationUpdates != nullptr ? std::make_optional(static_cast<bool>(enableBackgroundLocationUpdates->value())) : std::nullopt,
@@ -56,8 +56,8 @@ namespace margelo::nitro::nitrogeolocation {
      * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
      */
     [[maybe_unused]]
-    static jni::local_ref<JRNConfigurationInternal::javaobject> fromCpp(const RNConfigurationInternal& value) {
-      using JSignature = JRNConfigurationInternal(jboolean, jni::alias_ref<JAuthorizationLevelInternal>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JLocationProviderInternal>);
+    static jni::local_ref<JCompatGeolocationConfigurationInternal::javaobject> fromCpp(const CompatGeolocationConfigurationInternal& value) {
+      using JSignature = JCompatGeolocationConfigurationInternal(jboolean, jni::alias_ref<JAuthorizationLevelInternal>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JLocationProviderInternal>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(

package/nitrogen/generated/android/c++/{JGeolocationError.hpp → JCompatGeolocationError.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JGeolocationError.hpp
+/// JCompatGeolocationError.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include "GeolocationError.hpp"
+#include "CompatGeolocationError.hpp"
 
 #include <string>
 
@@ -17,19 +17,19 @@ namespace margelo::nitro::nitrogeolocation {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "GeolocationError" and the the Kotlin data class "GeolocationError".
+   * The C++ JNI bridge between the C++ struct "CompatGeolocationError" and the the Kotlin data class "CompatGeolocationError".
    */
-  struct JGeolocationError final: public jni::JavaClass<JGeolocationError> {
+  struct JCompatGeolocationError final: public jni::JavaClass<JCompatGeolocationError> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/GeolocationError;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/CompatGeolocationError;";
 
   public:
     /**
-     * Convert this Java/Kotlin-based struct to the C++ struct GeolocationError by copying all values to C++.
+     * Convert this Java/Kotlin-based struct to the C++ struct CompatGeolocationError by copying all values to C++.
      */
     [[maybe_unused]]
     [[nodiscard]]
-    GeolocationError toCpp() const {
+    CompatGeolocationError toCpp() const {
       static const auto clazz = javaClassStatic();
       static const auto fieldCode = clazz->getField<double>("code");
       double code = this->getFieldValue(fieldCode);
@@ -41,7 +41,7 @@ namespace margelo::nitro::nitrogeolocation {
       double POSITION_UNAVAILABLE = this->getFieldValue(fieldPOSITION_UNAVAILABLE);
       static const auto fieldTIMEOUT = clazz->getField<double>("TIMEOUT");
       double TIMEOUT = this->getFieldValue(fieldTIMEOUT);
-      return GeolocationError(
+      return CompatGeolocationError(
         code,
         message->toStdString(),
         PERMISSION_DENIED,
@@ -55,8 +55,8 @@ namespace margelo::nitro::nitrogeolocation {
      * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
      */
     [[maybe_unused]]
-    static jni::local_ref<JGeolocationError::javaobject> fromCpp(const GeolocationError& value) {
-      using JSignature = JGeolocationError(double, jni::alias_ref<jni::JString>, double, double, double);
+    static jni::local_ref<JCompatGeolocationError::javaobject> fromCpp(const CompatGeolocationError& value) {
+      using JSignature = JCompatGeolocationError(double, jni::alias_ref<jni::JString>, double, double, double);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(

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

@@ -0,0 +1,105 @@
+///
+/// JCompatGeolocationOptions.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 "CompatGeolocationOptions.hpp"
+
+#include "AndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "IOSActivityType.hpp"
+#include "JAndroidAccuracyPreset.hpp"
+#include "JIOSAccuracyPreset.hpp"
+#include "JIOSActivityType.hpp"
+#include "JLocationAccuracyOptions.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "CompatGeolocationOptions" and the the Kotlin data class "CompatGeolocationOptions".
+   */
+  struct JCompatGeolocationOptions final: public jni::JavaClass<JCompatGeolocationOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/CompatGeolocationOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct CompatGeolocationOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CompatGeolocationOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTimeout = clazz->getField<jni::JDouble>("timeout");
+      jni::local_ref<jni::JDouble> timeout = this->getFieldValue(fieldTimeout);
+      static const auto fieldMaximumAge = clazz->getField<jni::JDouble>("maximumAge");
+      jni::local_ref<jni::JDouble> maximumAge = this->getFieldValue(fieldMaximumAge);
+      static const auto fieldEnableHighAccuracy = clazz->getField<jni::JBoolean>("enableHighAccuracy");
+      jni::local_ref<jni::JBoolean> enableHighAccuracy = this->getFieldValue(fieldEnableHighAccuracy);
+      static const auto fieldAccuracy = clazz->getField<JLocationAccuracyOptions>("accuracy");
+      jni::local_ref<JLocationAccuracyOptions> accuracy = this->getFieldValue(fieldAccuracy);
+      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 fieldUseSignificantChanges = clazz->getField<jni::JBoolean>("useSignificantChanges");
+      jni::local_ref<jni::JBoolean> useSignificantChanges = this->getFieldValue(fieldUseSignificantChanges);
+      static const auto fieldActivityType = clazz->getField<JIOSActivityType>("activityType");
+      jni::local_ref<JIOSActivityType> 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);
+      return CompatGeolocationOptions(
+        timeout != nullptr ? std::make_optional(timeout->value()) : std::nullopt,
+        maximumAge != nullptr ? std::make_optional(maximumAge->value()) : std::nullopt,
+        enableHighAccuracy != nullptr ? std::make_optional(static_cast<bool>(enableHighAccuracy->value())) : std::nullopt,
+        accuracy != nullptr ? std::make_optional(accuracy->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,
+        useSignificantChanges != nullptr ? std::make_optional(static_cast<bool>(useSignificantChanges->value())) : std::nullopt,
+        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
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JCompatGeolocationOptions::javaobject> fromCpp(const CompatGeolocationOptions& value) {
+      using JSignature = JCompatGeolocationOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JLocationAccuracyOptions>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JIOSActivityType>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.timeout.has_value() ? jni::JDouble::valueOf(value.timeout.value()) : nullptr,
+        value.maximumAge.has_value() ? jni::JDouble::valueOf(value.maximumAge.value()) : nullptr,
+        value.enableHighAccuracy.has_value() ? jni::JBoolean::valueOf(value.enableHighAccuracy.value()) : nullptr,
+        value.accuracy.has_value() ? JLocationAccuracyOptions::fromCpp(value.accuracy.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.useSignificantChanges.has_value() ? jni::JBoolean::valueOf(value.useSignificantChanges.value()) : nullptr,
+        value.activityType.has_value() ? JIOSActivityType::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
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,67 @@
+///
+/// JCompatGeolocationResponse.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 "CompatGeolocationResponse.hpp"
+
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <variant>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "CompatGeolocationResponse" and the the Kotlin data class "CompatGeolocationResponse".
+   */
+  struct JCompatGeolocationResponse final: public jni::JavaClass<JCompatGeolocationResponse> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/CompatGeolocationResponse;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct CompatGeolocationResponse by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CompatGeolocationResponse toCpp() const {
+      static const auto clazz = javaClassStatic();
+      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 CompatGeolocationResponse(
+        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<JCompatGeolocationResponse::javaobject> fromCpp(const CompatGeolocationResponse& value) {
+      using JSignature = JCompatGeolocationResponse(jni::alias_ref<JGeolocationCoordinates>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JGeolocationCoordinates::fromCpp(value.coords),
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

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