react-native-nitro-compass 1.1.0 → 1.2.0

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

@@ -58,6 +58,10 @@ abstract class HybridNitroCompassSpec: HybridObject() {
   @Keep
   abstract fun getDiagnostics(): SensorDiagnostics?
   
+  @DoNotStrip
+  @Keep
+  abstract fun getDebugInfo(): DebugInfo
+  
   @DoNotStrip
   @Keep
   abstract fun hasCompass(): Boolean
@@ -70,6 +74,10 @@ abstract class HybridNitroCompassSpec: HybridObject() {
   @Keep
   abstract fun setDeclination(degrees: Double): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun setLocation(latitude: Double, longitude: Double): Unit
+  
   abstract fun setOnCalibrationNeeded(onChange: (quality: AccuracyQuality) -> Unit): Unit
   
   @DoNotStrip
@@ -92,6 +100,10 @@ abstract class HybridNitroCompassSpec: HybridObject() {
   @Keep
   abstract fun setPauseOnBackground(enabled: Boolean): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun recalibrate(): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun getPermissionStatus(): PermissionStatus

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

@@ -16,9 +16,10 @@ import com.facebook.proguard.annotations.DoNotStrip
 @DoNotStrip
 @Keep
 enum class SensorKind(@DoNotStrip @Keep val value: Int) {
-  ROTATIONVECTOR(0),
-  GEOMAGNETICROTATIONVECTOR(1),
-  CORELOCATION(2);
+  MAGNETOMETER(0),
+  CORELOCATION(1),
+  ROTATIONVECTOR(2),
+  GEOMAGNETICROTATIONVECTOR(3);
 
   companion object
 }

package/nitrogen/generated/ios/NitroCompass-Swift-Cxx-Bridge.hpp

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 // Forward declaration of `CompassSample` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { struct CompassSample; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `HybridNitroCompassSpec` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { class HybridNitroCompassSpec; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -28,6 +30,7 @@ namespace NitroCompass { class HybridNitroCompassSpec_cxx; }
 // Include C++ defined types
 #include "AccuracyQuality.hpp"
 #include "CompassSample.hpp"
+#include "DebugInfo.hpp"
 #include "HybridNitroCompassSpec.hpp"
 #include "PermissionStatus.hpp"
 #include "SensorDiagnostics.hpp"
@@ -237,6 +240,15 @@ namespace margelo::nitro::nitrocompass::bridge::swift {
     return Result<std::optional<SensorDiagnostics>>::withError(error);
   }
   
+  // pragma MARK: Result<DebugInfo>
+  using Result_DebugInfo_ = Result<DebugInfo>;
+  inline Result_DebugInfo_ create_Result_DebugInfo_(const DebugInfo& value) noexcept {
+    return Result<DebugInfo>::withValue(value);
+  }
+  inline Result_DebugInfo_ create_Result_DebugInfo_(const std::exception_ptr& error) noexcept {
+    return Result<DebugInfo>::withError(error);
+  }
+  
   // pragma MARK: Result<std::optional<CompassSample>>
   using Result_std__optional_CompassSample__ = Result<std::optional<CompassSample>>;
   inline Result_std__optional_CompassSample__ create_Result_std__optional_CompassSample__(const std::optional<CompassSample>& value) noexcept {

package/nitrogen/generated/ios/NitroCompass-Swift-Cxx-Umbrella.hpp

@@ -12,6 +12,8 @@
 namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 // Forward declaration of `CompassSample` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { struct CompassSample; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `HybridNitroCompassSpec` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { class HybridNitroCompassSpec; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -24,6 +26,7 @@ namespace margelo::nitro::nitrocompass { enum class SensorKind; }
 // Include C++ defined types
 #include "AccuracyQuality.hpp"
 #include "CompassSample.hpp"
+#include "DebugInfo.hpp"
 #include "HybridNitroCompassSpec.hpp"
 #include "PermissionStatus.hpp"
 #include "SensorDiagnostics.hpp"

package/nitrogen/generated/ios/c++/HybridNitroCompassSpecSwift.hpp

@@ -18,6 +18,8 @@ namespace margelo::nitro::nitrocompass { struct CompassSample; }
 namespace margelo::nitro::nitrocompass { struct SensorDiagnostics; }
 // Forward declaration of `SensorKind` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { enum class SensorKind; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `AccuracyQuality` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -28,6 +30,7 @@ namespace margelo::nitro::nitrocompass { enum class PermissionStatus; }
 #include "SensorDiagnostics.hpp"
 #include <optional>
 #include "SensorKind.hpp"
+#include "DebugInfo.hpp"
 #include "AccuracyQuality.hpp"
 #include "PermissionStatus.hpp"
 #include <NitroModules/Promise.hpp>
@@ -122,6 +125,14 @@ namespace margelo::nitro::nitrocompass {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline DebugInfo getDebugInfo() override {
+      auto __result = _swiftPart.getDebugInfo();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline bool hasCompass() override {
       auto __result = _swiftPart.hasCompass();
       if (__result.hasError()) [[unlikely]] {
@@ -144,6 +155,12 @@ namespace margelo::nitro::nitrocompass {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setLocation(double latitude, double longitude) override {
+      auto __result = _swiftPart.setLocation(std::forward<decltype(latitude)>(latitude), std::forward<decltype(longitude)>(longitude));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) override {
       auto __result = _swiftPart.setOnCalibrationNeeded(onChange);
       if (__result.hasError()) [[unlikely]] {
@@ -162,6 +179,12 @@ namespace margelo::nitro::nitrocompass {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void recalibrate() override {
+      auto __result = _swiftPart.recalibrate();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline PermissionStatus getPermissionStatus() override {
       auto __result = _swiftPart.getPermissionStatus();
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/CompassSample.swift

@@ -18,8 +18,8 @@ public extension CompassSample {
   /**
    * Create a new instance of `CompassSample`.
    */
-  init(heading: Double, accuracy: Double) {
-    self.init(heading, accuracy)
+  init(heading: Double, accuracy: Double, fieldStrengthMicroTesla: Double) {
+    self.init(heading, accuracy, fieldStrengthMicroTesla)
   }
 
   @inline(__always)
@@ -31,4 +31,9 @@ public extension CompassSample {
   var accuracy: Double {
     return self.__accuracy
   }
+  
+  @inline(__always)
+  var fieldStrengthMicroTesla: Double {
+    return self.__fieldStrengthMicroTesla
+  }
 }

package/nitrogen/generated/ios/swift/DebugInfo.swift

@@ -0,0 +1,64 @@
+///
+/// DebugInfo.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `DebugInfo`, backed by a C++ struct.
+ */
+public typealias DebugInfo = margelo.nitro.nitrocompass.DebugInfo
+
+public extension DebugInfo {
+  private typealias bridge = margelo.nitro.nitrocompass.bridge.swift
+
+  /**
+   * Create a new instance of `DebugInfo`.
+   */
+  init(interferenceActive: Bool, msSinceLastBiasJump: Double, expectedFieldMicroTesla: Double, lastFieldMicroTesla: Double, fusedYawDeg: Double, lastYawRateDegPerS: Double, hasGameRotationVector: Bool, usingUncalibratedMag: Bool) {
+    self.init(interferenceActive, msSinceLastBiasJump, expectedFieldMicroTesla, lastFieldMicroTesla, fusedYawDeg, lastYawRateDegPerS, hasGameRotationVector, usingUncalibratedMag)
+  }
+
+  @inline(__always)
+  var interferenceActive: Bool {
+    return self.__interferenceActive
+  }
+  
+  @inline(__always)
+  var msSinceLastBiasJump: Double {
+    return self.__msSinceLastBiasJump
+  }
+  
+  @inline(__always)
+  var expectedFieldMicroTesla: Double {
+    return self.__expectedFieldMicroTesla
+  }
+  
+  @inline(__always)
+  var lastFieldMicroTesla: Double {
+    return self.__lastFieldMicroTesla
+  }
+  
+  @inline(__always)
+  var fusedYawDeg: Double {
+    return self.__fusedYawDeg
+  }
+  
+  @inline(__always)
+  var lastYawRateDegPerS: Double {
+    return self.__lastYawRateDegPerS
+  }
+  
+  @inline(__always)
+  var hasGameRotationVector: Bool {
+    return self.__hasGameRotationVector
+  }
+  
+  @inline(__always)
+  var usingUncalibratedMag: Bool {
+    return self.__usingUncalibratedMag
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroCompassSpec.swift

@@ -19,12 +19,15 @@ public protocol HybridNitroCompassSpec_protocol: HybridObject {
   func setFilter(degrees: Double) throws -> Void
   func setSmoothing(alpha: Double) throws -> Void
   func getDiagnostics() throws -> SensorDiagnostics?
+  func getDebugInfo() throws -> DebugInfo
   func hasCompass() throws -> Bool
   func getCurrentHeading() throws -> CompassSample?
   func setDeclination(degrees: Double) throws -> Void
+  func setLocation(latitude: Double, longitude: Double) throws -> Void
   func setOnCalibrationNeeded(onChange: @escaping (_ quality: AccuracyQuality) -> Void) throws -> Void
   func setOnInterferenceDetected(onChange: @escaping (_ interferenceDetected: Bool) -> Void) throws -> Void
   func setPauseOnBackground(enabled: Bool) throws -> Void
+  func recalibrate() throws -> Void
   func getPermissionStatus() throws -> PermissionStatus
   func requestPermission() throws -> Promise<PermissionStatus>
 }

package/nitrogen/generated/ios/swift/HybridNitroCompassSpec_cxx.swift

@@ -203,6 +203,18 @@ open class HybridNitroCompassSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func getDebugInfo() -> bridge.Result_DebugInfo_ {
+    do {
+      let __result = try self.__implementation.getDebugInfo()
+      let __resultCpp = __result
+      return bridge.create_Result_DebugInfo_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_DebugInfo_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func hasCompass() -> bridge.Result_bool_ {
     do {
@@ -244,6 +256,17 @@ open class HybridNitroCompassSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setLocation(latitude: Double, longitude: Double) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setLocation(latitude: latitude, longitude: longitude)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setOnCalibrationNeeded(onChange: bridge.Func_void_AccuracyQuality) -> bridge.Result_void_ {
     do {
@@ -287,6 +310,17 @@ open class HybridNitroCompassSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func recalibrate() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.recalibrate()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func getPermissionStatus() -> bridge.Result_PermissionStatus_ {
     do {

package/nitrogen/generated/ios/swift/SensorKind.swift

@@ -17,12 +17,14 @@ public extension SensorKind {
    */
   init?(fromString string: String) {
     switch string {
+      case "magnetometer":
+        self = .magnetometer
+      case "coreLocation":
+        self = .corelocation
       case "rotationVector":
         self = .rotationvector
       case "geomagneticRotationVector":
         self = .geomagneticrotationvector
-      case "coreLocation":
-        self = .corelocation
       default:
         return nil
     }
@@ -33,12 +35,14 @@ public extension SensorKind {
    */
   var stringValue: String {
     switch self {
+      case .magnetometer:
+        return "magnetometer"
+      case .corelocation:
+        return "coreLocation"
       case .rotationvector:
         return "rotationVector"
       case .geomagneticrotationvector:
         return "geomagneticRotationVector"
-      case .corelocation:
-        return "coreLocation"
     }
   }
 }

package/nitrogen/generated/shared/c++/CompassSample.hpp

@@ -41,10 +41,11 @@ namespace margelo::nitro::nitrocompass {
   public:
     double heading     SWIFT_PRIVATE;
     double accuracy     SWIFT_PRIVATE;
+    double fieldStrengthMicroTesla     SWIFT_PRIVATE;
 
   public:
     CompassSample() = default;
-    explicit CompassSample(double heading, double accuracy): heading(heading), accuracy(accuracy) {}
+    explicit CompassSample(double heading, double accuracy, double fieldStrengthMicroTesla): heading(heading), accuracy(accuracy), fieldStrengthMicroTesla(fieldStrengthMicroTesla) {}
 
   public:
     friend bool operator==(const CompassSample& lhs, const CompassSample& rhs) = default;
@@ -61,13 +62,15 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::nitrocompass::CompassSample(
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "heading"))),
-        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accuracy")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accuracy"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fieldStrengthMicroTesla")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrocompass::CompassSample& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "heading"), JSIConverter<double>::toJSI(runtime, arg.heading));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "accuracy"), JSIConverter<double>::toJSI(runtime, arg.accuracy));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "fieldStrengthMicroTesla"), JSIConverter<double>::toJSI(runtime, arg.fieldStrengthMicroTesla));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -80,6 +83,7 @@ namespace margelo::nitro {
       }
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "heading")))) return false;
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accuracy")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fieldStrengthMicroTesla")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/DebugInfo.hpp

@@ -0,0 +1,111 @@
+///
+/// DebugInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::nitrocompass {
+
+  /**
+   * A struct which can be represented as a JavaScript object (DebugInfo).
+   */
+  struct DebugInfo final {
+  public:
+    bool interferenceActive     SWIFT_PRIVATE;
+    double msSinceLastBiasJump     SWIFT_PRIVATE;
+    double expectedFieldMicroTesla     SWIFT_PRIVATE;
+    double lastFieldMicroTesla     SWIFT_PRIVATE;
+    double fusedYawDeg     SWIFT_PRIVATE;
+    double lastYawRateDegPerS     SWIFT_PRIVATE;
+    bool hasGameRotationVector     SWIFT_PRIVATE;
+    bool usingUncalibratedMag     SWIFT_PRIVATE;
+
+  public:
+    DebugInfo() = default;
+    explicit DebugInfo(bool interferenceActive, double msSinceLastBiasJump, double expectedFieldMicroTesla, double lastFieldMicroTesla, double fusedYawDeg, double lastYawRateDegPerS, bool hasGameRotationVector, bool usingUncalibratedMag): interferenceActive(interferenceActive), msSinceLastBiasJump(msSinceLastBiasJump), expectedFieldMicroTesla(expectedFieldMicroTesla), lastFieldMicroTesla(lastFieldMicroTesla), fusedYawDeg(fusedYawDeg), lastYawRateDegPerS(lastYawRateDegPerS), hasGameRotationVector(hasGameRotationVector), usingUncalibratedMag(usingUncalibratedMag) {}
+
+  public:
+    friend bool operator==(const DebugInfo& lhs, const DebugInfo& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrocompass
+
+namespace margelo::nitro {
+
+  // C++ DebugInfo <> JS DebugInfo (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrocompass::DebugInfo> final {
+    static inline margelo::nitro::nitrocompass::DebugInfo fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrocompass::DebugInfo(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "interferenceActive"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "msSinceLastBiasJump"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "expectedFieldMicroTesla"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lastFieldMicroTesla"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fusedYawDeg"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lastYawRateDegPerS"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasGameRotationVector"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "usingUncalibratedMag")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrocompass::DebugInfo& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "interferenceActive"), JSIConverter<bool>::toJSI(runtime, arg.interferenceActive));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "msSinceLastBiasJump"), JSIConverter<double>::toJSI(runtime, arg.msSinceLastBiasJump));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "expectedFieldMicroTesla"), JSIConverter<double>::toJSI(runtime, arg.expectedFieldMicroTesla));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "lastFieldMicroTesla"), JSIConverter<double>::toJSI(runtime, arg.lastFieldMicroTesla));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "fusedYawDeg"), JSIConverter<double>::toJSI(runtime, arg.fusedYawDeg));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "lastYawRateDegPerS"), JSIConverter<double>::toJSI(runtime, arg.lastYawRateDegPerS));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "hasGameRotationVector"), JSIConverter<bool>::toJSI(runtime, arg.hasGameRotationVector));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "usingUncalibratedMag"), JSIConverter<bool>::toJSI(runtime, arg.usingUncalibratedMag));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "interferenceActive")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "msSinceLastBiasJump")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "expectedFieldMicroTesla")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lastFieldMicroTesla")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "fusedYawDeg")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "lastYawRateDegPerS")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "hasGameRotationVector")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "usingUncalibratedMag")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridNitroCompassSpec.cpp

@@ -20,12 +20,15 @@ namespace margelo::nitro::nitrocompass {
       prototype.registerHybridMethod("setFilter", &HybridNitroCompassSpec::setFilter);
       prototype.registerHybridMethod("setSmoothing", &HybridNitroCompassSpec::setSmoothing);
       prototype.registerHybridMethod("getDiagnostics", &HybridNitroCompassSpec::getDiagnostics);
+      prototype.registerHybridMethod("getDebugInfo", &HybridNitroCompassSpec::getDebugInfo);
       prototype.registerHybridMethod("hasCompass", &HybridNitroCompassSpec::hasCompass);
       prototype.registerHybridMethod("getCurrentHeading", &HybridNitroCompassSpec::getCurrentHeading);
       prototype.registerHybridMethod("setDeclination", &HybridNitroCompassSpec::setDeclination);
+      prototype.registerHybridMethod("setLocation", &HybridNitroCompassSpec::setLocation);
       prototype.registerHybridMethod("setOnCalibrationNeeded", &HybridNitroCompassSpec::setOnCalibrationNeeded);
       prototype.registerHybridMethod("setOnInterferenceDetected", &HybridNitroCompassSpec::setOnInterferenceDetected);
       prototype.registerHybridMethod("setPauseOnBackground", &HybridNitroCompassSpec::setPauseOnBackground);
+      prototype.registerHybridMethod("recalibrate", &HybridNitroCompassSpec::recalibrate);
       prototype.registerHybridMethod("getPermissionStatus", &HybridNitroCompassSpec::getPermissionStatus);
       prototype.registerHybridMethod("requestPermission", &HybridNitroCompassSpec::requestPermission);
     });

package/nitrogen/generated/shared/c++/HybridNitroCompassSpec.hpp

@@ -17,6 +17,8 @@
 namespace margelo::nitro::nitrocompass { struct CompassSample; }
 // Forward declaration of `SensorDiagnostics` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { struct SensorDiagnostics; }
+// Forward declaration of `DebugInfo` to properly resolve imports.
+namespace margelo::nitro::nitrocompass { struct DebugInfo; }
 // Forward declaration of `AccuracyQuality` to properly resolve imports.
 namespace margelo::nitro::nitrocompass { enum class AccuracyQuality; }
 // Forward declaration of `PermissionStatus` to properly resolve imports.
@@ -26,6 +28,7 @@ namespace margelo::nitro::nitrocompass { enum class PermissionStatus; }
 #include <functional>
 #include "SensorDiagnostics.hpp"
 #include <optional>
+#include "DebugInfo.hpp"
 #include "AccuracyQuality.hpp"
 #include "PermissionStatus.hpp"
 #include <NitroModules/Promise.hpp>
@@ -67,12 +70,15 @@ namespace margelo::nitro::nitrocompass {
       virtual void setFilter(double degrees) = 0;
       virtual void setSmoothing(double alpha) = 0;
       virtual std::optional<SensorDiagnostics> getDiagnostics() = 0;
+      virtual DebugInfo getDebugInfo() = 0;
       virtual bool hasCompass() = 0;
       virtual std::optional<CompassSample> getCurrentHeading() = 0;
       virtual void setDeclination(double degrees) = 0;
+      virtual void setLocation(double latitude, double longitude) = 0;
       virtual void setOnCalibrationNeeded(const std::function<void(AccuracyQuality /* quality */)>& onChange) = 0;
       virtual void setOnInterferenceDetected(const std::function<void(bool /* interferenceDetected */)>& onChange) = 0;
       virtual void setPauseOnBackground(bool enabled) = 0;
+      virtual void recalibrate() = 0;
       virtual PermissionStatus getPermissionStatus() = 0;
       virtual std::shared_ptr<Promise<PermissionStatus>> requestPermission() = 0;
 

package/nitrogen/generated/shared/c++/SensorKind.hpp

@@ -29,9 +29,10 @@ namespace margelo::nitro::nitrocompass {
    * An enum which can be represented as a JavaScript union (SensorKind).
    */
   enum class SensorKind {
-    ROTATIONVECTOR      SWIFT_NAME(rotationvector) = 0,
-    GEOMAGNETICROTATIONVECTOR      SWIFT_NAME(geomagneticrotationvector) = 1,
-    CORELOCATION      SWIFT_NAME(corelocation) = 2,
+    MAGNETOMETER      SWIFT_NAME(magnetometer) = 0,
+    CORELOCATION      SWIFT_NAME(corelocation) = 1,
+    ROTATIONVECTOR      SWIFT_NAME(rotationvector) = 2,
+    GEOMAGNETICROTATIONVECTOR      SWIFT_NAME(geomagneticrotationvector) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::nitrocompass
@@ -44,18 +45,20 @@ namespace margelo::nitro {
     static inline margelo::nitro::nitrocompass::SensorKind fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("magnetometer"): return margelo::nitro::nitrocompass::SensorKind::MAGNETOMETER;
+        case hashString("coreLocation"): return margelo::nitro::nitrocompass::SensorKind::CORELOCATION;
         case hashString("rotationVector"): return margelo::nitro::nitrocompass::SensorKind::ROTATIONVECTOR;
         case hashString("geomagneticRotationVector"): return margelo::nitro::nitrocompass::SensorKind::GEOMAGNETICROTATIONVECTOR;
-        case hashString("coreLocation"): return margelo::nitro::nitrocompass::SensorKind::CORELOCATION;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum SensorKind - invalid value!");
       }
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrocompass::SensorKind arg) {
       switch (arg) {
+        case margelo::nitro::nitrocompass::SensorKind::MAGNETOMETER: return JSIConverter<std::string>::toJSI(runtime, "magnetometer");
+        case margelo::nitro::nitrocompass::SensorKind::CORELOCATION: return JSIConverter<std::string>::toJSI(runtime, "coreLocation");
         case margelo::nitro::nitrocompass::SensorKind::ROTATIONVECTOR: return JSIConverter<std::string>::toJSI(runtime, "rotationVector");
         case margelo::nitro::nitrocompass::SensorKind::GEOMAGNETICROTATIONVECTOR: return JSIConverter<std::string>::toJSI(runtime, "geomagneticRotationVector");
-        case margelo::nitro::nitrocompass::SensorKind::CORELOCATION: return JSIConverter<std::string>::toJSI(runtime, "coreLocation");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert SensorKind to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -67,9 +70,10 @@ namespace margelo::nitro {
       }
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("magnetometer"):
+        case hashString("coreLocation"):
         case hashString("rotationVector"):
         case hashString("geomagneticRotationVector"):
-        case hashString("coreLocation"):
           return true;
         default:
           return false;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "react-native-nitro-compass",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "engines": {
     "node": ">=18"
   },
-  "description": "Fast, accurate compass heading for React Native, powered by Nitro Modules. Uses Android TYPE_ROTATION_VECTOR sensor fusion and iOS CLHeading.",
+  "description": "Fast, accurate compass heading for React Native, powered by Nitro Modules. Uses raw Android accelerometer + magnetometer fusion (instant interference recovery) and iOS CLHeading.",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",