react-native-nitro-geolocation 1.1.3 → 1.2.0

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

@@ -9,49 +9,116 @@
 
 // Forward declaration of `PermissionStatus` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class PermissionStatus; }
-// Forward declaration of `GeolocationResponse` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
-// Forward declaration of `GeolocationCoordinates` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
-// Forward declaration of `ModernGeolocationConfiguration` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct ModernGeolocationConfiguration; }
+// Forward declaration of `LocationProviderStatus` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationProviderStatus; }
+// Forward declaration of `LocationAvailability` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAvailability; }
+// Forward declaration of `AccuracyAuthorization` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AccuracyAuthorization; }
+// Forward declaration of `GeolocationConfiguration` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationConfiguration; }
 // Forward declaration of `AuthorizationLevel` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevel; }
 // Forward declaration of `LocationProvider` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { enum class LocationProvider; }
-// Forward declaration of `LocationRequestOptions` to properly resolve imports.
-namespace margelo::nitro::nitrogeolocation { struct LocationRequestOptions; }
 // Forward declaration of `LocationError` to properly resolve imports.
 namespace margelo::nitro::nitrogeolocation { struct LocationError; }
+// Forward declaration of `LocationSettingsOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationSettingsOptions; }
+// Forward declaration of `LocationAccuracyOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationAccuracyOptions; }
+// Forward declaration of `AndroidAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidAccuracyPreset; }
+// Forward declaration of `IOSAccuracyPreset` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSAccuracyPreset; }
+// Forward declaration of `GeolocationResponse` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// Forward declaration of `GeolocationCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
+// Forward declaration of `LocationProviderUsed` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderUsed; }
+// Forward declaration of `LocationRequestOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct LocationRequestOptions; }
+// Forward declaration of `AndroidGranularity` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AndroidGranularity; }
+// Forward declaration of `IOSActivityType` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class IOSActivityType; }
+// Forward declaration of `GeocodedLocation` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeocodedLocation; }
+// Forward declaration of `GeocodingCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeocodingCoordinates; }
+// Forward declaration of `ReverseGeocodedAddress` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct ReverseGeocodedAddress; }
+// Forward declaration of `Heading` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct Heading; }
+// Forward declaration of `HeadingOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct HeadingOptions; }
 
 #include "PermissionStatus.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JPermissionStatus.hpp"
-#include "GeolocationResponse.hpp"
-#include "JGeolocationResponse.hpp"
-#include "GeolocationCoordinates.hpp"
-#include "JGeolocationCoordinates.hpp"
-#include <NitroModules/Null.hpp>
-#include <variant>
+#include "LocationProviderStatus.hpp"
+#include "JLocationProviderStatus.hpp"
 #include <optional>
-#include "JNullableDouble.hpp"
-#include <NitroModules/JNull.hpp>
+#include "LocationAvailability.hpp"
+#include "JLocationAvailability.hpp"
 #include <string>
-#include "ModernGeolocationConfiguration.hpp"
-#include "JModernGeolocationConfiguration.hpp"
+#include "AccuracyAuthorization.hpp"
+#include "JAccuracyAuthorization.hpp"
+#include "GeolocationConfiguration.hpp"
+#include "JGeolocationConfiguration.hpp"
 #include "AuthorizationLevel.hpp"
 #include "JAuthorizationLevel.hpp"
 #include "LocationProvider.hpp"
 #include "JLocationProvider.hpp"
-#include "LocationRequestOptions.hpp"
-#include "JLocationRequestOptions.hpp"
 #include <functional>
-#include "JFunc_void_GeolocationResponse.hpp"
+#include "JFunc_void_PermissionStatus.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include "LocationError.hpp"
 #include "JFunc_void_LocationError.hpp"
 #include "JLocationError.hpp"
+#include "JFunc_void_LocationProviderStatus.hpp"
+#include "LocationSettingsOptions.hpp"
+#include "JLocationSettingsOptions.hpp"
+#include "LocationAccuracyOptions.hpp"
+#include "JLocationAccuracyOptions.hpp"
+#include "AndroidAccuracyPreset.hpp"
+#include "JAndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "JIOSAccuracyPreset.hpp"
+#include "JFunc_void_AccuracyAuthorization.hpp"
+#include "GeolocationResponse.hpp"
+#include "JFunc_void_GeolocationResponse.hpp"
+#include "JGeolocationResponse.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+#include "LocationProviderUsed.hpp"
+#include "JLocationProviderUsed.hpp"
+#include "LocationRequestOptions.hpp"
+#include "JLocationRequestOptions.hpp"
+#include "AndroidGranularity.hpp"
+#include "JAndroidGranularity.hpp"
+#include "IOSActivityType.hpp"
+#include "JIOSActivityType.hpp"
+#include "GeocodedLocation.hpp"
+#include <vector>
+#include "JFunc_void_std__vector_GeocodedLocation_.hpp"
+#include "JGeocodedLocation.hpp"
+#include "GeocodingCoordinates.hpp"
+#include "JGeocodingCoordinates.hpp"
+#include "ReverseGeocodedAddress.hpp"
+#include "JFunc_void_std__vector_ReverseGeocodedAddress_.hpp"
+#include "JReverseGeocodedAddress.hpp"
+#include "Heading.hpp"
+#include "JFunc_void_Heading.hpp"
+#include "JHeading.hpp"
+#include "HeadingOptions.hpp"
+#include "JHeadingOptions.hpp"
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -86,9 +153,9 @@ namespace margelo::nitro::nitrogeolocation {
   
 
   // Methods
-  void JHybridNitroGeolocationSpec::setConfiguration(const ModernGeolocationConfiguration& config) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JModernGeolocationConfiguration> /* config */)>("setConfiguration");
-    method(_javaPart, JModernGeolocationConfiguration::fromCpp(config));
+  void JHybridNitroGeolocationSpec::setConfiguration(const GeolocationConfiguration& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JGeolocationConfiguration> /* config */)>("setConfiguration");
+    method(_javaPart, JGeolocationConfiguration::fromCpp(config));
   }
   std::shared_ptr<Promise<PermissionStatus>> JHybridNitroGeolocationSpec::checkPermission() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("checkPermission");
@@ -106,13 +173,49 @@ namespace margelo::nitro::nitrogeolocation {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<PermissionStatus>> JHybridNitroGeolocationSpec::requestPermission() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestPermission");
+  void JHybridNitroGeolocationSpec::requestPermission(const std::function<void(PermissionStatus /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_PermissionStatus::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */)>("requestPermission_cxx");
+    method(_javaPart, JFunc_void_PermissionStatus_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<bool>> JHybridNitroGeolocationSpec::hasServicesEnabled() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("hasServicesEnabled");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<LocationProviderStatus>> JHybridNitroGeolocationSpec::getProviderStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getProviderStatus");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<LocationProviderStatus>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JLocationProviderStatus>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<LocationAvailability>> JHybridNitroGeolocationSpec::getLocationAvailability() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getLocationAvailability");
     auto __result = method(_javaPart);
     return [&]() {
-      auto __promise = Promise<PermissionStatus>::create();
+      auto __promise = Promise<LocationAvailability>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<JPermissionStatus>(__boxedResult);
+        auto __result = jni::static_ref_cast<JLocationAvailability>(__boxedResult);
         __promise->resolve(__result->toCpp());
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
@@ -122,13 +225,17 @@ namespace margelo::nitro::nitrogeolocation {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<GeolocationResponse>> JHybridNitroGeolocationSpec::getCurrentPosition(const std::optional<LocationRequestOptions>& options) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLocationRequestOptions> /* options */)>("getCurrentPosition");
-    auto __result = method(_javaPart, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);
+  void JHybridNitroGeolocationSpec::requestLocationSettings(const std::function<void(const LocationProviderStatus& /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationSettingsOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_LocationProviderStatus::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JLocationSettingsOptions> /* options */)>("requestLocationSettings_cxx");
+    method(_javaPart, JFunc_void_LocationProviderStatus_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JLocationSettingsOptions::fromCpp(options.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<AccuracyAuthorization>> JHybridNitroGeolocationSpec::getAccuracyAuthorization() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getAccuracyAuthorization");
+    auto __result = method(_javaPart);
     return [&]() {
-      auto __promise = Promise<GeolocationResponse>::create();
+      auto __promise = Promise<AccuracyAuthorization>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
-        auto __result = jni::static_ref_cast<JGeolocationResponse>(__boxedResult);
+        auto __result = jni::static_ref_cast<JAccuracyAuthorization>(__boxedResult);
         __promise->resolve(__result->toCpp());
       });
       __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
@@ -138,6 +245,35 @@ namespace margelo::nitro::nitrogeolocation {
       return __promise;
     }();
   }
+  void JHybridNitroGeolocationSpec::requestTemporaryFullAccuracy(const std::string& purposeKey, const std::function<void(AccuracyAuthorization /* authorization */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* purposeKey */, jni::alias_ref<JFunc_void_AccuracyAuthorization::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */)>("requestTemporaryFullAccuracy_cxx");
+    method(_javaPart, jni::make_jstring(purposeKey), JFunc_void_AccuracyAuthorization_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationSpec::getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JLocationRequestOptions> /* options */)>("getCurrentPosition_cxx");
+    method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationSpec::getLastKnownPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JLocationRequestOptions> /* options */)>("getLastKnownPosition_cxx");
+    method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationSpec::geocode(const std::string& address, const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* address */, jni::alias_ref<JFunc_void_std__vector_GeocodedLocation_::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */)>("geocode_cxx");
+    method(_javaPart, jni::make_jstring(address), JFunc_void_std__vector_GeocodedLocation__cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationSpec::reverseGeocode(const GeocodingCoordinates& coords, const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JGeocodingCoordinates> /* coords */, jni::alias_ref<JFunc_void_std__vector_ReverseGeocodedAddress_::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */)>("reverseGeocode_cxx");
+    method(_javaPart, JGeocodingCoordinates::fromCpp(coords), JFunc_void_std__vector_ReverseGeocodedAddress__cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationSpec::getHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_Heading::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */)>("getHeading_cxx");
+    method(_javaPart, JFunc_void_Heading_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  std::string JHybridNitroGeolocationSpec::watchHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<HeadingOptions>& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JFunc_void_Heading::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JHeadingOptions> /* options */)>("watchHeading_cxx");
+    auto __result = method(_javaPart, JFunc_void_Heading_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JHeadingOptions::fromCpp(options.value()) : nullptr);
+    return __result->toStdString();
+  }
   std::string JHybridNitroGeolocationSpec::watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_LocationError::javaobject> /* error */, jni::alias_ref<JLocationRequestOptions> /* options */)>("watchPosition_cxx");
     auto __result = method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_LocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JLocationRequestOptions::fromCpp(options.value()) : nullptr);

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

@@ -54,10 +54,21 @@ namespace margelo::nitro::nitrogeolocation {
 
   public:
     // Methods
-    void setConfiguration(const ModernGeolocationConfiguration& config) override;
+    void setConfiguration(const GeolocationConfiguration& config) override;
     std::shared_ptr<Promise<PermissionStatus>> checkPermission() override;
-    std::shared_ptr<Promise<PermissionStatus>> requestPermission() override;
-    std::shared_ptr<Promise<GeolocationResponse>> getCurrentPosition(const std::optional<LocationRequestOptions>& options) override;
+    void requestPermission(const std::function<void(PermissionStatus /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override;
+    std::shared_ptr<Promise<bool>> hasServicesEnabled() override;
+    std::shared_ptr<Promise<LocationProviderStatus>> getProviderStatus() override;
+    std::shared_ptr<Promise<LocationAvailability>> getLocationAvailability() override;
+    void requestLocationSettings(const std::function<void(const LocationProviderStatus& /* status */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationSettingsOptions>& options) override;
+    std::shared_ptr<Promise<AccuracyAuthorization>> getAccuracyAuthorization() override;
+    void requestTemporaryFullAccuracy(const std::string& purposeKey, const std::function<void(AccuracyAuthorization /* authorization */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override;
+    void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) override;
+    void getLastKnownPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) override;
+    void geocode(const std::string& address, const std::function<void(const std::vector<GeocodedLocation>& /* locations */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override;
+    void reverseGeocode(const GeocodingCoordinates& coords, const std::function<void(const std::vector<ReverseGeocodedAddress>& /* addresses */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override;
+    void getHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error) override;
+    std::string watchHeading(const std::function<void(const Heading& /* heading */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<HeadingOptions>& options) override;
     std::string watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const LocationError& /* error */)>>& error, const std::optional<LocationRequestOptions>& options) override;
     void unwatch(const std::string& token) override;
     void stopObserving() override;

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

@@ -0,0 +1,73 @@
+///
+/// JIOSAccuracyPreset.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 "IOSAccuracyPreset.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSAccuracyPreset" and the the Kotlin enum "IOSAccuracyPreset".
+   */
+  struct JIOSAccuracyPreset final: public jni::JavaClass<JIOSAccuracyPreset> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/IOSAccuracyPreset;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSAccuracyPreset.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSAccuracyPreset toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSAccuracyPreset>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSAccuracyPreset> fromCpp(IOSAccuracyPreset value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case IOSAccuracyPreset::BESTFORNAVIGATION:
+          static const auto fieldBESTFORNAVIGATION = clazz->getStaticField<JIOSAccuracyPreset>("BESTFORNAVIGATION");
+          return clazz->getStaticFieldValue(fieldBESTFORNAVIGATION);
+        case IOSAccuracyPreset::BEST:
+          static const auto fieldBEST = clazz->getStaticField<JIOSAccuracyPreset>("BEST");
+          return clazz->getStaticFieldValue(fieldBEST);
+        case IOSAccuracyPreset::NEARESTTENMETERS:
+          static const auto fieldNEARESTTENMETERS = clazz->getStaticField<JIOSAccuracyPreset>("NEARESTTENMETERS");
+          return clazz->getStaticFieldValue(fieldNEARESTTENMETERS);
+        case IOSAccuracyPreset::HUNDREDMETERS:
+          static const auto fieldHUNDREDMETERS = clazz->getStaticField<JIOSAccuracyPreset>("HUNDREDMETERS");
+          return clazz->getStaticFieldValue(fieldHUNDREDMETERS);
+        case IOSAccuracyPreset::KILOMETER:
+          static const auto fieldKILOMETER = clazz->getStaticField<JIOSAccuracyPreset>("KILOMETER");
+          return clazz->getStaticFieldValue(fieldKILOMETER);
+        case IOSAccuracyPreset::THREEKILOMETERS:
+          static const auto fieldTHREEKILOMETERS = clazz->getStaticField<JIOSAccuracyPreset>("THREEKILOMETERS");
+          return clazz->getStaticFieldValue(fieldTHREEKILOMETERS);
+        case IOSAccuracyPreset::REDUCED:
+          static const auto fieldREDUCED = clazz->getStaticField<JIOSAccuracyPreset>("REDUCED");
+          return clazz->getStaticFieldValue(fieldREDUCED);
+        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++/JIOSActivityType.hpp

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

@@ -0,0 +1,65 @@
+///
+/// JLocationAccuracyOptions.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 "LocationAccuracyOptions.hpp"
+
+#include "AndroidAccuracyPreset.hpp"
+#include "IOSAccuracyPreset.hpp"
+#include "JAndroidAccuracyPreset.hpp"
+#include "JIOSAccuracyPreset.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationAccuracyOptions" and the the Kotlin data class "LocationAccuracyOptions".
+   */
+  struct JLocationAccuracyOptions final: public jni::JavaClass<JLocationAccuracyOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/LocationAccuracyOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationAccuracyOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationAccuracyOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAndroid = clazz->getField<JAndroidAccuracyPreset>("android");
+      jni::local_ref<JAndroidAccuracyPreset> android = this->getFieldValue(fieldAndroid);
+      static const auto fieldIos = clazz->getField<JIOSAccuracyPreset>("ios");
+      jni::local_ref<JIOSAccuracyPreset> ios = this->getFieldValue(fieldIos);
+      return LocationAccuracyOptions(
+        android != nullptr ? std::make_optional(android->toCpp()) : std::nullopt,
+        ios != nullptr ? std::make_optional(ios->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<JLocationAccuracyOptions::javaobject> fromCpp(const LocationAccuracyOptions& value) {
+      using JSignature = JLocationAccuracyOptions(jni::alias_ref<JAndroidAccuracyPreset>, jni::alias_ref<JIOSAccuracyPreset>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.android.has_value() ? JAndroidAccuracyPreset::fromCpp(value.android.value()) : nullptr,
+        value.ios.has_value() ? JIOSAccuracyPreset::fromCpp(value.ios.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,62 @@
+///
+/// JLocationAvailability.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 "LocationAvailability.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationAvailability" and the the Kotlin data class "LocationAvailability".
+   */
+  struct JLocationAvailability final: public jni::JavaClass<JLocationAvailability> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/LocationAvailability;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationAvailability by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationAvailability toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAvailable = clazz->getField<jboolean>("available");
+      jboolean available = this->getFieldValue(fieldAvailable);
+      static const auto fieldReason = clazz->getField<jni::JString>("reason");
+      jni::local_ref<jni::JString> reason = this->getFieldValue(fieldReason);
+      return LocationAvailability(
+        static_cast<bool>(available),
+        reason != nullptr ? std::make_optional(reason->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<JLocationAvailability::javaobject> fromCpp(const LocationAvailability& value) {
+      using JSignature = JLocationAvailability(jboolean, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.available,
+        value.reason.has_value() ? jni::make_jstring(value.reason.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,77 @@
+///
+/// JLocationProviderStatus.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 "LocationProviderStatus.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationProviderStatus" and the the Kotlin data class "LocationProviderStatus".
+   */
+  struct JLocationProviderStatus final: public jni::JavaClass<JLocationProviderStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/LocationProviderStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationProviderStatus by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationProviderStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLocationServicesEnabled = clazz->getField<jboolean>("locationServicesEnabled");
+      jboolean locationServicesEnabled = this->getFieldValue(fieldLocationServicesEnabled);
+      static const auto fieldBackgroundModeEnabled = clazz->getField<jboolean>("backgroundModeEnabled");
+      jboolean backgroundModeEnabled = this->getFieldValue(fieldBackgroundModeEnabled);
+      static const auto fieldGpsAvailable = clazz->getField<jni::JBoolean>("gpsAvailable");
+      jni::local_ref<jni::JBoolean> gpsAvailable = this->getFieldValue(fieldGpsAvailable);
+      static const auto fieldNetworkAvailable = clazz->getField<jni::JBoolean>("networkAvailable");
+      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 fieldGoogleLocationAccuracyEnabled = clazz->getField<jni::JBoolean>("googleLocationAccuracyEnabled");
+      jni::local_ref<jni::JBoolean> googleLocationAccuracyEnabled = this->getFieldValue(fieldGoogleLocationAccuracyEnabled);
+      return LocationProviderStatus(
+        static_cast<bool>(locationServicesEnabled),
+        static_cast<bool>(backgroundModeEnabled),
+        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,
+        googleLocationAccuracyEnabled != nullptr ? std::make_optional(static_cast<bool>(googleLocationAccuracyEnabled->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<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>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.locationServicesEnabled,
+        value.backgroundModeEnabled,
+        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.googleLocationAccuracyEnabled.has_value() ? jni::JBoolean::valueOf(value.googleLocationAccuracyEnabled.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation