expo-sensors 10.2.2 → 11.0.3

package/CHANGELOG.md

@@ -10,14 +10,33 @@
 
 ### 💡 Others
 
-## 10.2.2 — 2021-06-24
+## 11.0.3 — 2021-10-21
 
 _This version does not introduce any user-facing changes._
 
-## 10.2.1 — 2021-06-22
+## 11.0.2 — 2021-10-15
 
 _This version does not introduce any user-facing changes._
 
+## 11.0.1 — 2021-10-01
+
+_This version does not introduce any user-facing changes._
+
+## 11.0.0 — 2021-09-28
+
+### 🛠 Breaking changes
+
+- Dropped support for iOS 11.0 ([#14383](https://github.com/expo/expo/pull/14383) by [@cruzach](https://github.com/cruzach))
+
+### 🐛 Bug fixes
+
+- Fix building errors from use_frameworks! in Podfile. ([#14523](https://github.com/expo/expo/pull/14523) by [@kudo](https://github.com/kudo))
+
+### 💡 Others
+
+- Converted Android code to Kotlin ([#13738](https://github.com/expo/expo/pull/13738) by [@ixf](https://github.com/ixf))
+- Updated `@expo/config-plugins` ([#14443](https://github.com/expo/expo/pull/14443) by [@EvanBacon](https://github.com/EvanBacon))
+
 ## 10.2.0 — 2021-06-16
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -3,7 +3,7 @@ apply plugin: 'kotlin-android'
 apply plugin: 'maven'
 
 group = 'host.exp.exponent'
-version = '10.2.2'
+version = '11.0.3'
 
 buildscript {
   // Simple helper that allows the root project to override versions declared by this library.
@@ -57,24 +57,15 @@ android {
     minSdkVersion safeExtGet("minSdkVersion", 21)
     targetSdkVersion safeExtGet("targetSdkVersion", 30)
     versionCode 27
-    versionName "10.2.2"
+    versionName "11.0.3"
   }
   lintOptions {
     abortOnError false
   }
 }
 
-if (new File(rootProject.projectDir.parentFile, 'package.json').exists()) {
-  apply from: project(":unimodules-core").file("../unimodules-core.gradle")
-} else {
-  throw new GradleException(
-      "'unimodules-core.gradle' was not found in the usual React Native dependency location. " +
-          "This package can only be used in such projects. Are you sure you've installed the dependencies properly?")
-}
-
 dependencies {
-  unimodule "unimodules-core"
-  unimodule 'expo-modules-core'
+  implementation project(':expo-modules-core')
 
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.4.21')}"
 }

package/android/src/main/java/expo/modules/sensors/SensorsPackage.kt

@@ -0,0 +1,50 @@
+package expo.modules.sensors
+
+import android.content.Context
+import expo.modules.sensors.modules.AccelerometerModule
+import expo.modules.sensors.modules.BarometerModule
+import expo.modules.sensors.modules.DeviceMotionModule
+import expo.modules.sensors.modules.GyroscopeModule
+import expo.modules.sensors.modules.MagnetometerModule
+import expo.modules.sensors.modules.MagnetometerUncalibratedModule
+import expo.modules.sensors.modules.PedometerModule
+import expo.modules.sensors.services.AccelerometerService
+import expo.modules.sensors.services.BarometerService
+import expo.modules.sensors.services.GravitySensorService
+import expo.modules.sensors.services.GyroscopeService
+import expo.modules.sensors.services.LinearAccelerationSensorService
+import expo.modules.sensors.services.MagnetometerService
+import expo.modules.sensors.services.MagnetometerUncalibratedService
+import expo.modules.sensors.services.PedometerService
+import expo.modules.sensors.services.RotationVectorSensorService
+import expo.modules.core.BasePackage
+import expo.modules.core.ExportedModule
+import expo.modules.core.interfaces.InternalModule
+
+class SensorsPackage : BasePackage() {
+  override fun createInternalModules(context: Context): List<InternalModule> {
+    return listOf<InternalModule>(
+      AccelerometerService(context),
+      BarometerService(context),
+      GravitySensorService(context),
+      GyroscopeService(context),
+      LinearAccelerationSensorService(context),
+      MagnetometerService(context),
+      MagnetometerUncalibratedService(context),
+      RotationVectorSensorService(context),
+      PedometerService(context)
+    )
+  }
+
+  override fun createExportedModules(context: Context): List<ExportedModule> {
+    return listOf<ExportedModule>(
+      AccelerometerModule(context),
+      BarometerModule(context),
+      GyroscopeModule(context),
+      DeviceMotionModule(context),
+      MagnetometerModule(context),
+      MagnetometerUncalibratedModule(context),
+      PedometerModule(context)
+    )
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/AccelerometerModule.kt

@@ -0,0 +1,55 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorManager
+import android.os.Bundle
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.services.AccelerometerServiceInterface
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+
+class AccelerometerModule(reactContext: Context?) : BaseSensorModule(reactContext) {
+  override val eventName: String = "accelerometerDidUpdate"
+
+  override fun getName(): String = "ExponentAccelerometer"
+
+  override fun getSensorService(): SensorServiceInterface {
+    return moduleRegistry.getModule(AccelerometerServiceInterface::class.java)
+  }
+
+  override fun eventToMap(sensorEvent: SensorEvent): Bundle {
+    return Bundle().apply {
+      putDouble("x", (sensorEvent.values[0] / SensorManager.GRAVITY_EARTH).toDouble())
+      putDouble("y", (sensorEvent.values[1] / SensorManager.GRAVITY_EARTH).toDouble())
+      putDouble("z", (sensorEvent.values[2] / SensorManager.GRAVITY_EARTH).toDouble())
+    }
+  }
+
+  @ExpoMethod
+  fun startObserving(promise: Promise) {
+    super.startObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun stopObserving(promise: Promise) {
+    super.stopObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun setUpdateInterval(updateInterval: Int, promise: Promise) {
+    super.setUpdateInterval(updateInterval)
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun isAvailableAsync(promise: Promise) {
+    val mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    val isAvailable = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null
+    promise.resolve(isAvailable)
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/BarometerModule.kt

@@ -0,0 +1,54 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorManager
+import android.os.Bundle
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.services.BarometerServiceInterface
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+
+class BarometerModule(reactContext: Context?) : BaseSensorModule(reactContext) {
+  override val eventName: String = "barometerDidUpdate"
+
+  override fun getName(): String = "ExpoBarometer"
+
+  override fun getSensorService(): SensorServiceInterface {
+    return moduleRegistry.getModule(BarometerServiceInterface::class.java)
+  }
+
+  override fun eventToMap(sensorEvent: SensorEvent): Bundle {
+    return Bundle().apply {
+      // TODO: Bacon: Can we get relative altitude?
+      putDouble("pressure", sensorEvent.values[0].toDouble())
+    }
+  }
+
+  @ExpoMethod
+  fun startObserving(promise: Promise) {
+    super.startObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun stopObserving(promise: Promise) {
+    super.stopObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun setUpdateInterval(updateInterval: Int, promise: Promise) {
+    super.setUpdateInterval(updateInterval)
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun isAvailableAsync(promise: Promise) {
+    val mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    val isAvailable = mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null
+    promise.resolve(isAvailable)
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/BaseSensorModule.kt

@@ -0,0 +1,80 @@
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener2
+import android.os.Bundle
+import android.util.Log
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.SensorServiceSubscriptionInterface
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.interfaces.LifecycleEventListener
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.core.interfaces.services.UIManager
+
+abstract class BaseSensorModule internal constructor(context: Context?) : ExportedModule(context), SensorEventListener2, LifecycleEventListener {
+  lateinit var moduleRegistry: ModuleRegistry
+    private set
+  private val sensorKernelServiceSubscription: SensorServiceSubscriptionInterface by lazy {
+    getSensorService().createSubscriptionForListener(this)
+  }
+  private var mIsObserving = false
+
+  protected abstract val eventName: String
+  protected abstract fun getSensorService(): SensorServiceInterface
+  protected abstract fun eventToMap(sensorEvent: SensorEvent): Bundle
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    this.moduleRegistry = moduleRegistry
+
+    // Unregister from old UIManager
+    moduleRegistry.getModule(UIManager::class.java)?.unregisterLifecycleEventListener(this)
+
+    // Register to new UIManager
+    moduleRegistry.getModule(UIManager::class.java)?.registerLifecycleEventListener(this)
+  }
+
+  override fun onSensorChanged(sensorEvent: SensorEvent) {
+    val eventEmitter = moduleRegistry.getModule(EventEmitter::class.java)
+    eventEmitter?.emit(eventName, eventToMap(sensorEvent))
+      ?: Log.e("E_SENSOR_MODULE", "Could not emit $eventName event, no event emitter present.")
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) = Unit
+
+  override fun onFlushCompleted(sensor: Sensor) = Unit
+
+  fun setUpdateInterval(updateInterval: Int) {
+    sensorKernelServiceSubscription.updateInterval = updateInterval.toLong()
+  }
+
+  fun startObserving() {
+    mIsObserving = true
+    sensorKernelServiceSubscription.start()
+  }
+
+  fun stopObserving() {
+    if (mIsObserving) {
+      mIsObserving = false
+      sensorKernelServiceSubscription.stop()
+    }
+  }
+
+  override fun onHostResume() {
+    if (mIsObserving) {
+      sensorKernelServiceSubscription.start()
+    }
+  }
+
+  override fun onHostPause() {
+    if (mIsObserving) {
+      sensorKernelServiceSubscription.stop()
+    }
+  }
+
+  override fun onHostDestroy() {
+    sensorKernelServiceSubscription.release()
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/DeviceMotionModule.kt

@@ -0,0 +1,242 @@
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener2
+import android.hardware.SensorManager
+import android.os.Bundle
+import android.view.Choreographer
+import android.view.Surface
+import android.view.WindowManager
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.SensorServiceSubscriptionInterface
+import expo.modules.interfaces.sensors.services.AccelerometerServiceInterface
+import expo.modules.interfaces.sensors.services.GravitySensorServiceInterface
+import expo.modules.interfaces.sensors.services.GyroscopeServiceInterface
+import expo.modules.interfaces.sensors.services.LinearAccelerationSensorServiceInterface
+import expo.modules.interfaces.sensors.services.RotationVectorSensorServiceInterface
+import expo.modules.core.ExportedModule
+import expo.modules.core.ModuleRegistry
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+import expo.modules.core.interfaces.services.EventEmitter
+import expo.modules.core.interfaces.services.UIManager
+
+class DeviceMotionModule(context: Context?) : ExportedModule(context), SensorEventListener2 {
+  private var mLastUpdate: Long = 0
+  private var mUpdateInterval = 1.0f / 60.0f
+  private val mRotationMatrix = FloatArray(9)
+  private val mRotationResult = FloatArray(3)
+  private var mAccelerationEvent: SensorEvent? = null
+  private var mAccelerationIncludingGravityEvent: SensorEvent? = null
+  private var mRotationEvent: SensorEvent? = null
+  private var mRotationRateEvent: SensorEvent? = null
+  private var mGravityEvent: SensorEvent? = null
+  private lateinit var mServiceSubscriptions: MutableList<SensorServiceSubscriptionInterface>
+  private lateinit var mUIManager: UIManager
+  private lateinit var mModuleRegistry: ModuleRegistry
+
+  private val mCurrentFrameCallback: ScheduleDispatchFrameCallback = ScheduleDispatchFrameCallback()
+  private val mDispatchEventRunnable = DispatchEventRunnable()
+  private lateinit var mEventEmitter: EventEmitter
+
+  override fun getName(): String = "ExponentDeviceMotion"
+
+  override fun getConstants(): Map<String, Any> {
+    // Gravity on the planet this module supports (currently just Earth) represented as m/s^2.
+    return mapOf(Pair("Gravity", 9.80665))
+  }
+
+  @ExpoMethod
+  fun setUpdateInterval(updateInterval: Int, promise: Promise) {
+    mUpdateInterval = updateInterval.toFloat()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun startObserving(promise: Promise) {
+    if (!this::mServiceSubscriptions.isInitialized) {
+      mServiceSubscriptions = ArrayList()
+      for (kernelService in getSensorKernelServices()) {
+        val subscription = kernelService.createSubscriptionForListener(this)
+        // We want handle update interval on our own,
+        // because we need to coordinate updates from multiple sensor services.
+        subscription.updateInterval = 0
+        mServiceSubscriptions.add(subscription)
+      }
+    }
+    mServiceSubscriptions.forEach { it.start() }
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun stopObserving(promise: Promise) {
+    mUIManager.runOnUiQueueThread {
+      mServiceSubscriptions.forEach { it.stop() }
+      mCurrentFrameCallback.stop()
+      promise.resolve(null)
+    }
+  }
+
+  @ExpoMethod
+  fun isAvailableAsync(promise: Promise) {
+    val mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    val sensorTypes = arrayListOf(Sensor.TYPE_GYROSCOPE, Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_LINEAR_ACCELERATION, Sensor.TYPE_ROTATION_VECTOR, Sensor.TYPE_GRAVITY)
+    for (type in sensorTypes) {
+      if (mSensorManager.getDefaultSensor(type!!) == null) {
+        promise.resolve(false)
+        return
+      }
+    }
+    promise.resolve(true)
+  }
+
+  override fun onCreate(moduleRegistry: ModuleRegistry) {
+    mEventEmitter = moduleRegistry.getModule(EventEmitter::class.java)
+    mUIManager = moduleRegistry.getModule(UIManager::class.java)
+    mModuleRegistry = moduleRegistry
+  }
+
+  private fun getSensorKernelServices(): List<SensorServiceInterface> {
+    return arrayListOf(
+      mModuleRegistry.getModule(GyroscopeServiceInterface::class.java),
+      mModuleRegistry.getModule(LinearAccelerationSensorServiceInterface::class.java),
+      mModuleRegistry.getModule(AccelerometerServiceInterface::class.java),
+      mModuleRegistry.getModule(RotationVectorSensorServiceInterface::class.java),
+      mModuleRegistry.getModule(GravitySensorServiceInterface::class.java)
+    )
+  }
+
+  override fun onSensorChanged(sensorEvent: SensorEvent) {
+    val sensor = sensorEvent.sensor
+    when (sensor.type) {
+      Sensor.TYPE_GYROSCOPE -> mRotationRateEvent = sensorEvent
+      Sensor.TYPE_ACCELEROMETER -> mAccelerationIncludingGravityEvent = sensorEvent
+      Sensor.TYPE_LINEAR_ACCELERATION -> mAccelerationEvent = sensorEvent
+      Sensor.TYPE_ROTATION_VECTOR -> mRotationEvent = sensorEvent
+      Sensor.TYPE_GRAVITY -> mGravityEvent = sensorEvent
+    }
+    mCurrentFrameCallback.maybePostFromNonUI()
+  }
+
+  override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) = Unit
+
+  override fun onFlushCompleted(sensor: Sensor) = Unit
+
+  private inner class ScheduleDispatchFrameCallback : Choreographer.FrameCallback {
+    @Volatile
+    private var mIsPosted = false
+    private var mShouldStop = false
+
+    override fun doFrame(frameTimeNanos: Long) {
+      if (mShouldStop) {
+        mIsPosted = false
+      } else {
+        post()
+      }
+      val curTime = System.currentTimeMillis()
+      if (curTime - mLastUpdate > mUpdateInterval) {
+        mUIManager.runOnClientCodeQueueThread(mDispatchEventRunnable)
+        mLastUpdate = curTime
+      }
+    }
+
+    fun stop() {
+      mShouldStop = true
+    }
+
+    fun maybePost() {
+      if (!mIsPosted) {
+        mIsPosted = true
+        post()
+      }
+    }
+
+    private fun post() {
+      Choreographer.getInstance().postFrameCallback(mCurrentFrameCallback)
+    }
+
+    fun maybePostFromNonUI() {
+      if (mIsPosted) {
+        return
+      }
+      mUIManager.runOnUiQueueThread { maybePost() }
+    }
+  }
+
+  private inner class DispatchEventRunnable : Runnable {
+    override fun run() {
+      mEventEmitter.emit("deviceMotionDidUpdate", eventsToMap())
+    }
+  }
+
+  private fun eventsToMap(): Bundle {
+    val map = Bundle()
+    var interval = 0.0
+    if (mAccelerationEvent != null) {
+      map.putBundle(
+        "acceleration",
+        Bundle().apply {
+          putDouble("x", mAccelerationEvent!!.values[0].toDouble())
+          putDouble("y", mAccelerationEvent!!.values[1].toDouble())
+          putDouble("z", mAccelerationEvent!!.values[2].toDouble())
+        }
+      )
+      interval = mAccelerationEvent!!.timestamp.toDouble()
+    }
+    if (mAccelerationIncludingGravityEvent != null && mGravityEvent != null) {
+      map.putBundle(
+        "accelerationIncludingGravity",
+        Bundle().apply {
+          putDouble("x", (mAccelerationIncludingGravityEvent!!.values[0] - 2 * mGravityEvent!!.values[0]).toDouble())
+          putDouble("y", (mAccelerationIncludingGravityEvent!!.values[1] - 2 * mGravityEvent!!.values[1]).toDouble())
+          putDouble("z", (mAccelerationIncludingGravityEvent!!.values[2] - 2 * mGravityEvent!!.values[2]).toDouble())
+        }
+      )
+      interval = mAccelerationIncludingGravityEvent!!.timestamp.toDouble()
+    }
+    if (mRotationRateEvent != null) {
+      map.putBundle(
+        "rotationRate",
+        Bundle().apply {
+          putDouble("alpha", Math.toDegrees(mRotationRateEvent!!.values[0].toDouble()))
+          putDouble("beta", Math.toDegrees(mRotationRateEvent!!.values[1].toDouble()))
+          putDouble("gamma", Math.toDegrees(mRotationRateEvent!!.values[2].toDouble()))
+        }
+      )
+      interval = mRotationRateEvent!!.timestamp.toDouble()
+    }
+    if (mRotationEvent != null) {
+      SensorManager.getRotationMatrixFromVector(mRotationMatrix, mRotationEvent!!.values)
+      SensorManager.getOrientation(mRotationMatrix, mRotationResult)
+      map.putBundle(
+        "rotation",
+        Bundle().apply {
+          putDouble("alpha", (-mRotationResult[0]).toDouble())
+          putDouble("beta", (-mRotationResult[1]).toDouble())
+          putDouble("gamma", mRotationResult[2].toDouble())
+        }
+      )
+      interval = mRotationEvent!!.timestamp.toDouble()
+    }
+    map.putDouble("interval", interval)
+    map.putInt("orientation", getOrientation())
+    return map
+  }
+
+  private fun getOrientation(): Int {
+    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager?
+    if (windowManager != null) {
+      when (windowManager.defaultDisplay.rotation) {
+        Surface.ROTATION_0 -> return 0
+        Surface.ROTATION_90 -> return 90
+        Surface.ROTATION_180 -> return 180
+        Surface.ROTATION_270 -> return -90
+        else -> {
+        }
+      }
+    }
+    return 0
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/GyroscopeModule.kt

@@ -0,0 +1,55 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorManager
+import android.os.Bundle
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.services.GyroscopeServiceInterface
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+
+class GyroscopeModule(reactContext: Context?) : BaseSensorModule(reactContext) {
+  override val eventName: String = "gyroscopeDidUpdate"
+
+  override fun getName(): String = "ExponentGyroscope"
+
+  override fun getSensorService(): SensorServiceInterface {
+    return moduleRegistry.getModule(GyroscopeServiceInterface::class.java)
+  }
+
+  override fun eventToMap(sensorEvent: SensorEvent): Bundle {
+    return Bundle().apply {
+      putDouble("x", sensorEvent.values[0].toDouble())
+      putDouble("y", sensorEvent.values[1].toDouble())
+      putDouble("z", sensorEvent.values[2].toDouble())
+    }
+  }
+
+  @ExpoMethod
+  fun startObserving(promise: Promise) {
+    super.startObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun stopObserving(promise: Promise) {
+    super.stopObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun setUpdateInterval(updateInterval: Int, promise: Promise) {
+    super.setUpdateInterval(updateInterval)
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun isAvailableAsync(promise: Promise) {
+    val mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    val isAvailable = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE) != null
+    promise.resolve(isAvailable)
+  }
+}

package/android/src/main/java/expo/modules/sensors/modules/MagnetometerModule.kt

@@ -0,0 +1,55 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+package expo.modules.sensors.modules
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorManager
+import android.os.Bundle
+import expo.modules.interfaces.sensors.SensorServiceInterface
+import expo.modules.interfaces.sensors.services.MagnetometerServiceInterface
+import expo.modules.core.Promise
+import expo.modules.core.interfaces.ExpoMethod
+
+class MagnetometerModule(reactContext: Context?) : BaseSensorModule(reactContext) {
+  override val eventName: String = "magnetometerDidUpdate"
+
+  override fun getName(): String = "ExponentMagnetometer"
+
+  override fun getSensorService(): SensorServiceInterface {
+    return moduleRegistry.getModule(MagnetometerServiceInterface::class.java)
+  }
+
+  override fun eventToMap(sensorEvent: SensorEvent): Bundle {
+    return Bundle().apply {
+      putDouble("x", sensorEvent.values[0].toDouble())
+      putDouble("y", sensorEvent.values[1].toDouble())
+      putDouble("z", sensorEvent.values[2].toDouble())
+    }
+  }
+
+  @ExpoMethod
+  fun startObserving(promise: Promise) {
+    super.startObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun stopObserving(promise: Promise) {
+    super.stopObserving()
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun setUpdateInterval(updateInterval: Int, promise: Promise) {
+    super.setUpdateInterval(updateInterval)
+    promise.resolve(null)
+  }
+
+  @ExpoMethod
+  fun isAvailableAsync(promise: Promise) {
+    val mSensorManager = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    val isAvailable = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null
+    promise.resolve(isAvailable)
+  }
+}