react-native-nitro-location-tracking 0.1.0

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

@@ -0,0 +1,179 @@
+///
+/// JHybridNitroLocationTrackingSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroLocationTrackingSpec.hpp"
+
+// Forward declaration of `LocationData` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { struct LocationData; }
+// Forward declaration of `ConnectionState` to properly resolve imports.
+namespace margelo::nitro::nitrolocationtracking { enum class ConnectionState; }
+// 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; }
+
+#include "LocationData.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JLocationData.hpp"
+#include "ConnectionState.hpp"
+#include "JConnectionState.hpp"
+#include "LocationConfig.hpp"
+#include "JLocationConfig.hpp"
+#include "AccuracyLevel.hpp"
+#include "JAccuracyLevel.hpp"
+#include <string>
+#include <functional>
+#include "JFunc_void_LocationData.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void_bool.hpp"
+#include "ConnectionConfig.hpp"
+#include "JConnectionConfig.hpp"
+#include "JFunc_void_ConnectionState.hpp"
+#include "JFunc_void_std__string.hpp"
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  jni::local_ref<JHybridNitroLocationTrackingSpec::jhybriddata> JHybridNitroLocationTrackingSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroLocationTrackingSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroLocationTrackingSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroLocationTrackingSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  bool JHybridNitroLocationTrackingSpec::equals(const std::shared_ptr<HybridObject>& other) {
+    if (auto otherCast = std::dynamic_pointer_cast<JHybridNitroLocationTrackingSpec>(other)) {
+      return _javaPart == otherCast->_javaPart;
+    }
+    return false;
+  }
+
+  void JHybridNitroLocationTrackingSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNitroLocationTrackingSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridNitroLocationTrackingSpec::configure(const LocationConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JLocationConfig> /* config */)>("configure");
+    method(_javaPart, JLocationConfig::fromCpp(config));
+  }
+  void JHybridNitroLocationTrackingSpec::startTracking() {
+    static const auto method = javaClassStatic()->getMethod<void()>("startTracking");
+    method(_javaPart);
+  }
+  void JHybridNitroLocationTrackingSpec::stopTracking() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopTracking");
+    method(_javaPart);
+  }
+  std::shared_ptr<Promise<LocationData>> JHybridNitroLocationTrackingSpec::getCurrentLocation() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("getCurrentLocation");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<LocationData>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JLocationData>(__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;
+    }();
+  }
+  bool JHybridNitroLocationTrackingSpec::isTracking() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isTracking");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroLocationTrackingSpec::onLocation(const std::function<void(const LocationData& /* location */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_LocationData::javaobject> /* callback */)>("onLocation_cxx");
+    method(_javaPart, JFunc_void_LocationData_cxx::fromCpp(callback));
+  }
+  void JHybridNitroLocationTrackingSpec::onMotionChange(const std::function<void(bool /* isMoving */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onMotionChange_cxx");
+    method(_javaPart, JFunc_void_bool_cxx::fromCpp(callback));
+  }
+  void JHybridNitroLocationTrackingSpec::configureConnection(const ConnectionConfig& config) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JConnectionConfig> /* config */)>("configureConnection");
+    method(_javaPart, JConnectionConfig::fromCpp(config));
+  }
+  void JHybridNitroLocationTrackingSpec::connectWebSocket() {
+    static const auto method = javaClassStatic()->getMethod<void()>("connectWebSocket");
+    method(_javaPart);
+  }
+  void JHybridNitroLocationTrackingSpec::disconnectWebSocket() {
+    static const auto method = javaClassStatic()->getMethod<void()>("disconnectWebSocket");
+    method(_javaPart);
+  }
+  void JHybridNitroLocationTrackingSpec::sendMessage(const std::string& message) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* message */)>("sendMessage");
+    method(_javaPart, jni::make_jstring(message));
+  }
+  ConnectionState JHybridNitroLocationTrackingSpec::getConnectionState() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JConnectionState>()>("getConnectionState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  void JHybridNitroLocationTrackingSpec::onConnectionStateChange(const std::function<void(ConnectionState /* state */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_ConnectionState::javaobject> /* callback */)>("onConnectionStateChange_cxx");
+    method(_javaPart, JFunc_void_ConnectionState_cxx::fromCpp(callback));
+  }
+  void JHybridNitroLocationTrackingSpec::onMessage(const std::function<void(const std::string& /* message */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* callback */)>("onMessage_cxx");
+    method(_javaPart, JFunc_void_std__string_cxx::fromCpp(callback));
+  }
+  std::shared_ptr<Promise<bool>> JHybridNitroLocationTrackingSpec::forceSync() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("forceSync");
+    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;
+    }();
+  }
+  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));
+  }
+  void JHybridNitroLocationTrackingSpec::updateForegroundNotification(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 */)>("updateForegroundNotification");
+    method(_javaPart, jni::make_jstring(title), jni::make_jstring(body));
+  }
+  void JHybridNitroLocationTrackingSpec::destroy() {
+    static const auto method = javaClassStatic()->getMethod<void()>("destroy");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,83 @@
+///
+/// HybridNitroLocationTrackingSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroLocationTrackingSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  class JHybridNitroLocationTrackingSpec: public jni::HybridClass<JHybridNitroLocationTrackingSpec, JHybridObject>,
+                                          public virtual HybridNitroLocationTrackingSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/HybridNitroLocationTrackingSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroLocationTrackingSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroLocationTrackingSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroLocationTrackingSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    bool equals(const std::shared_ptr<HybridObject>& other) override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroLocationTrackingSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void configure(const LocationConfig& config) override;
+    void startTracking() override;
+    void stopTracking() override;
+    std::shared_ptr<Promise<LocationData>> getCurrentLocation() override;
+    bool isTracking() override;
+    void onLocation(const std::function<void(const LocationData& /* location */)>& callback) override;
+    void onMotionChange(const std::function<void(bool /* isMoving */)>& callback) override;
+    void configureConnection(const ConnectionConfig& config) override;
+    void connectWebSocket() override;
+    void disconnectWebSocket() override;
+    void sendMessage(const std::string& message) override;
+    ConnectionState getConnectionState() override;
+    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;
+    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;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroLocationTrackingSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,91 @@
+///
+/// JLocationConfig.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 "LocationConfig.hpp"
+
+#include "AccuracyLevel.hpp"
+#include "JAccuracyLevel.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationConfig" and the the Kotlin data class "LocationConfig".
+   */
+  struct JLocationConfig final: public jni::JavaClass<JLocationConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/LocationConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDesiredAccuracy = clazz->getField<JAccuracyLevel>("desiredAccuracy");
+      jni::local_ref<JAccuracyLevel> desiredAccuracy = this->getFieldValue(fieldDesiredAccuracy);
+      static const auto fieldDistanceFilter = clazz->getField<double>("distanceFilter");
+      double distanceFilter = this->getFieldValue(fieldDistanceFilter);
+      static const auto fieldIntervalMs = clazz->getField<double>("intervalMs");
+      double intervalMs = this->getFieldValue(fieldIntervalMs);
+      static const auto fieldFastestIntervalMs = clazz->getField<double>("fastestIntervalMs");
+      double fastestIntervalMs = this->getFieldValue(fieldFastestIntervalMs);
+      static const auto fieldStopTimeout = clazz->getField<double>("stopTimeout");
+      double stopTimeout = this->getFieldValue(fieldStopTimeout);
+      static const auto fieldStopOnTerminate = clazz->getField<jboolean>("stopOnTerminate");
+      jboolean stopOnTerminate = this->getFieldValue(fieldStopOnTerminate);
+      static const auto fieldStartOnBoot = clazz->getField<jboolean>("startOnBoot");
+      jboolean startOnBoot = this->getFieldValue(fieldStartOnBoot);
+      static const auto fieldForegroundNotificationTitle = clazz->getField<jni::JString>("foregroundNotificationTitle");
+      jni::local_ref<jni::JString> foregroundNotificationTitle = this->getFieldValue(fieldForegroundNotificationTitle);
+      static const auto fieldForegroundNotificationText = clazz->getField<jni::JString>("foregroundNotificationText");
+      jni::local_ref<jni::JString> foregroundNotificationText = this->getFieldValue(fieldForegroundNotificationText);
+      return LocationConfig(
+        desiredAccuracy->toCpp(),
+        distanceFilter,
+        intervalMs,
+        fastestIntervalMs,
+        stopTimeout,
+        static_cast<bool>(stopOnTerminate),
+        static_cast<bool>(startOnBoot),
+        foregroundNotificationTitle->toStdString(),
+        foregroundNotificationText->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLocationConfig::javaobject> fromCpp(const LocationConfig& value) {
+      using JSignature = JLocationConfig(jni::alias_ref<JAccuracyLevel>, double, double, double, double, jboolean, jboolean, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JAccuracyLevel::fromCpp(value.desiredAccuracy),
+        value.distanceFilter,
+        value.intervalMs,
+        value.fastestIntervalMs,
+        value.stopTimeout,
+        value.stopOnTerminate,
+        value.startOnBoot,
+        jni::make_jstring(value.foregroundNotificationTitle),
+        jni::make_jstring(value.foregroundNotificationText)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

@@ -0,0 +1,81 @@
+///
+/// JLocationData.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 "LocationData.hpp"
+
+
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LocationData" and the the Kotlin data class "LocationData".
+   */
+  struct JLocationData final: public jni::JavaClass<JLocationData> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/LocationData;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LocationData by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LocationData toCpp() const {
+      static const auto clazz = javaClassStatic();
+      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 fieldAltitude = clazz->getField<double>("altitude");
+      double altitude = this->getFieldValue(fieldAltitude);
+      static const auto fieldSpeed = clazz->getField<double>("speed");
+      double speed = this->getFieldValue(fieldSpeed);
+      static const auto fieldBearing = clazz->getField<double>("bearing");
+      double bearing = this->getFieldValue(fieldBearing);
+      static const auto fieldAccuracy = clazz->getField<double>("accuracy");
+      double accuracy = this->getFieldValue(fieldAccuracy);
+      static const auto fieldTimestamp = clazz->getField<double>("timestamp");
+      double timestamp = this->getFieldValue(fieldTimestamp);
+      return LocationData(
+        latitude,
+        longitude,
+        altitude,
+        speed,
+        bearing,
+        accuracy,
+        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<JLocationData::javaobject> fromCpp(const LocationData& value) {
+      using JSignature = JLocationData(double, double, double, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.latitude,
+        value.longitude,
+        value.altitude,
+        value.speed,
+        value.bearing,
+        value.accuracy,
+        value.timestamp
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolocationtracking/AccuracyLevel.kt

@@ -0,0 +1,24 @@
+///
+/// AccuracyLevel.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrolocationtracking
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AccuracyLevel".
+ */
+@DoNotStrip
+@Keep
+enum class AccuracyLevel(@DoNotStrip @Keep val value: Int) {
+  HIGH(0),
+  BALANCED(1),
+  LOW(2);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolocationtracking/ConnectionConfig.kt

@@ -0,0 +1,56 @@
+///
+/// ConnectionConfig.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrolocationtracking
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "ConnectionConfig".
+ */
+@DoNotStrip
+@Keep
+data class ConnectionConfig(
+  @DoNotStrip
+  @Keep
+  val wsUrl: String,
+  @DoNotStrip
+  @Keep
+  val restUrl: String,
+  @DoNotStrip
+  @Keep
+  val authToken: String,
+  @DoNotStrip
+  @Keep
+  val reconnectIntervalMs: Double,
+  @DoNotStrip
+  @Keep
+  val maxReconnectAttempts: Double,
+  @DoNotStrip
+  @Keep
+  val batchSize: Double,
+  @DoNotStrip
+  @Keep
+  val syncIntervalMs: Double
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(wsUrl: String, restUrl: String, authToken: String, reconnectIntervalMs: Double, maxReconnectAttempts: Double, batchSize: Double, syncIntervalMs: Double): ConnectionConfig {
+      return ConnectionConfig(wsUrl, restUrl, authToken, reconnectIntervalMs, maxReconnectAttempts, batchSize, syncIntervalMs)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolocationtracking/ConnectionState.kt

@@ -0,0 +1,24 @@
+///
+/// ConnectionState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrolocationtracking
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "ConnectionState".
+ */
+@DoNotStrip
+@Keep
+enum class ConnectionState(@DoNotStrip @Keep val value: Int) {
+  CONNECTED(0),
+  DISCONNECTED(1),
+  RECONNECTING(2);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrolocationtracking/Func_void_ConnectionState.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_ConnectionState.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrolocationtracking
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(state: enum) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_ConnectionState: (ConnectionState) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(state: ConnectionState): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(state: enum) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_ConnectionState_cxx: Func_void_ConnectionState {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(state: ConnectionState): Unit
+    = invoke_cxx(state)
+
+  @FastNative
+  private external fun invoke_cxx(state: ConnectionState): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(state: enum) => void`.
+ * This is implemented in Java/Kotlin, via a `(ConnectionState) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_ConnectionState_java(private val function: (ConnectionState) -> Unit): Func_void_ConnectionState {
+  @DoNotStrip
+  @Keep
+  override fun invoke(state: ConnectionState): Unit {
+    return this.function(state)
+  }
+}