react-native-nitro-compass 0.1.0

package/nitrogen/generated/android/NitroCompass+autolinking.cmake

@@ -0,0 +1,81 @@
+#
+# NitroCompass+autolinking.cmake
+# This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+# https://github.com/mrousavy/nitro
+# Copyright © Marc Rousavy @ Margelo
+#
+
+# This is a CMake file that adds all files generated by Nitrogen
+# to the current CMake project.
+#
+# To use it, add this to your CMakeLists.txt:
+# ```cmake
+# include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/NitroCompass+autolinking.cmake)
+# ```
+
+# Define a flag to check if we are building properly
+add_definitions(-DBUILDING_NITROCOMPASS_WITH_GENERATED_CMAKE_PROJECT)
+
+# Enable Raw Props parsing in react-native (for Nitro Views)
+add_definitions(-DRN_SERIALIZABLE_STATE)
+
+# Add all headers that were generated by Nitrogen
+include_directories(
+  "../nitrogen/generated/shared/c++"
+  "../nitrogen/generated/android/c++"
+  "../nitrogen/generated/android/"
+)
+
+# Add all .cpp sources that were generated by Nitrogen
+target_sources(
+  # CMake project name (Android C++ library name)
+  NitroCompass PRIVATE
+  # Autolinking Setup
+  ../nitrogen/generated/android/NitroCompassOnLoad.cpp
+  # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridNitroCompassSpec.cpp
+  # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridNitroCompassSpec.cpp
+)
+
+# From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake
+# Used in node_modules/react-native/ReactAndroid/cmake-utils/ReactNative-application.cmake
+target_compile_definitions(
+  NitroCompass PRIVATE
+  -DFOLLY_NO_CONFIG=1
+  -DFOLLY_HAVE_CLOCK_GETTIME=1
+  -DFOLLY_USE_LIBCPP=1
+  -DFOLLY_CFG_NO_COROUTINES=1
+  -DFOLLY_MOBILE=1
+  -DFOLLY_HAVE_RECVMMSG=1
+  -DFOLLY_HAVE_PTHREAD=1
+  # Once we target android-23 above, we can comment
+  # the following line. NDK uses GNU style stderror_r() after API 23.
+  -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
+
+# Add all libraries required by the generated specs
+find_package(fbjni REQUIRED) # <-- Used for communication between Java <-> C++
+find_package(ReactAndroid REQUIRED) # <-- Used to set up React Native bindings (e.g. CallInvoker/TurboModule)
+find_package(react-native-nitro-modules REQUIRED) # <-- Used to create all HybridObjects and use the Nitro core library
+
+# Link all libraries together
+target_link_libraries(
+        NitroCompass
+        fbjni::fbjni                              # <-- Facebook C++ JNI helpers
+        ReactAndroid::jsi                         # <-- RN: JSI
+        react-native-nitro-modules::NitroModules  # <-- NitroModules Core :)
+)
+
+# Link react-native (different prefab between RN 0.75 and RN 0.76)
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+    target_link_libraries(
+        NitroCompass
+        ReactAndroid::reactnative                 # <-- RN: Native Modules umbrella prefab
+    )
+else()
+    target_link_libraries(
+        NitroCompass
+        ReactAndroid::react_nativemodule_core     # <-- RN: TurboModules Core
+    )
+endif()

package/nitrogen/generated/android/NitroCompass+autolinking.gradle

@@ -0,0 +1,27 @@
+///
+/// NitroCompass+autolinking.gradle
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/// This is a Gradle file that adds all files generated by Nitrogen
+/// to the current Gradle project.
+///
+/// To use it, add this to your build.gradle:
+/// ```gradle
+/// apply from: '../nitrogen/generated/android/NitroCompass+autolinking.gradle'
+/// ```
+
+logger.warn("[NitroModules] 🔥 NitroCompass is boosted by nitro!")
+
+android {
+  sourceSets {
+    main {
+      java.srcDirs += [
+        // Nitrogen files
+        "${project.projectDir}/../nitrogen/generated/android/kotlin"
+      ]
+    }
+  }
+}

package/nitrogen/generated/android/NitroCompassOnLoad.cpp

@@ -0,0 +1,60 @@
+///
+/// NitroCompassOnLoad.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#ifndef BUILDING_NITROCOMPASS_WITH_GENERATED_CMAKE_PROJECT
+#error NitroCompassOnLoad.cpp is not being built with the autogenerated CMakeLists.txt project. Is a different CMakeLists.txt building this?
+#endif
+
+#include "NitroCompassOnLoad.hpp"
+
+#include <jni.h>
+#include <fbjni/fbjni.h>
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "JHybridNitroCompassSpec.hpp"
+#include "JFunc_void_CompassSample.hpp"
+#include "JFunc_void_AccuracyQuality.hpp"
+#include "JFunc_void_bool.hpp"
+#include <NitroModules/DefaultConstructableObject.hpp>
+
+namespace margelo::nitro::nitrocompass {
+
+int initialize(JavaVM* vm) {
+  return facebook::jni::initialize(vm, []() {
+    ::margelo::nitro::nitrocompass::registerAllNatives();
+  });
+}
+
+struct JHybridNitroCompassSpecImpl: public jni::JavaClass<JHybridNitroCompassSpecImpl, JHybridNitroCompassSpec::JavaPart> {
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/HybridNitroCompass;";
+  static std::shared_ptr<JHybridNitroCompassSpec> create() {
+    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridNitroCompassSpecImpl::javaobject()>();
+    jni::local_ref<JHybridNitroCompassSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
+    return javaPart->getJHybridNitroCompassSpec();
+  }
+};
+
+void registerAllNatives() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::nitrocompass;
+
+  // Register native JNI methods
+  margelo::nitro::nitrocompass::JHybridNitroCompassSpec::CxxPart::registerNatives();
+  margelo::nitro::nitrocompass::JFunc_void_CompassSample_cxx::registerNatives();
+  margelo::nitro::nitrocompass::JFunc_void_AccuracyQuality_cxx::registerNatives();
+  margelo::nitro::nitrocompass::JFunc_void_bool_cxx::registerNatives();
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "NitroCompass",
+    []() -> std::shared_ptr<HybridObject> {
+      return JHybridNitroCompassSpecImpl::create();
+    }
+  );
+}
+
+} // namespace margelo::nitro::nitrocompass

package/nitrogen/generated/android/NitroCompassOnLoad.hpp

@@ -0,0 +1,34 @@
+///
+/// NitroCompassOnLoad.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <jni.h>
+#include <functional>
+#include <NitroModules/NitroDefines.hpp>
+
+namespace margelo::nitro::nitrocompass {
+
+  [[deprecated("Use registerNatives() instead.")]]
+  int initialize(JavaVM* vm);
+
+  /**
+   * Register the native (C++) part of NitroCompass, and autolinks all Hybrid Objects.
+   * Call this in your `JNI_OnLoad` function (probably inside `cpp-adapter.cpp`),
+   * inside a `facebook::jni::initialize(vm, ...)` call.
+   * Example:
+   * ```cpp (cpp-adapter.cpp)
+   * JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+   *   return facebook::jni::initialize(vm, []() {
+   *     // register all NitroCompass HybridObjects
+   *     margelo::nitro::nitrocompass::registerNatives();
+   *     // any other custom registrations go here.
+   *   });
+   * }
+   * ```
+   */
+  void registerAllNatives();
+
+} // namespace margelo::nitro::nitrocompass

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

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

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

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

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

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

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

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::nitrocompass {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(interferenceDetected: Boolean) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_bool: public jni::JavaClass<JFunc_void_bool> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/Func_void_bool;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_bool` instance holds through JNI.
+     */
+    void invoke(bool interferenceDetected) const {
+      static const auto method = javaClassStatic()->getMethod<void(jboolean /* interferenceDetected */)>("invoke");
+      method(self(), interferenceDetected);
+    }
+  };
+
+  /**
+   * 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 /* interferenceDetected */)>& 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 interferenceDetected) {
+      _func(static_cast<bool>(interferenceDetected));
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(bool /* interferenceDetected */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrocompass/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 /* interferenceDetected */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(bool /* interferenceDetected */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrocompass