react-native-nitro-location-tracking 0.1.5 → 0.1.6

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

@@ -0,0 +1,77 @@
+///
+/// JFunc_void_SpeedAlertType_double.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 "SpeedAlertType.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JSpeedAlertType.hpp"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(alert: SpeedAlertType, currentSpeedKmh: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_SpeedAlertType_double: public jni::JavaClass<JFunc_void_SpeedAlertType_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/Func_void_SpeedAlertType_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_SpeedAlertType_double` instance holds through JNI.
+     */
+    void invoke(SpeedAlertType alert, double currentSpeedKmh) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSpeedAlertType> /* alert */, double /* currentSpeedKmh */)>("invoke");
+      method(self(), JSpeedAlertType::fromCpp(alert), currentSpeedKmh);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_SpeedAlertType_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_SpeedAlertType_double_cxx final: public jni::HybridClass<JFunc_void_SpeedAlertType_double_cxx, JFunc_void_SpeedAlertType_double> {
+  public:
+    static jni::local_ref<JFunc_void_SpeedAlertType_double::javaobject> fromCpp(const std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)>& func) {
+      return JFunc_void_SpeedAlertType_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_SpeedAlertType_double_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JSpeedAlertType> alert, double currentSpeedKmh) {
+      _func(alert->toCpp(), currentSpeedKmh);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/Func_void_SpeedAlertType_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_SpeedAlertType_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_SpeedAlertType_double_cxx(const std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,58 @@
+///
+/// JGeofenceEvent.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 "GeofenceEvent.hpp"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "GeofenceEvent" and the the Kotlin enum "GeofenceEvent".
+   */
+  struct JGeofenceEvent final: public jni::JavaClass<JGeofenceEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/GeofenceEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum GeofenceEvent.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeofenceEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<GeofenceEvent>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JGeofenceEvent> fromCpp(GeofenceEvent value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case GeofenceEvent::ENTER:
+          static const auto fieldENTER = clazz->getStaticField<JGeofenceEvent>("ENTER");
+          return clazz->getStaticFieldValue(fieldENTER);
+        case GeofenceEvent::EXIT:
+          static const auto fieldEXIT = clazz->getStaticField<JGeofenceEvent>("EXIT");
+          return clazz->getStaticFieldValue(fieldEXIT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,77 @@
+///
+/// JGeofenceRegion.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 "GeofenceRegion.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GeofenceRegion" and the the Kotlin data class "GeofenceRegion".
+   */
+  struct JGeofenceRegion final: public jni::JavaClass<JGeofenceRegion> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/GeofenceRegion;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GeofenceRegion by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GeofenceRegion toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldLatitude = clazz->getField<double>("latitude");
+      double latitude = this->getFieldValue(fieldLatitude);
+      static const auto fieldLongitude = clazz->getField<double>("longitude");
+      double longitude = this->getFieldValue(fieldLongitude);
+      static const auto fieldRadius = clazz->getField<double>("radius");
+      double radius = this->getFieldValue(fieldRadius);
+      static const auto fieldNotifyOnEntry = clazz->getField<jboolean>("notifyOnEntry");
+      jboolean notifyOnEntry = this->getFieldValue(fieldNotifyOnEntry);
+      static const auto fieldNotifyOnExit = clazz->getField<jboolean>("notifyOnExit");
+      jboolean notifyOnExit = this->getFieldValue(fieldNotifyOnExit);
+      return GeofenceRegion(
+        id->toStdString(),
+        latitude,
+        longitude,
+        radius,
+        static_cast<bool>(notifyOnEntry),
+        static_cast<bool>(notifyOnExit)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JGeofenceRegion::javaobject> fromCpp(const GeofenceRegion& value) {
+      using JSignature = JGeofenceRegion(jni::alias_ref<jni::JString>, double, double, double, jboolean, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.id),
+        value.latitude,
+        value.longitude,
+        value.radius,
+        value.notifyOnEntry,
+        value.notifyOnExit
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -11,19 +11,38 @@
 namespace margelo::nitro::nitrolocationtracking { struct LocationData; }
 // Forward declaration of `ConnectionState` to properly resolve imports.
 namespace margelo::nitro::nitrolocationtracking { enum class ConnectionState; }
+// Forward declaration of `TripStats` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { struct TripStats; }
+// Forward declaration of `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { enum class PermissionStatus; }
 // Forward declaration of `LocationConfig` to properly resolve imports.
 namespace margelo::nitro::nitrolocationtracking { struct LocationConfig; }
 // Forward declaration of `AccuracyLevel` to properly resolve imports.
 namespace margelo::nitro::nitrolocationtracking { enum class AccuracyLevel; }
 // Forward declaration of `ConnectionConfig` to properly resolve imports.
 namespace margelo::nitro::nitrolocationtracking { struct ConnectionConfig; }
+// Forward declaration of `GeofenceRegion` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { struct GeofenceRegion; }
+// Forward declaration of `GeofenceEvent` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { enum class GeofenceEvent; }
+// Forward declaration of `SpeedConfig` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { struct SpeedConfig; }
+// Forward declaration of `SpeedAlertType` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { enum class SpeedAlertType; }
+// Forward declaration of `LocationProviderStatus` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { enum class LocationProviderStatus; }
 
 #include "LocationData.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
 #include "JLocationData.hpp"
+#include <optional>
 #include "ConnectionState.hpp"
 #include "JConnectionState.hpp"
+#include "TripStats.hpp"
+#include "JTripStats.hpp"
+#include "PermissionStatus.hpp"
+#include "JPermissionStatus.hpp"
 #include "LocationConfig.hpp"
 #include "JLocationConfig.hpp"
 #include "AccuracyLevel.hpp"
@@ -37,6 +56,19 @@ namespace margelo::nitro::nitrolocationtracking { struct ConnectionConfig; }
 #include "JConnectionConfig.hpp"
 #include "JFunc_void_ConnectionState.hpp"
 #include "JFunc_void_std__string.hpp"
+#include "GeofenceRegion.hpp"
+#include "JGeofenceRegion.hpp"
+#include "GeofenceEvent.hpp"
+#include "JFunc_void_GeofenceEvent_std__string.hpp"
+#include "JGeofenceEvent.hpp"
+#include "SpeedConfig.hpp"
+#include "JSpeedConfig.hpp"
+#include "SpeedAlertType.hpp"
+#include "JFunc_void_SpeedAlertType_double.hpp"
+#include "JSpeedAlertType.hpp"
+#include "LocationProviderStatus.hpp"
+#include "JFunc_void_LocationProviderStatus_LocationProviderStatus.hpp"
+#include "JLocationProviderStatus.hpp"
 
 namespace margelo::nitro::nitrolocationtracking {
 
@@ -163,6 +195,76 @@ namespace margelo::nitro::nitrolocationtracking {
       return __promise;
     }();
   }
+  bool JHybridNitroLocationTrackingSpec::isFakeGpsEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isFakeGpsEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroLocationTrackingSpec::setRejectMockLocations(bool reject) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* reject */)>("setRejectMockLocations");
+    method(_javaPart, reject);
+  }
+  void JHybridNitroLocationTrackingSpec::addGeofence(const GeofenceRegion& region) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JGeofenceRegion> /* region */)>("addGeofence");
+    method(_javaPart, JGeofenceRegion::fromCpp(region));
+  }
+  void JHybridNitroLocationTrackingSpec::removeGeofence(const std::string& regionId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* regionId */)>("removeGeofence");
+    method(_javaPart, jni::make_jstring(regionId));
+  }
+  void JHybridNitroLocationTrackingSpec::removeAllGeofences() {
+    static const auto method = javaClassStatic()->getMethod<void()>("removeAllGeofences");
+    method(_javaPart);
+  }
+  void JHybridNitroLocationTrackingSpec::onGeofenceEvent(const std::function<void(GeofenceEvent /* event */, const std::string& /* regionId */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_GeofenceEvent_std__string::javaobject> /* callback */)>("onGeofenceEvent_cxx");
+    method(_javaPart, JFunc_void_GeofenceEvent_std__string_cxx::fromCpp(callback));
+  }
+  void JHybridNitroLocationTrackingSpec::configureSpeedMonitor(const SpeedConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSpeedConfig> /* config */)>("configureSpeedMonitor");
+    method(_javaPart, JSpeedConfig::fromCpp(config));
+  }
+  void JHybridNitroLocationTrackingSpec::onSpeedAlert(const std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_SpeedAlertType_double::javaobject> /* callback */)>("onSpeedAlert_cxx");
+    method(_javaPart, JFunc_void_SpeedAlertType_double_cxx::fromCpp(callback));
+  }
+  double JHybridNitroLocationTrackingSpec::getCurrentSpeed() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getCurrentSpeed");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNitroLocationTrackingSpec::startTripCalculation() {
+    static const auto method = javaClassStatic()->getMethod<void()>("startTripCalculation");
+    method(_javaPart);
+  }
+  TripStats JHybridNitroLocationTrackingSpec::stopTripCalculation() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JTripStats>()>("stopTripCalculation");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  TripStats JHybridNitroLocationTrackingSpec::getTripStats() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JTripStats>()>("getTripStats");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroLocationTrackingSpec::resetTripCalculation() {
+    static const auto method = javaClassStatic()->getMethod<void()>("resetTripCalculation");
+    method(_javaPart);
+  }
+  bool JHybridNitroLocationTrackingSpec::isLocationServicesEnabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isLocationServicesEnabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroLocationTrackingSpec::onProviderStatusChange(const std::function<void(LocationProviderStatus /* gps */, LocationProviderStatus /* network */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_LocationProviderStatus_LocationProviderStatus::javaobject> /* callback */)>("onProviderStatusChange_cxx");
+    method(_javaPart, JFunc_void_LocationProviderStatus_LocationProviderStatus_cxx::fromCpp(callback));
+  }
+  PermissionStatus JHybridNitroLocationTrackingSpec::getLocationPermissionStatus() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getLocationPermissionStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
   void JHybridNitroLocationTrackingSpec::showLocalNotification(const std::string& title, const std::string& body) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* title */, jni::alias_ref<jni::JString> /* body */)>("showLocalNotification");
     method(_javaPart, jni::make_jstring(title), jni::make_jstring(body));

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

@@ -70,6 +70,22 @@ namespace margelo::nitro::nitrolocationtracking {
     void onConnectionStateChange(const std::function<void(ConnectionState /* state */)>& callback) override;
     void onMessage(const std::function<void(const std::string& /* message */)>& callback) override;
     std::shared_ptr<Promise<bool>> forceSync() override;
+    bool isFakeGpsEnabled() override;
+    void setRejectMockLocations(bool reject) override;
+    void addGeofence(const GeofenceRegion& region) override;
+    void removeGeofence(const std::string& regionId) override;
+    void removeAllGeofences() override;
+    void onGeofenceEvent(const std::function<void(GeofenceEvent /* event */, const std::string& /* regionId */)>& callback) override;
+    void configureSpeedMonitor(const SpeedConfig& config) override;
+    void onSpeedAlert(const std::function<void(SpeedAlertType /* alert */, double /* currentSpeedKmh */)>& callback) override;
+    double getCurrentSpeed() override;
+    void startTripCalculation() override;
+    TripStats stopTripCalculation() override;
+    TripStats getTripStats() override;
+    void resetTripCalculation() override;
+    bool isLocationServicesEnabled() override;
+    void onProviderStatusChange(const std::function<void(LocationProviderStatus /* gps */, LocationProviderStatus /* network */)>& callback) override;
+    PermissionStatus getLocationPermissionStatus() override;
     void showLocalNotification(const std::string& title, const std::string& body) override;
     void updateForegroundNotification(const std::string& title, const std::string& body) override;
     void destroy() override;

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

@@ -10,7 +10,7 @@
 #include <fbjni/fbjni.h>
 #include "LocationData.hpp"
 
-
+#include <optional>
 
 namespace margelo::nitro::nitrolocationtracking {
 
@@ -45,6 +45,8 @@ namespace margelo::nitro::nitrolocationtracking {
       double accuracy = this->getFieldValue(fieldAccuracy);
       static const auto fieldTimestamp = clazz->getField<double>("timestamp");
       double timestamp = this->getFieldValue(fieldTimestamp);
+      static const auto fieldIsMockLocation = clazz->getField<jni::JBoolean>("isMockLocation");
+      jni::local_ref<jni::JBoolean> isMockLocation = this->getFieldValue(fieldIsMockLocation);
       return LocationData(
         latitude,
         longitude,
@@ -52,7 +54,8 @@ namespace margelo::nitro::nitrolocationtracking {
         speed,
         bearing,
         accuracy,
-        timestamp
+        timestamp,
+        isMockLocation != nullptr ? std::make_optional(static_cast<bool>(isMockLocation->value())) : std::nullopt
       );
     }
 
@@ -62,7 +65,7 @@ namespace margelo::nitro::nitrolocationtracking {
      */
     [[maybe_unused]]
     static jni::local_ref<JLocationData::javaobject> fromCpp(const LocationData& value) {
-      using JSignature = JLocationData(double, double, double, double, double, double, double);
+      using JSignature = JLocationData(double, double, double, double, double, double, double, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -73,7 +76,8 @@ namespace margelo::nitro::nitrolocationtracking {
         value.speed,
         value.bearing,
         value.accuracy,
-        value.timestamp
+        value.timestamp,
+        value.isMockLocation.has_value() ? jni::JBoolean::valueOf(value.isMockLocation.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,58 @@
+///
+/// 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"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "LocationProviderStatus" and the the Kotlin enum "LocationProviderStatus".
+   */
+  struct JLocationProviderStatus final: public jni::JavaClass<JLocationProviderStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/LocationProviderStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum LocationProviderStatus.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationProviderStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<LocationProviderStatus>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JLocationProviderStatus> fromCpp(LocationProviderStatus value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case LocationProviderStatus::ENABLED:
+          static const auto fieldENABLED = clazz->getStaticField<JLocationProviderStatus>("ENABLED");
+          return clazz->getStaticFieldValue(fieldENABLED);
+        case LocationProviderStatus::DISABLED:
+          static const auto fieldDISABLED = clazz->getStaticField<JLocationProviderStatus>("DISABLED");
+          return clazz->getStaticFieldValue(fieldDISABLED);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,67 @@
+///
+/// JPermissionStatus.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 "PermissionStatus.hpp"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "PermissionStatus" and the the Kotlin enum "PermissionStatus".
+   */
+  struct JPermissionStatus final: public jni::JavaClass<JPermissionStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/PermissionStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum PermissionStatus.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    PermissionStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<PermissionStatus>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JPermissionStatus> fromCpp(PermissionStatus value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case PermissionStatus::NOTDETERMINED:
+          static const auto fieldNOTDETERMINED = clazz->getStaticField<JPermissionStatus>("NOTDETERMINED");
+          return clazz->getStaticFieldValue(fieldNOTDETERMINED);
+        case PermissionStatus::DENIED:
+          static const auto fieldDENIED = clazz->getStaticField<JPermissionStatus>("DENIED");
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case PermissionStatus::RESTRICTED:
+          static const auto fieldRESTRICTED = clazz->getStaticField<JPermissionStatus>("RESTRICTED");
+          return clazz->getStaticFieldValue(fieldRESTRICTED);
+        case PermissionStatus::WHENINUSE:
+          static const auto fieldWHENINUSE = clazz->getStaticField<JPermissionStatus>("WHENINUSE");
+          return clazz->getStaticFieldValue(fieldWHENINUSE);
+        case PermissionStatus::ALWAYS:
+          static const auto fieldALWAYS = clazz->getStaticField<JPermissionStatus>("ALWAYS");
+          return clazz->getStaticFieldValue(fieldALWAYS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,61 @@
+///
+/// JSpeedAlertType.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 "SpeedAlertType.hpp"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "SpeedAlertType" and the the Kotlin enum "SpeedAlertType".
+   */
+  struct JSpeedAlertType final: public jni::JavaClass<JSpeedAlertType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/SpeedAlertType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum SpeedAlertType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    SpeedAlertType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<SpeedAlertType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JSpeedAlertType> fromCpp(SpeedAlertType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case SpeedAlertType::EXCEEDED:
+          static const auto fieldEXCEEDED = clazz->getStaticField<JSpeedAlertType>("EXCEEDED");
+          return clazz->getStaticFieldValue(fieldEXCEEDED);
+        case SpeedAlertType::NORMALIZED:
+          static const auto fieldNORMALIZED = clazz->getStaticField<JSpeedAlertType>("NORMALIZED");
+          return clazz->getStaticFieldValue(fieldNORMALIZED);
+        case SpeedAlertType::BELOW_MINIMUM:
+          static const auto fieldBELOW_MINIMUM = clazz->getStaticField<JSpeedAlertType>("BELOW_MINIMUM");
+          return clazz->getStaticFieldValue(fieldBELOW_MINIMUM);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,65 @@
+///
+/// JSpeedConfig.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 "SpeedConfig.hpp"
+
+
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "SpeedConfig" and the the Kotlin data class "SpeedConfig".
+   */
+  struct JSpeedConfig final: public jni::JavaClass<JSpeedConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/SpeedConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct SpeedConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    SpeedConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMaxSpeedKmh = clazz->getField<double>("maxSpeedKmh");
+      double maxSpeedKmh = this->getFieldValue(fieldMaxSpeedKmh);
+      static const auto fieldMinSpeedKmh = clazz->getField<double>("minSpeedKmh");
+      double minSpeedKmh = this->getFieldValue(fieldMinSpeedKmh);
+      static const auto fieldCheckIntervalMs = clazz->getField<double>("checkIntervalMs");
+      double checkIntervalMs = this->getFieldValue(fieldCheckIntervalMs);
+      return SpeedConfig(
+        maxSpeedKmh,
+        minSpeedKmh,
+        checkIntervalMs
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JSpeedConfig::javaobject> fromCpp(const SpeedConfig& value) {
+      using JSignature = JSpeedConfig(double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.maxSpeedKmh,
+        value.minSpeedKmh,
+        value.checkIntervalMs
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking