react-native-nitro-compass 0.1.0

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

@@ -0,0 +1,143 @@
+///
+/// JHybridNitroCompassSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroCompassSpec.hpp"
+
+// Forward declaration of `SensorDiagnostics` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct SensorDiagnostics; }
+// Forward declaration of `SensorKind` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { enum class SensorKind; }
+// Forward declaration of `CompassSample` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct CompassSample; }
+// Forward declaration of `PermissionStatus` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { enum class PermissionStatus; }
+// Forward declaration of `AccuracyQuality` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
+
+#include "SensorDiagnostics.hpp"
+#include <optional>
+#include "JSensorDiagnostics.hpp"
+#include "SensorKind.hpp"
+#include "JSensorKind.hpp"
+#include "CompassSample.hpp"
+#include "JCompassSample.hpp"
+#include "PermissionStatus.hpp"
+#include "JPermissionStatus.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <functional>
+#include "JFunc_void_CompassSample.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "AccuracyQuality.hpp"
+#include "JFunc_void_AccuracyQuality.hpp"
+#include "JAccuracyQuality.hpp"
+#include "JFunc_void_bool.hpp"
+
+namespace margelo::nitro::nitrocompass {
+
+  std::shared_ptr<JHybridNitroCompassSpec> JHybridNitroCompassSpec::JavaPart::getJHybridNitroCompassSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroCompassSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroCompassSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroCompassSpec::CxxPart::jhybriddata> JHybridNitroCompassSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroCompassSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroCompassSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroCompassSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroCompassSpec>(castJavaPart);
+  }
+
+  void JHybridNitroCompassSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroCompassSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  void JHybridNitroCompassSpec::start(double filterDegrees, const std::function<void(const CompassSample& /* sample */)>& onHeading) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* filterDegrees */, jni::alias_ref<JFunc_void_CompassSample::javaobject> /* onHeading */)>("start_cxx");
+    method(_javaPart, filterDegrees, JFunc_void_CompassSample_cxx::fromCpp(onHeading));
+  }
+  void JHybridNitroCompassSpec::stop() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stop");
+    method(_javaPart);
+  }
+  bool JHybridNitroCompassSpec::isStarted() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isStarted");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridNitroCompassSpec::setFilter(double degrees) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* degrees */)>("setFilter");
+    method(_javaPart, degrees);
+  }
+  std::optional<SensorDiagnostics> JHybridNitroCompassSpec::getDiagnostics() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSensorDiagnostics>()>("getDiagnostics");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  bool JHybridNitroCompassSpec::hasCompass() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasCompass");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::optional<CompassSample> JHybridNitroCompassSpec::getCurrentHeading() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JCompassSample>()>("getCurrentHeading");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridNitroCompassSpec::setDeclination(double degrees) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* degrees */)>("setDeclination");
+    method(_javaPart, degrees);
+  }
+  void JHybridNitroCompassSpec::setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_AccuracyQuality::javaobject> /* onChange */)>("setOnCalibrationNeeded_cxx");
+    method(_javaPart, JFunc_void_AccuracyQuality_cxx::fromCpp(onChange));
+  }
+  void JHybridNitroCompassSpec::setOnInterferenceDetected(const std::function<void(bool /* interferenceDetected */)>& onChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_bool::javaobject> /* onChange */)>("setOnInterferenceDetected_cxx");
+    method(_javaPart, JFunc_void_bool_cxx::fromCpp(onChange));
+  }
+  void JHybridNitroCompassSpec::setPauseOnBackground(bool enabled) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setPauseOnBackground");
+    method(_javaPart, enabled);
+  }
+  PermissionStatus JHybridNitroCompassSpec::getPermissionStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPermissionStatus>()>("getPermissionStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::shared_ptr<Promise<PermissionStatus>> JHybridNitroCompassSpec::requestPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<PermissionStatus>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JPermissionStatus>(__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;
+    }();
+  }
+
+} // namespace margelo::nitro::nitrocompass

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

@@ -0,0 +1,75 @@
+///
+/// HybridNitroCompassSpec.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 "HybridNitroCompassSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrocompass {
+
+  using namespace facebook;
+
+  class JHybridNitroCompassSpec: public virtual HybridNitroCompassSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/HybridNitroCompassSpec;";
+      std::shared_ptr<JHybridNitroCompassSpec> getJHybridNitroCompassSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/HybridNitroCompassSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroCompassSpec(const jni::local_ref<JHybridNitroCompassSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroCompassSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroCompassSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroCompassSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    void start(double filterDegrees, const std::function<void(const CompassSample& /* sample */)>& onHeading) override;
+    void stop() override;
+    bool isStarted() override;
+    void setFilter(double degrees) override;
+    std::optional<SensorDiagnostics> getDiagnostics() override;
+    bool hasCompass() override;
+    std::optional<CompassSample> getCurrentHeading() override;
+    void setDeclination(double degrees) override;
+    void setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) override;
+    void setOnInterferenceDetected(const std::function<void(bool /* interferenceDetected */)>& onChange) override;
+    void setPauseOnBackground(bool enabled) override;
+    PermissionStatus getPermissionStatus() override;
+    std::shared_ptr<Promise<PermissionStatus>> requestPermission() override;
+
+  private:
+    jni::global_ref<JHybridNitroCompassSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrocompass

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

@@ -0,0 +1,61 @@
+///
+/// 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::nitrocompass {
+
+  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 constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/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::GRANTED:
+          static const auto fieldGRANTED = clazz->getStaticField<JPermissionStatus>("GRANTED");
+          return clazz->getStaticFieldValue(fieldGRANTED);
+        case PermissionStatus::DENIED:
+          static const auto fieldDENIED = clazz->getStaticField<JPermissionStatus>("DENIED");
+          return clazz->getStaticFieldValue(fieldDENIED);
+        case PermissionStatus::UNKNOWN:
+          static const auto fieldUNKNOWN = clazz->getStaticField<JPermissionStatus>("UNKNOWN");
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrocompass

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

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

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

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

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/AccuracyQuality.kt

@@ -0,0 +1,25 @@
+///
+/// AccuracyQuality.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.nitrocompass
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "AccuracyQuality".
+ */
+@DoNotStrip
+@Keep
+enum class AccuracyQuality(@DoNotStrip @Keep val value: Int) {
+  HIGH(0),
+  MEDIUM(1),
+  LOW(2),
+  UNRELIABLE(3);
+
+  companion object
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/CompassSample.kt

@@ -0,0 +1,56 @@
+///
+/// CompassSample.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.nitrocompass
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "CompassSample".
+ */
+@DoNotStrip
+@Keep
+data class CompassSample(
+  @DoNotStrip
+  @Keep
+  val heading: Double,
+  @DoNotStrip
+  @Keep
+  val accuracy: Double
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is CompassSample) return false
+    return Objects.deepEquals(this.heading, other.heading)
+      && Objects.deepEquals(this.accuracy, other.accuracy)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf(
+      heading,
+      accuracy
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(heading: Double, accuracy: Double): CompassSample {
+      return CompassSample(heading, accuracy)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/Func_void_AccuracyQuality.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_AccuracyQuality.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.nitrocompass
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(quality: 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_AccuracyQuality: (AccuracyQuality) -> 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(quality: AccuracyQuality): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(quality: 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_AccuracyQuality_cxx: Func_void_AccuracyQuality {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(quality: AccuracyQuality): Unit
+    = invoke_cxx(quality)
+
+  @FastNative
+  private external fun invoke_cxx(quality: AccuracyQuality): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(quality: enum) => void`.
+ * This is implemented in Java/Kotlin, via a `(AccuracyQuality) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_AccuracyQuality_java(private val function: (AccuracyQuality) -> Unit): Func_void_AccuracyQuality {
+  @DoNotStrip
+  @Keep
+  override fun invoke(quality: AccuracyQuality): Unit {
+    return this.function(quality)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrocompass/Func_void_CompassSample.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_CompassSample.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.nitrocompass
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(sample: struct) => 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_CompassSample: (CompassSample) -> 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(sample: CompassSample): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(sample: struct) => 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_CompassSample_cxx: Func_void_CompassSample {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(sample: CompassSample): Unit
+    = invoke_cxx(sample)
+
+  @FastNative
+  private external fun invoke_cxx(sample: CompassSample): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(sample: struct) => void`.
+ * This is implemented in Java/Kotlin, via a `(CompassSample) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_CompassSample_java(private val function: (CompassSample) -> Unit): Func_void_CompassSample {
+  @DoNotStrip
+  @Keep
+  override fun invoke(sample: CompassSample): Unit {
+    return this.function(sample)
+  }
+}