react-native-nitro-location-tracking 0.1.0

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,21 @@
+import type { NitroLocationTracking, LocationData, LocationConfig, ConnectionConfig } from './NitroLocationTracking.nitro';
+declare const NitroLocationModule: NitroLocationTracking;
+export default NitroLocationModule;
+export { LocationSmoother } from './LocationSmoother';
+export { shortestRotation, calculateBearing } from './bearing';
+export type { NitroLocationTracking, LocationData, LocationConfig, ConnectionConfig, } from './NitroLocationTracking.nitro';
+export declare function useDriverLocation(config: LocationConfig): {
+    location: LocationData | null;
+    isMoving: boolean;
+    isTracking: boolean;
+    startTracking: () => void;
+    stopTracking: () => void;
+};
+export declare function useRideConnection(config: ConnectionConfig): {
+    connectionState: "connected" | "disconnected" | "reconnecting";
+    lastMessage: string | null;
+    connect: () => void;
+    disconnect: () => void;
+    send: (m: string) => void;
+};
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAEvC,QAAA,MAAM,mBAAmB,uBAGtB,CAAC;AAEJ,eAAe,mBAAmB,CAAC;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAE/D,YAAY,EACV,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,gBAAgB,GACjB,MAAM,+BAA+B,CAAC;AAEvC,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc;;;;;;EAuCvD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB;;;;;cAuBhC,MAAM;EAE/B"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["nitrolocationtracking"],
+  "ios": {
+    "iosModuleName": "NitroLocationTracking"
+  },
+  "android": {
+    "androidNamespace": ["nitrolocationtracking"],
+    "androidCxxLibName": "nitrolocationtracking"
+  },
+  "autolinking": {
+    "NitroLocationTracking": {
+      "swift": "NitroLocationTracking",
+      "kotlin": "NitroLocationTracking"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

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

@@ -0,0 +1,81 @@
+///
+/// JConnectionConfig.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 "ConnectionConfig.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrolocationtracking {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ConnectionConfig" and the the Kotlin data class "ConnectionConfig".
+   */
+  struct JConnectionConfig final: public jni::JavaClass<JConnectionConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrolocationtracking/ConnectionConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ConnectionConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ConnectionConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWsUrl = clazz->getField<jni::JString>("wsUrl");
+      jni::local_ref<jni::JString> wsUrl = this->getFieldValue(fieldWsUrl);
+      static const auto fieldRestUrl = clazz->getField<jni::JString>("restUrl");
+      jni::local_ref<jni::JString> restUrl = this->getFieldValue(fieldRestUrl);
+      static const auto fieldAuthToken = clazz->getField<jni::JString>("authToken");
+      jni::local_ref<jni::JString> authToken = this->getFieldValue(fieldAuthToken);
+      static const auto fieldReconnectIntervalMs = clazz->getField<double>("reconnectIntervalMs");
+      double reconnectIntervalMs = this->getFieldValue(fieldReconnectIntervalMs);
+      static const auto fieldMaxReconnectAttempts = clazz->getField<double>("maxReconnectAttempts");
+      double maxReconnectAttempts = this->getFieldValue(fieldMaxReconnectAttempts);
+      static const auto fieldBatchSize = clazz->getField<double>("batchSize");
+      double batchSize = this->getFieldValue(fieldBatchSize);
+      static const auto fieldSyncIntervalMs = clazz->getField<double>("syncIntervalMs");
+      double syncIntervalMs = this->getFieldValue(fieldSyncIntervalMs);
+      return ConnectionConfig(
+        wsUrl->toStdString(),
+        restUrl->toStdString(),
+        authToken->toStdString(),
+        reconnectIntervalMs,
+        maxReconnectAttempts,
+        batchSize,
+        syncIntervalMs
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JConnectionConfig::javaobject> fromCpp(const ConnectionConfig& value) {
+      using JSignature = JConnectionConfig(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.wsUrl),
+        jni::make_jstring(value.restUrl),
+        jni::make_jstring(value.authToken),
+        value.reconnectIntervalMs,
+        value.maxReconnectAttempts,
+        value.batchSize,
+        value.syncIntervalMs
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrolocationtracking

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

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

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

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

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

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

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

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

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