react-native-nitro-geolocation 0.1.2 → 0.3.0

package/ios/NitroGeolocationCompat.swift

@@ -0,0 +1,109 @@
+import CoreLocation
+
+class NitroGeolocationCompat: HybridNitroGeolocationCompatSpec {
+    // MARK: - Properties
+
+    private var configuration: RNConfigurationInternal = RNConfigurationInternal(
+        skipPermissionRequests: false,
+        authorizationLevel: nil,
+        enableBackgroundLocationUpdates: nil,
+        locationProvider: nil
+    )
+
+    private let locationManager = LocationManager()
+
+    // MARK: - Public API
+
+    public func setRNConfiguration(config: RNConfigurationInternal) throws {
+        configuration = config
+    }
+
+    public func requestAuthorization(success: (() -> Void)?, error: ((GeolocationError) -> Void)?)
+        throws
+    {
+        let authType = determineAuthorizationType()
+        let skipPermissionRequests = configuration.skipPermissionRequests
+        let enableBackgroundLocationUpdates = configuration.enableBackgroundLocationUpdates ?? false
+
+        locationManager.requestAuthorization(
+            authType: authType,
+            skipPermissionRequests: skipPermissionRequests,
+            enableBackgroundLocationUpdates: enableBackgroundLocationUpdates,
+            success: success,
+            error: error
+        )
+    }
+
+    public func getCurrentPosition(
+        success: @escaping (GeolocationResponse) -> Void, error: ((GeolocationError) -> Void)?,
+        options: GeolocationOptions?
+    ) throws {
+        // Fast path: check cached location immediately (no dispatch overhead!)
+        let parsedOptions = LocationManager.ParsedOptions.parse(from: options)
+
+        if let cached = locationManager.lastLocation,
+           locationManager.isCachedLocationValid(cached, options: parsedOptions) {
+            success(locationManager.locationToPosition(cached))
+            return
+        }
+
+        // Slow path: need GPS
+        locationManager.getCurrentPosition(success: success, error: error, options: options)
+    }
+
+    public func watchPosition(
+        success: @escaping (GeolocationResponse) -> Void, error: ((GeolocationError) -> Void)?,
+        options: GeolocationOptions?
+    ) throws -> Double {
+        return locationManager.watchPosition(success: success, error: error, options: options)
+    }
+
+    public func clearWatch(watchId: Double) throws {
+        locationManager.clearWatch(watchId: watchId)
+    }
+
+    public func stopObserving() throws {
+        locationManager.stopObserving()
+    }
+
+    // MARK: - Authorization Helpers
+
+    private func determineAuthorizationType() -> LocationManager.AuthorizationType {
+        guard let authLevel = configuration.authorizationLevel else {
+            return determineAuthorizationTypeFromInfoPlist()
+        }
+
+        switch authLevel {
+        case .always:
+            return .always
+        case .wheninuse:
+            return .whenInUse
+        case .auto:
+            return determineAuthorizationTypeFromInfoPlist()
+        }
+    }
+
+    private func determineAuthorizationTypeFromInfoPlist() -> LocationManager.AuthorizationType {
+        if hasInfoPlistKey(for: .always) {
+            return .always
+        } else if hasInfoPlistKey(for: .whenInUse) {
+            return .whenInUse
+        }
+        return .none
+    }
+
+    private func hasInfoPlistKey(for type: LocationManager.AuthorizationType) -> Bool {
+        switch type {
+        case .always:
+            return Bundle.main.object(forInfoDictionaryKey: "NSLocationAlwaysUsageDescription")
+                != nil
+                || Bundle.main.object(
+                    forInfoDictionaryKey: "NSLocationAlwaysAndWhenInUseUsageDescription") != nil
+        case .whenInUse:
+            return Bundle.main.object(forInfoDictionaryKey: "NSLocationWhenInUseUsageDescription")
+                != nil
+        case .none:
+            return false
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+///
+/// JAuthorizationLevel.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AuthorizationLevel.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AuthorizationLevel" and the the Kotlin enum "AuthorizationLevel".
+   */
+  struct JAuthorizationLevel final: public jni::JavaClass<JAuthorizationLevel> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/AuthorizationLevel;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AuthorizationLevel.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AuthorizationLevel toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AuthorizationLevel>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAuthorizationLevel> fromCpp(AuthorizationLevel value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AuthorizationLevel::ALWAYS:
+          static const auto fieldALWAYS = clazz->getStaticField<JAuthorizationLevel>("ALWAYS");
+          return clazz->getStaticFieldValue(fieldALWAYS);
+        case AuthorizationLevel::WHENINUSE:
+          static const auto fieldWHENINUSE = clazz->getStaticField<JAuthorizationLevel>("WHENINUSE");
+          return clazz->getStaticFieldValue(fieldWHENINUSE);
+        case AuthorizationLevel::AUTO:
+          static const auto fieldAUTO = clazz->getStaticField<JAuthorizationLevel>("AUTO");
+          return clazz->getStaticFieldValue(fieldAUTO);
+        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++/JAuthorizationLevelInternal.hpp

@@ -41,16 +41,15 @@ namespace margelo::nitro::nitrogeolocation {
     [[maybe_unused]]
     static jni::alias_ref<JAuthorizationLevelInternal> fromCpp(AuthorizationLevelInternal value) {
       static const auto clazz = javaClassStatic();
-      static const auto fieldALWAYS = clazz->getStaticField<JAuthorizationLevelInternal>("ALWAYS");
-      static const auto fieldWHENINUSE = clazz->getStaticField<JAuthorizationLevelInternal>("WHENINUSE");
-      static const auto fieldAUTO = clazz->getStaticField<JAuthorizationLevelInternal>("AUTO");
-      
       switch (value) {
         case AuthorizationLevelInternal::ALWAYS:
+          static const auto fieldALWAYS = clazz->getStaticField<JAuthorizationLevelInternal>("ALWAYS");
           return clazz->getStaticFieldValue(fieldALWAYS);
         case AuthorizationLevelInternal::WHENINUSE:
+          static const auto fieldWHENINUSE = clazz->getStaticField<JAuthorizationLevelInternal>("WHENINUSE");
           return clazz->getStaticFieldValue(fieldWHENINUSE);
         case AuthorizationLevelInternal::AUTO:
+          static const auto fieldAUTO = clazz->getStaticField<JAuthorizationLevelInternal>("AUTO");
           return clazz->getStaticFieldValue(fieldAUTO);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));

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

@@ -11,6 +11,7 @@
 #include <functional>
 
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -37,7 +38,7 @@ namespace margelo::nitro::nitrogeolocation {
   /**
    * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
   public:
     static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
       return JFunc_void_cxx::newObjectCxxArgs(func);

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

@@ -12,6 +12,7 @@
 
 #include "GeolocationError.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JGeolocationError.hpp"
 #include <string>
 
@@ -40,7 +41,7 @@ namespace margelo::nitro::nitrogeolocation {
   /**
    * An implementation of Func_void_GeolocationError that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_GeolocationError_cxx final: public jni::HybridClass<JFunc_void_GeolocationError_cxx, JFunc_void_GeolocationError> {
+  class JFunc_void_GeolocationError_cxx final: public jni::HybridClass<JFunc_void_GeolocationError_cxx, JFunc_void_GeolocationError> {
   public:
     static jni::local_ref<JFunc_void_GeolocationError::javaobject> fromCpp(const std::function<void(const GeolocationError& /* error */)>& func) {
       return JFunc_void_GeolocationError_cxx::newObjectCxxArgs(func);

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

@@ -12,10 +12,15 @@
 
 #include "GeolocationResponse.hpp"
 #include <functional>
+#include <NitroModules/JNICallable.hpp>
 #include "JGeolocationResponse.hpp"
 #include "GeolocationCoordinates.hpp"
 #include "JGeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
 #include <optional>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -42,7 +47,7 @@ namespace margelo::nitro::nitrogeolocation {
   /**
    * An implementation of Func_void_GeolocationResponse that is backed by a C++ implementation (using `std::function<...>`)
    */
-  struct JFunc_void_GeolocationResponse_cxx final: public jni::HybridClass<JFunc_void_GeolocationResponse_cxx, JFunc_void_GeolocationResponse> {
+  class JFunc_void_GeolocationResponse_cxx final: public jni::HybridClass<JFunc_void_GeolocationResponse_cxx, JFunc_void_GeolocationResponse> {
   public:
     static jni::local_ref<JFunc_void_GeolocationResponse::javaobject> fromCpp(const std::function<void(const GeolocationResponse& /* position */)>& func) {
       return JFunc_void_GeolocationResponse_cxx::newObjectCxxArgs(func);

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

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

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

@@ -10,7 +10,11 @@
 #include <fbjni/fbjni.h>
 #include "GeolocationCoordinates.hpp"
 
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
 #include <optional>
+#include <variant>
 
 namespace margelo::nitro::nitrogeolocation {
 
@@ -35,24 +39,24 @@ namespace margelo::nitro::nitrogeolocation {
       double latitude = this->getFieldValue(fieldLatitude);
       static const auto fieldLongitude = clazz->getField<double>("longitude");
       double longitude = this->getFieldValue(fieldLongitude);
-      static const auto fieldAltitude = clazz->getField<jni::JDouble>("altitude");
-      jni::local_ref<jni::JDouble> altitude = this->getFieldValue(fieldAltitude);
+      static const auto fieldAltitude = clazz->getField<JNullableDouble>("altitude");
+      jni::local_ref<JNullableDouble> altitude = this->getFieldValue(fieldAltitude);
       static const auto fieldAccuracy = clazz->getField<double>("accuracy");
       double accuracy = this->getFieldValue(fieldAccuracy);
-      static const auto fieldAltitudeAccuracy = clazz->getField<jni::JDouble>("altitudeAccuracy");
-      jni::local_ref<jni::JDouble> altitudeAccuracy = this->getFieldValue(fieldAltitudeAccuracy);
-      static const auto fieldHeading = clazz->getField<jni::JDouble>("heading");
-      jni::local_ref<jni::JDouble> heading = this->getFieldValue(fieldHeading);
-      static const auto fieldSpeed = clazz->getField<jni::JDouble>("speed");
-      jni::local_ref<jni::JDouble> speed = this->getFieldValue(fieldSpeed);
+      static const auto fieldAltitudeAccuracy = clazz->getField<JNullableDouble>("altitudeAccuracy");
+      jni::local_ref<JNullableDouble> altitudeAccuracy = this->getFieldValue(fieldAltitudeAccuracy);
+      static const auto fieldHeading = clazz->getField<JNullableDouble>("heading");
+      jni::local_ref<JNullableDouble> heading = this->getFieldValue(fieldHeading);
+      static const auto fieldSpeed = clazz->getField<JNullableDouble>("speed");
+      jni::local_ref<JNullableDouble> speed = this->getFieldValue(fieldSpeed);
       return GeolocationCoordinates(
         latitude,
         longitude,
-        altitude != nullptr ? std::make_optional(altitude->value()) : std::nullopt,
+        altitude != nullptr ? std::make_optional(altitude->toCpp()) : std::nullopt,
         accuracy,
-        altitudeAccuracy != nullptr ? std::make_optional(altitudeAccuracy->value()) : std::nullopt,
-        heading != nullptr ? std::make_optional(heading->value()) : std::nullopt,
-        speed != nullptr ? std::make_optional(speed->value()) : std::nullopt
+        altitudeAccuracy != nullptr ? std::make_optional(altitudeAccuracy->toCpp()) : std::nullopt,
+        heading != nullptr ? std::make_optional(heading->toCpp()) : std::nullopt,
+        speed != nullptr ? std::make_optional(speed->toCpp()) : std::nullopt
       );
     }
 
@@ -62,14 +66,18 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JGeolocationCoordinates::javaobject> fromCpp(const GeolocationCoordinates& value) {
-      return newInstance(
+      using JSignature = JGeolocationCoordinates(double, double, jni::alias_ref<JNullableDouble>, double, jni::alias_ref<JNullableDouble>, jni::alias_ref<JNullableDouble>, jni::alias_ref<JNullableDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
         value.latitude,
         value.longitude,
-        value.altitude.has_value() ? jni::JDouble::valueOf(value.altitude.value()) : nullptr,
+        value.altitude.has_value() ? JNullableDouble::fromCpp(value.altitude.value()) : nullptr,
         value.accuracy,
-        value.altitudeAccuracy.has_value() ? jni::JDouble::valueOf(value.altitudeAccuracy.value()) : nullptr,
-        value.heading.has_value() ? jni::JDouble::valueOf(value.heading.value()) : nullptr,
-        value.speed.has_value() ? jni::JDouble::valueOf(value.speed.value()) : nullptr
+        value.altitudeAccuracy.has_value() ? JNullableDouble::fromCpp(value.altitudeAccuracy.value()) : nullptr,
+        value.heading.has_value() ? JNullableDouble::fromCpp(value.heading.value()) : nullptr,
+        value.speed.has_value() ? JNullableDouble::fromCpp(value.speed.value()) : nullptr
       );
     }
   };

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

@@ -56,7 +56,11 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JGeolocationError::javaobject> fromCpp(const GeolocationError& value) {
-      return newInstance(
+      using JSignature = JGeolocationError(double, jni::alias_ref<jni::JString>, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
         value.code,
         jni::make_jstring(value.message),
         value.PERMISSION_DENIED,

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

@@ -62,7 +62,11 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JGeolocationOptions::javaobject> fromCpp(const GeolocationOptions& value) {
-      return newInstance(
+      using JSignature = JGeolocationOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>);
+      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,

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

@@ -12,7 +12,11 @@
 
 #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 {
 
@@ -49,7 +53,11 @@ namespace margelo::nitro::nitrogeolocation {
      */
     [[maybe_unused]]
     static jni::local_ref<JGeolocationResponse::javaobject> fromCpp(const GeolocationResponse& value) {
-      return newInstance(
+      using JSignature = JGeolocationResponse(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
       );

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

@@ -0,0 +1,109 @@
+///
+/// JHybridNitroGeolocationCompatSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroGeolocationCompatSpec.hpp"
+
+// Forward declaration of `RNConfigurationInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
+// Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
+// Forward declaration of `LocationProviderInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
+// Forward declaration of `GeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
+// 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 `GeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+
+#include "RNConfigurationInternal.hpp"
+#include "JRNConfigurationInternal.hpp"
+#include "AuthorizationLevelInternal.hpp"
+#include <optional>
+#include "JAuthorizationLevelInternal.hpp"
+#include "LocationProviderInternal.hpp"
+#include "JLocationProviderInternal.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "GeolocationError.hpp"
+#include "JFunc_void_GeolocationError.hpp"
+#include "JGeolocationError.hpp"
+#include <string>
+#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 "GeolocationOptions.hpp"
+#include "JGeolocationOptions.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  jni::local_ref<JHybridNitroGeolocationCompatSpec::jhybriddata> JHybridNitroGeolocationCompatSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroGeolocationCompatSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroGeolocationCompatSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroGeolocationCompatSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroGeolocationCompatSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNitroGeolocationCompatSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridNitroGeolocationCompatSpec::setRNConfiguration(const RNConfigurationInternal& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRNConfigurationInternal> /* config */)>("setRNConfiguration");
+    method(_javaPart, JRNConfigurationInternal::fromCpp(config));
+  }
+  void JHybridNitroGeolocationCompatSpec::requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */)>("requestAuthorization_cxx");
+    method(_javaPart, success.has_value() ? JFunc_void_cxx::fromCpp(success.value()) : nullptr, error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr);
+  }
+  void JHybridNitroGeolocationCompatSpec::getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */, jni::alias_ref<JGeolocationOptions> /* options */)>("getCurrentPosition_cxx");
+    method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JGeolocationOptions::fromCpp(options.value()) : nullptr);
+  }
+  double JHybridNitroGeolocationCompatSpec::watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_GeolocationResponse::javaobject> /* success */, jni::alias_ref<JFunc_void_GeolocationError::javaobject> /* error */, jni::alias_ref<JGeolocationOptions> /* options */)>("watchPosition_cxx");
+    auto __result = method(_javaPart, JFunc_void_GeolocationResponse_cxx::fromCpp(success), error.has_value() ? JFunc_void_GeolocationError_cxx::fromCpp(error.value()) : nullptr, options.has_value() ? JGeolocationOptions::fromCpp(options.value()) : nullptr);
+    return __result;
+  }
+  void JHybridNitroGeolocationCompatSpec::clearWatch(double watchId) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* watchId */)>("clearWatch");
+    method(_javaPart, watchId);
+  }
+  void JHybridNitroGeolocationCompatSpec::stopObserving() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopObserving");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,70 @@
+///
+/// HybridNitroGeolocationCompatSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroGeolocationCompatSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  class JHybridNitroGeolocationCompatSpec: public jni::HybridClass<JHybridNitroGeolocationCompatSpec, JHybridObject>,
+                                           public virtual HybridNitroGeolocationCompatSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/HybridNitroGeolocationCompatSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroGeolocationCompatSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroGeolocationCompatSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroGeolocationCompatSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroGeolocationCompatSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void setRNConfiguration(const RNConfigurationInternal& config) override;
+    void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) override;
+    void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override;
+    double watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) override;
+    void clearWatch(double watchId) override;
+    void stopObserving() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroGeolocationCompatSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation