react-native-nitro-geolocation 1.2.6 → 1.3.0

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

@@ -0,0 +1,79 @@
+///
+/// JBackgroundPermissionResult.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 "BackgroundPermissionResult.hpp"
+
+#include "AccuracyAuthorization.hpp"
+#include "BackgroundPermissionStatus.hpp"
+#include "JAccuracyAuthorization.hpp"
+#include "JBackgroundPermissionStatus.hpp"
+#include "JPermissionStatus.hpp"
+#include "PermissionStatus.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BackgroundPermissionResult" and the the Kotlin data class "BackgroundPermissionResult".
+   */
+  struct JBackgroundPermissionResult final: public jni::JavaClass<JBackgroundPermissionResult> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundPermissionResult;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BackgroundPermissionResult by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundPermissionResult toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldForeground = clazz->getField<JPermissionStatus>("foreground");
+      jni::local_ref<JPermissionStatus> foreground = this->getFieldValue(fieldForeground);
+      static const auto fieldBackground = clazz->getField<JBackgroundPermissionStatus>("background");
+      jni::local_ref<JBackgroundPermissionStatus> background = this->getFieldValue(fieldBackground);
+      static const auto fieldAccuracyAuthorization = clazz->getField<JAccuracyAuthorization>("accuracyAuthorization");
+      jni::local_ref<JAccuracyAuthorization> accuracyAuthorization = this->getFieldValue(fieldAccuracyAuthorization);
+      static const auto fieldCanRequestBackgroundInline = clazz->getField<jni::JBoolean>("canRequestBackgroundInline");
+      jni::local_ref<jni::JBoolean> canRequestBackgroundInline = this->getFieldValue(fieldCanRequestBackgroundInline);
+      static const auto fieldNeedsSettingsRedirect = clazz->getField<jni::JBoolean>("needsSettingsRedirect");
+      jni::local_ref<jni::JBoolean> needsSettingsRedirect = this->getFieldValue(fieldNeedsSettingsRedirect);
+      return BackgroundPermissionResult(
+        foreground->toCpp(),
+        background->toCpp(),
+        accuracyAuthorization != nullptr ? std::make_optional(accuracyAuthorization->toCpp()) : std::nullopt,
+        canRequestBackgroundInline != nullptr ? std::make_optional(static_cast<bool>(canRequestBackgroundInline->value())) : std::nullopt,
+        needsSettingsRedirect != nullptr ? std::make_optional(static_cast<bool>(needsSettingsRedirect->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<JBackgroundPermissionResult::javaobject> fromCpp(const BackgroundPermissionResult& value) {
+      using JSignature = JBackgroundPermissionResult(jni::alias_ref<JPermissionStatus>, jni::alias_ref<JBackgroundPermissionStatus>, jni::alias_ref<JAccuracyAuthorization>, 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,
+        JPermissionStatus::fromCpp(value.foreground),
+        JBackgroundPermissionStatus::fromCpp(value.background),
+        value.accuracyAuthorization.has_value() ? JAccuracyAuthorization::fromCpp(value.accuracyAuthorization.value()) : nullptr,
+        value.canRequestBackgroundInline.has_value() ? jni::JBoolean::valueOf(value.canRequestBackgroundInline.value()) : nullptr,
+        value.needsSettingsRedirect.has_value() ? jni::JBoolean::valueOf(value.needsSettingsRedirect.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,64 @@
+///
+/// JBackgroundPermissionStatus.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 "BackgroundPermissionStatus.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "BackgroundPermissionStatus" and the the Kotlin enum "BackgroundPermissionStatus".
+   */
+  struct JBackgroundPermissionStatus final: public jni::JavaClass<JBackgroundPermissionStatus> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BackgroundPermissionStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum BackgroundPermissionStatus.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BackgroundPermissionStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<BackgroundPermissionStatus>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JBackgroundPermissionStatus> fromCpp(BackgroundPermissionStatus value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case BackgroundPermissionStatus::GRANTED:
+          static const auto fieldGRANTED = clazz->getStaticField<JBackgroundPermissionStatus>("GRANTED");
+          return clazz->getStaticFieldValue(fieldGRANTED);
+        case BackgroundPermissionStatus::DENIED:
+          static const auto fieldDENIED = clazz->getStaticField<JBackgroundPermissionStatus>("DENIED");
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case BackgroundPermissionStatus::RESTRICTED:
+          static const auto fieldRESTRICTED = clazz->getStaticField<JBackgroundPermissionStatus>("RESTRICTED");
+          return clazz->getStaticFieldValue(fieldRESTRICTED);
+        case BackgroundPermissionStatus::UNDETERMINED:
+          static const auto fieldUNDETERMINED = clazz->getStaticField<JBackgroundPermissionStatus>("UNDETERMINED");
+          return clazz->getStaticFieldValue(fieldUNDETERMINED);
+        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++/JBackgroundTrackingMode.hpp

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

@@ -0,0 +1,61 @@
+///
+/// JBatterySnapshot.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 "BatterySnapshot.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BatterySnapshot" and the the Kotlin data class "BatterySnapshot".
+   */
+  struct JBatterySnapshot final: public jni::JavaClass<JBatterySnapshot> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/BatterySnapshot;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BatterySnapshot by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BatterySnapshot toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldLevel = clazz->getField<jni::JDouble>("level");
+      jni::local_ref<jni::JDouble> level = this->getFieldValue(fieldLevel);
+      static const auto fieldIsCharging = clazz->getField<jni::JBoolean>("isCharging");
+      jni::local_ref<jni::JBoolean> isCharging = this->getFieldValue(fieldIsCharging);
+      return BatterySnapshot(
+        level != nullptr ? std::make_optional(level->value()) : std::nullopt,
+        isCharging != nullptr ? std::make_optional(static_cast<bool>(isCharging->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<JBatterySnapshot::javaobject> fromCpp(const BatterySnapshot& value) {
+      using JSignature = JBatterySnapshot(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.level.has_value() ? jni::JDouble::valueOf(value.level.value()) : nullptr,
+        value.isCharging.has_value() ? jni::JBoolean::valueOf(value.isCharging.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,66 @@
+///
+/// JDetectedActivity.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 "DetectedActivity.hpp"
+
+#include "DetectedActivityType.hpp"
+#include "JDetectedActivityType.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DetectedActivity" and the the Kotlin data class "DetectedActivity".
+   */
+  struct JDetectedActivity final: public jni::JavaClass<JDetectedActivity> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/DetectedActivity;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DetectedActivity by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DetectedActivity toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JDetectedActivityType>("type");
+      jni::local_ref<JDetectedActivityType> type = this->getFieldValue(fieldType);
+      static const auto fieldConfidence = clazz->getField<double>("confidence");
+      double confidence = this->getFieldValue(fieldConfidence);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return DetectedActivity(
+        type->toCpp(),
+        confidence,
+        timestamp
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDetectedActivity::javaobject> fromCpp(const DetectedActivity& value) {
+      using JSignature = JDetectedActivity(jni::alias_ref<JDetectedActivityType>, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JDetectedActivityType::fromCpp(value.type),
+        value.confidence,
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,76 @@
+///
+/// JDetectedActivityType.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 "DetectedActivityType.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "DetectedActivityType" and the the Kotlin enum "DetectedActivityType".
+   */
+  struct JDetectedActivityType final: public jni::JavaClass<JDetectedActivityType> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/DetectedActivityType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum DetectedActivityType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DetectedActivityType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<DetectedActivityType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JDetectedActivityType> fromCpp(DetectedActivityType value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case DetectedActivityType::UNKNOWN:
+          static const auto fieldUNKNOWN = clazz->getStaticField<JDetectedActivityType>("UNKNOWN");
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        case DetectedActivityType::RUNNING:
+          static const auto fieldRUNNING = clazz->getStaticField<JDetectedActivityType>("RUNNING");
+          return clazz->getStaticFieldValue(fieldRUNNING);
+        case DetectedActivityType::STILL:
+          static const auto fieldSTILL = clazz->getStaticField<JDetectedActivityType>("STILL");
+          return clazz->getStaticFieldValue(fieldSTILL);
+        case DetectedActivityType::WALKING:
+          static const auto fieldWALKING = clazz->getStaticField<JDetectedActivityType>("WALKING");
+          return clazz->getStaticFieldValue(fieldWALKING);
+        case DetectedActivityType::ONFOOT:
+          static const auto fieldONFOOT = clazz->getStaticField<JDetectedActivityType>("ONFOOT");
+          return clazz->getStaticFieldValue(fieldONFOOT);
+        case DetectedActivityType::ONBICYCLE:
+          static const auto fieldONBICYCLE = clazz->getStaticField<JDetectedActivityType>("ONBICYCLE");
+          return clazz->getStaticFieldValue(fieldONBICYCLE);
+        case DetectedActivityType::INVEHICLE:
+          static const auto fieldINVEHICLE = clazz->getStaticField<JDetectedActivityType>("INVEHICLE");
+          return clazz->getStaticFieldValue(fieldINVEHICLE);
+        case DetectedActivityType::TILTING:
+          static const auto fieldTILTING = clazz->getStaticField<JDetectedActivityType>("TILTING");
+          return clazz->getStaticFieldValue(fieldTILTING);
+        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++/JFunc_void_BackgroundEventEnvelope.hpp

@@ -0,0 +1,114 @@
+///
+/// JFunc_void_BackgroundEventEnvelope.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 "BackgroundEventEnvelope.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JBackgroundEventEnvelope.hpp"
+#include "BackgroundLocation.hpp"
+#include <optional>
+#include "JBackgroundLocation.hpp"
+#include <string>
+#include "BackgroundLocationSource.hpp"
+#include "JBackgroundLocationSource.hpp"
+#include "LocationProviderUsed.hpp"
+#include "JLocationProviderUsed.hpp"
+#include "DetectedActivity.hpp"
+#include "JDetectedActivity.hpp"
+#include "DetectedActivityType.hpp"
+#include "JDetectedActivityType.hpp"
+#include "BatterySnapshot.hpp"
+#include "JBatterySnapshot.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+#include "GeofenceEvent.hpp"
+#include "JGeofenceEvent.hpp"
+#include "GeofenceRegion.hpp"
+#include "JGeofenceRegion.hpp"
+#include <unordered_map>
+#include "JVariant_NullType_Boolean_String_Double.hpp"
+#include "GeofenceTransition.hpp"
+#include "JGeofenceTransition.hpp"
+#include "LocationProviderStatus.hpp"
+#include "JLocationProviderStatus.hpp"
+#include "BackgroundHttpSyncResult.hpp"
+#include "JBackgroundHttpSyncResult.hpp"
+#include <vector>
+#include "LocationError.hpp"
+#include "JLocationError.hpp"
+#include "BackgroundEventType.hpp"
+#include "JBackgroundEventType.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: BackgroundEventEnvelope) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_BackgroundEventEnvelope: public jni::JavaClass<JFunc_void_BackgroundEventEnvelope> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_BackgroundEventEnvelope;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_BackgroundEventEnvelope` instance holds through JNI.
+     */
+    void invoke(const BackgroundEventEnvelope& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBackgroundEventEnvelope> /* event */)>("invoke");
+      method(self(), JBackgroundEventEnvelope::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_BackgroundEventEnvelope that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_BackgroundEventEnvelope_cxx final: public jni::HybridClass<JFunc_void_BackgroundEventEnvelope_cxx, JFunc_void_BackgroundEventEnvelope> {
+  public:
+    static jni::local_ref<JFunc_void_BackgroundEventEnvelope::javaobject> fromCpp(const std::function<void(const BackgroundEventEnvelope& /* event */)>& func) {
+      return JFunc_void_BackgroundEventEnvelope_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_BackgroundEventEnvelope_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBackgroundEventEnvelope> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const BackgroundEventEnvelope& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_BackgroundEventEnvelope_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_BackgroundEventEnvelope_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_BackgroundEventEnvelope_cxx(const std::function<void(const BackgroundEventEnvelope& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const BackgroundEventEnvelope& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,95 @@
+///
+/// JFunc_void_BackgroundLocation.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 "BackgroundLocation.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JBackgroundLocation.hpp"
+#include <string>
+#include <optional>
+#include "BackgroundLocationSource.hpp"
+#include "JBackgroundLocationSource.hpp"
+#include "LocationProviderUsed.hpp"
+#include "JLocationProviderUsed.hpp"
+#include "DetectedActivity.hpp"
+#include "JDetectedActivity.hpp"
+#include "DetectedActivityType.hpp"
+#include "JDetectedActivityType.hpp"
+#include "BatterySnapshot.hpp"
+#include "JBatterySnapshot.hpp"
+#include "GeolocationCoordinates.hpp"
+#include "JGeolocationCoordinates.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include "JNullableDouble.hpp"
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(location: BackgroundLocation) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_BackgroundLocation: public jni::JavaClass<JFunc_void_BackgroundLocation> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_BackgroundLocation;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_BackgroundLocation` instance holds through JNI.
+     */
+    void invoke(const BackgroundLocation& location) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBackgroundLocation> /* location */)>("invoke");
+      method(self(), JBackgroundLocation::fromCpp(location));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_BackgroundLocation that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_BackgroundLocation_cxx final: public jni::HybridClass<JFunc_void_BackgroundLocation_cxx, JFunc_void_BackgroundLocation> {
+  public:
+    static jni::local_ref<JFunc_void_BackgroundLocation::javaobject> fromCpp(const std::function<void(const BackgroundLocation& /* location */)>& func) {
+      return JFunc_void_BackgroundLocation_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_BackgroundLocation_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JBackgroundLocation> location) {
+      _func(location->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const BackgroundLocation& /* location */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrogeolocation/Func_void_BackgroundLocation_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_BackgroundLocation_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_BackgroundLocation_cxx(const std::function<void(const BackgroundLocation& /* location */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const BackgroundLocation& /* location */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrogeolocation