@blife/rn-step-counter 1.0.0

package/android/src/main/java/com/stepcounter/StepCounterModule.kt

@@ -0,0 +1,190 @@
+package com.stepcounter
+
+import android.content.Context
+import android.hardware.SensorManager
+import android.os.Build.VERSION_CODES
+import android.util.Log
+import androidx.core.content.PermissionChecker.PERMISSION_GRANTED
+import androidx.core.content.PermissionChecker.checkSelfPermission
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import com.stepcounter.services.AccelerometerService
+import com.stepcounter.services.SensorListenService
+import com.stepcounter.services.StepCounterService
+import com.stepcounter.utils.AndroidVersionHelper
+
+/**
+ * This class is the native module for the react-native-step-counter package.
+ *
+ * It is responsible for the communication between the native and the react-native code.
+ * @param reactContext The context of the react-native application
+ * @property appContext The context of the react-native application from [context][com.facebook.react.bridge.ReactApplicationContext]
+ * @property sensorManager The sensor manager that is responsible for the sensor
+ * @property stepCounterListener The service that is responsible for the step counter sensor
+ * @constructor Creates a new StepCounterModule implements StepCounterSpec
+ * @see ReactContextBaseJavaModule
+ * @see ReactApplicationContext
+ * @see NativeStepCounterSpec
+ */
+class StepCounterModule(
+  reactContext: ReactApplicationContext,
+) : NativeStepCounterSpec(reactContext) {
+  companion object {
+    const val NAME: String = NativeStepCounterSpec.NAME
+    private val TAG_NAME: String = StepCounterModule::class.java.name
+    private const val STEP_COUNTER = "android.permission.ACTIVITY_RECOGNITION"
+  }
+
+  private val appContext: ReactApplicationContext = reactContext
+  private var sensorManager: SensorManager =
+    reactContext.getSystemService(
+      Context.SENSOR_SERVICE,
+    ) as SensorManager
+  private val stepsOK: Boolean
+    get() = checkSelfPermission(appContext, STEP_COUNTER) == PERMISSION_GRANTED
+  private val accelOK: Boolean
+    get() = AndroidVersionHelper.isHardwareAccelerometerEnabled(appContext)
+  private val supported: Boolean
+    get() = AndroidVersionHelper.isHardwareStepCounterEnabled(appContext)
+  private val walkingStatus: Boolean
+    get() = stepCounterListener !== null
+
+  /**
+   * gets the step counter listener
+   * @return the step counter listener
+   * @see SensorListenService
+   * @see StepCounterService
+   * @see AccelerometerService
+   * @see checkSelfPermission
+   * @see PERMISSION_GRANTED
+   */
+  private var stepCounterListener: SensorListenService? = null
+
+  /**
+   * The method that is called when the module is initialized.
+   * It checks the permission and the availability for the step counter sensor and initializes the step counter service.
+   */
+  init {
+    stepCounterListener =
+      if (stepsOK) {
+        StepCounterService(this, sensorManager)
+      } else {
+        AccelerometerService(this, sensorManager)
+      }
+    appContext.addLifecycleEventListener(stepCounterListener)
+  }
+
+  /**
+   * The method ask if the step counter sensor is supported.
+   * @param promise the promise that is used to return the result to the react-native code
+   * @see Promise.resolve
+   * @see VERSION_CODES.ECLAIR
+   * @see VERSION_CODES.KITKAT
+   * @see WritableMap
+   */
+  @ReactMethod
+  override fun isStepCountingSupported(promise: Promise) {
+    Log.d(TAG_NAME, "hardware_step_counter? $supported")
+    Log.d(TAG_NAME, "step_counter granted? $stepsOK")
+    Log.d(TAG_NAME, "accelerometer granted? $accelOK")
+    sendDeviceEvent("stepDetected", walkingStatus)
+    promise.resolve(
+      Arguments.createMap().apply {
+        putBoolean("supported", supported)
+        putBoolean("granted", stepsOK || accelOK)
+        putBoolean("working", walkingStatus)
+      },
+    )
+  }
+
+  /**
+   * Start the step counter sensor.
+   * @param from the number of steps to start from
+   */
+  @ReactMethod
+  override fun startStepCounterUpdate(from: Double) {
+    val sessionStartMillis = normalizeStartTimestampToMillis(from)
+    stepCounterListener = stepCounterListener ?: if (stepsOK) {
+      StepCounterService(this, sensorManager)
+    } else {
+      AccelerometerService(this, sensorManager)
+    }
+    Log.d(TAG_NAME, "startStepCounterUpdate")
+    stepCounterListener!!.startService(sessionStartMillis)
+  }
+
+  /**
+   * Stop the step counter sensor.
+   * @return Nothing.
+   */
+  @ReactMethod
+  override fun stopStepCounterUpdate() {
+    Log.d(TAG_NAME, "stopStepCounterUpdate")
+    stepCounterListener!!.stopService()
+  }
+
+  /**
+   * Keep: Required for RN built in Event Emitter Support.
+   * @param eventName the name of the event. usually "stepCounterUpdate".
+   */
+  @ReactMethod
+  override fun addListener(eventName: String) {
+  }
+
+  /**
+   * Keep: Required for RN built in Event Emitter Support.
+   * @param count the number of listeners to remove.
+   * not implemented.
+   */
+  @ReactMethod
+  override fun removeListeners(count: Double) {
+  }
+
+  /**
+   * StepCounterPackage requires this property for the module.
+   * @return the name of the module. usually "StepCounter".
+   */
+  override fun getName(): String = NAME
+
+  /**
+   * Send the step counter update event to the react-native code.
+   * @param eventPayload the object that contains information about the step counter update.
+   * @return Nothing.
+   * @see WritableMap
+   * @see RCTDeviceEventEmitter
+   * @see com.facebook.react.modules.core.DeviceEventManagerModule
+   * @throws RuntimeException if the event emitter is not initialized.
+   */
+  fun sendDeviceEvent(
+    eventType: String,
+    eventPayload: Any,
+  ) {
+    try {
+      appContext
+        .getJSModule(RCTDeviceEventEmitter::class.java)
+        .emit(eventName = "$NAME.$eventType", data = eventPayload)
+    } catch (e: RuntimeException) {
+      e.message?.let { Log.e(TAG_NAME, it) }
+      Log.e(TAG_NAME, eventType, e)
+    }
+  }
+
+  /**
+   * JS passes ms; accept seconds too for backward-compat.
+   */
+  private fun normalizeStartTimestampToMillis(from: Double): Long {
+    if (!from.isFinite() || from <= 0) {
+      return System.currentTimeMillis()
+    }
+    return if (from >= 1_000_000_000_000.0) {
+      from.toLong()
+    } else {
+      (from * 1000).toLong()
+    }
+  }
+}

package/android/src/main/java/com/stepcounter/StepCounterPackage.kt

@@ -0,0 +1,53 @@
+package com.stepcounter
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+/**
+ * This class is responsible for the creation of the ReactNative package.
+ * @see com.facebook.react.ReactPackage
+ * @see BaseReactPackage
+ * @see ReactApplicationContext
+ * @see ReactModuleInfo
+ * @see ReactModuleInfoProvider
+ */
+class StepCounterPackage : BaseReactPackage() {
+  /**
+   * This method is responsible for the creation of the ReactNative module.
+   * @param name The name of the module
+   * @param reactContext The context of the react-native application
+   * @return [com.facebook.react.module.model.ReactModuleInfo] ]The ReactNative module
+   * @see NativeModule
+   * @see ReactApplicationContext
+   * @see StepCounterModule
+   * @see StepCounterModule.NAME
+   */
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? = if (name == StepCounterModule.NAME) StepCounterModule(reactContext) else null
+
+  /**
+   * This method is responsible for the creation of the ReactNative module info provider.
+   * @return The ReactNative module info provider
+   * @see ReactModuleInfoProvider
+   * @see ReactModuleInfo
+   */
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      val moduleInfo: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfo[StepCounterModule.NAME] =
+        ReactModuleInfo(
+          name = StepCounterModule.NAME,
+          className = StepCounterModule.NAME,
+          canOverrideExistingModule = false,
+          needsEagerInit = false,
+          isCxxModule = false,
+          isTurboModule = true,
+        )
+      moduleInfo
+    }
+}

package/android/src/main/java/com/stepcounter/services/AccelerometerService.kt

@@ -0,0 +1,147 @@
+package com.stepcounter.services
+
+import android.hardware.Sensor
+import android.hardware.SensorManager
+import android.util.Log
+import com.stepcounter.StepCounterModule
+import com.stepcounter.utils.SensorFusionMath.dot
+import com.stepcounter.utils.SensorFusionMath.norm
+import com.stepcounter.utils.SensorFusionMath.normalize
+import com.stepcounter.utils.SensorFusionMath.sum
+import kotlin.math.min
+
+/**
+ * This class is responsible for listening to the accelerometer sensor.
+ * It is used to count the steps of the user.
+ * @constructor Creates a new AccelerometerService
+ * @param counterModule The module that is responsible for the communication with the react-native layer
+ * @param sensorManager The sensor manager that is responsible for the sensor
+ *
+ * @property sensorTypeString The type of the sensor as a string "Accelerometer"
+ * @property sensorType The type of the sensor
+ * @property detectedSensor The sensor that is detected
+ * @property currentSteps The current steps
+ * @property velocityRingCounter The velocity ring counter
+ * @property accelRingCounter The acceleration ring counter
+ * @property oldVelocityEstimate The old velocity estimate
+ * @property startDate The last step time in milliseconds
+ * @property accelRingX The acceleration ring for the x-axis
+ * @property accelRingY The acceleration ring for the y-axis
+ * @property accelRingZ The acceleration ring for the z-axis
+ * @property velocityRing The velocity ring
+ *
+ * @see SensorListenService
+ * @see Sensor
+ * @see SensorManager
+ * @see StepCounterModule
+ * @see SensorManager.SENSOR_DELAY_NORMAL
+ * @see Sensor.TYPE_ACCELEROMETER
+ */
+class AccelerometerService(
+  counterModule: StepCounterModule,
+  sensorManager: SensorManager,
+) : SensorListenService(counterModule, sensorManager) {
+  override val sensorTypeString = "Accelerometer"
+  override val sensorType = Sensor.TYPE_ACCELEROMETER
+  override val detectedSensor: Sensor? = sensorManager.getDefaultSensor(sensorType)
+  override var currentSteps: Double = 0.0
+  private var velocityRingCounter: Int = 0
+  private var accelRingCounter: Int = 0
+  private var oldVelocityEstimate: Float = 0f
+  private var lastStepTimeNs: Long = 0
+
+  // We want to keep a history of values to do a rolling average of the current
+  private val accelRingX = FloatArray(ACCEL_RING_SIZE)
+  private val accelRingY = FloatArray(ACCEL_RING_SIZE)
+  private val accelRingZ = FloatArray(ACCEL_RING_SIZE)
+
+  // We want to keep a history of values to do a rolling average of the current
+  private val velocityRing = FloatArray(VELOCITY_RING_SIZE)
+
+  override fun resetSessionState() {
+    currentSteps = 0.0
+    velocityRingCounter = 0
+    accelRingCounter = 0
+    oldVelocityEstimate = 0f
+    lastStepTimeNs = 0
+    accelRingX.fill(0f)
+    accelRingY.fill(0f)
+    accelRingZ.fill(0f)
+    velocityRing.fill(0f)
+  }
+
+  /**
+   * This function is responsible for updating the current steps.
+   * All [values][android.hardware.SensorEvent.values] are in SI units (m/s^2)
+   *
+   * - values[0]: Acceleration minus Gx on the x-axis
+   * - values[1]: Acceleration minus Gy on the y-axis
+   * - values[2]: Acceleration minus Gz on the z-axis
+   *
+   * @param eventData array of vector.
+   * @return If the current step is just updated
+   * @see android.hardware.SensorEvent
+   * @see android.hardware.SensorEvent.values
+   * @see android.hardware.SensorEvent.timestamp
+   */
+  override fun updateCurrentSteps(eventData: FloatArray): Boolean {
+    val timeNs = System.nanoTime()
+    // First step is to update our guess of where the global z vector is.
+    accelRingCounter++
+    // We keep a rolling average of the last 50 values
+    accelRingX[accelRingCounter % ACCEL_RING_SIZE] = eventData[0]
+    accelRingY[accelRingCounter % ACCEL_RING_SIZE] = eventData[1]
+    accelRingZ[accelRingCounter % ACCEL_RING_SIZE] = eventData[2]
+    // Next we'll calculate the average of the last 50 vectors in the ring
+    val gravity: FloatArray =
+      floatArrayOf(
+        sum(accelRingX) / min(accelRingCounter, ACCEL_RING_SIZE),
+        sum(accelRingY) / min(accelRingCounter, ACCEL_RING_SIZE),
+        sum(accelRingZ) / min(accelRingCounter, ACCEL_RING_SIZE),
+      )
+    // Next step is to figure out the component of the current acceleration
+    // in the direction of world_z and subtract gravity's contribution
+    val currentZ: Float = dot(normalize(gravity), eventData) - norm(gravity)
+    // Now we just need to update our estimate of the velocity
+    velocityRingCounter++
+    // We keep a rolling average of the last 10 values
+    velocityRing[velocityRingCounter % VELOCITY_RING_SIZE] = currentZ
+    // Calculate the average of the last 10 values
+    val velocityEstimate: Float = sum(velocityRing)
+    // If the velocity estimate is greater than the threshold and the previous
+    val isWalkingOrRunning: Boolean =
+      STEP_THRESHOLD in oldVelocityEstimate..<velocityEstimate &&
+        timeNs - lastStepTimeNs > STEP_DELAY_NS
+    if (isWalkingOrRunning) {
+      currentSteps = currentSteps.plus(1)
+      Log.d(TAG_NAME, "STATUS: $currentSteps steps. TIMESTAMP: $timeNs")
+      lastStepTimeNs = timeNs
+    }
+    oldVelocityEstimate = velocityEstimate
+    return isWalkingOrRunning
+  }
+
+  companion object {
+    /**
+     * The delay between steps in nanoseconds
+     */
+    private const val STEP_DELAY_NS = 250000000 // 250ms
+
+    /**
+     * The size of the acceleration sensor data ring
+     */
+    private const val ACCEL_RING_SIZE = 50
+
+    /**
+     * The size of the acceleration's velocity ring
+     */
+    private const val VELOCITY_RING_SIZE = 10
+
+    /**
+     * The minimum acceleration that is considered a step
+     */
+    private const val STEP_THRESHOLD = 12f // 4f-16f
+
+    val TAG_NAME: String = AccelerometerService::class.java.name
+  }
+}

package/android/src/main/java/com/stepcounter/services/SensorListenService.kt

@@ -0,0 +1,305 @@
+package com.stepcounter.services
+
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.LifecycleEventListener
+import com.facebook.react.bridge.WritableMap
+import com.stepcounter.StepCounterModule
+
+/**
+ * the base class for sensor listen service
+ * @param counterModule the step counter module
+ * @param sensorManager the sensor manager
+ * @see StepCounterModule
+ * @see Sensor
+ * @see SensorEvent
+ * @see <a href="https://developer.android.com/reference/android/hardware/SensorEventListener">SensorEventListener</a>
+ * @see <a href="https://developer.android.com/reference/android/hardware/SensorManager">SensorManager</a>
+ * @see <a href="https://reactnative.dev/docs/native-modules-android#listening-to-lifecycle-events">LifecycleEventListener: document</a>
+ * @see <a href="https://github.com/facebook/react-native/blob/main/ReactAndroid/src/main/java/com/facebook/react/bridge/LifecycleEventListener.java">LifecycleEventListener: original file</a>
+ */
+abstract class SensorListenService(
+  private val counterModule: StepCounterModule,
+  private val sensorManager: SensorManager,
+) : SensorEventListener,
+  LifecycleEventListener {
+  /**
+   * the accelerometer sensor type
+   * [TYPE_ACCELEROMETER][Sensor.TYPE_ACCELEROMETER]: 1<br/>
+   *
+   * the step counter sensor type
+   * [TYPE_STEP_COUNTER][Sensor.TYPE_STEP_COUNTER]: 19<br/>
+   */
+  abstract val sensorType: Int
+
+  /**
+   * The `rate` of [sensor events][android.hardware.SensorEvent] are
+   * delivered at. This is only a hint to the system. Events may be received faster or
+   * slower than the specified rate. Usually events are received faster.
+   *
+   * [samplingPeriodUs] – The desired delay between two consecutive events in microseconds.
+   * This is only a hint to the system. Events may be received faster or slower than the specified rate.
+   * Typically, events are received faster. Can be one of [SENSOR_DELAY_NORMAL][SensorManager.SENSOR_DELAY_NORMAL], [SENSOR_DELAY_UI][SensorManager.SENSOR_DELAY_UI],
+   * [SENSOR_DELAY_GAME][SensorManager.SENSOR_DELAY_GAME], or [SENSOR_DELAY_FASTEST][SensorManager.SENSOR_DELAY_FASTEST]
+   * or, the desired delay between events in microseconds. Specifying the delay in microseconds only works
+   * from Android 2.3 (API level 9) onwards. For earlier releases, you must use one of the `SENSOR_DELAY_*` constants.
+   *
+   * @see
+   * The following are the constants for the sampling period in microseconds
+   * <pre class="prettyprint kotlin">
+   * private fun getDelay(rate: Int): Int {
+   *     return when (rate) {
+   *         SensorManager.SENSOR_DELAY_FASTEST -> 0
+   *         SensorManager.SENSOR_DELAY_GAME -> 20000
+   *         SensorManager.SENSOR_DELAY_UI -> 66667
+   *         SensorManager.SENSOR_DELAY_NORMAL -> 200000
+   *         else -> rate
+   *     }
+   * }
+   * </pre>
+   */
+  private val samplingPeriodUs
+    get() =
+      when (sensorType) {
+        Sensor.TYPE_ACCELEROMETER -> SensorManager.SENSOR_DELAY_GAME
+        Sensor.TYPE_STEP_COUNTER -> SensorManager.SENSOR_DELAY_NORMAL
+        else -> SensorManager.SENSOR_DELAY_UI
+      }
+
+  /**
+   * @return if the [sensor][detectedSensor] is
+   * [accelerometer][Sensor.TYPE_ACCELEROMETER],
+   * "Accelerometer"
+   * if it's [stepCounter][Sensor.TYPE_STEP_COUNTER],
+   * "Step Counter".
+   */
+  abstract val sensorTypeString: String
+
+  /**
+   * the detected sensor
+   * @see SensorManager.getDefaultSensor
+   * @see SensorManager.getSensorList
+   * @see Sensor.TYPE_ACCELEROMETER
+   * @see Sensor.TYPE_STEP_COUNTER
+   */
+  abstract val detectedSensor: Sensor?
+
+  /**
+   * the current steps data of the user
+   * @see currentSteps
+   * @see distance
+   * @see endDate
+   * @see sensorTypeString
+   * @see calories
+   * @see WritableMap
+   * @see Arguments.createMap
+   */
+  val stepsParamsMap: WritableMap
+    get() =
+      Arguments.createMap().apply {
+        putNumber("steps", currentSteps)
+        putNumber("distance", distance)
+        putNumber("startDate", startDate)
+        putNumber("endDate", endDate)
+        putString("counterType", sensorTypeString)
+        putNumber("calories", calories)
+      }
+
+  val stepsSensorInfo: WritableMap
+    get() =
+      Arguments.createMap().apply {
+        putNumber("minDelay", detectedSensor!!.minDelay)
+        putNumber("maxDelay", detectedSensor!!.maxDelay)
+        putString("name", detectedSensor!!.name)
+        putString("vendor", detectedSensor!!.vendor)
+        putNumber("power", detectedSensor!!.power)
+        putNumber("resolution", detectedSensor!!.resolution)
+        putBoolean("wakeUpSensor", detectedSensor!!.isWakeUpSensor)
+        putBoolean("additionalInfoSupported", detectedSensor!!.isAdditionalInfoSupported)
+      }
+
+  /**
+   * Number of in-database-saved calories.
+   * 0.045 is the average calories burned per step.
+   * to get more accurate result, you can use this formula:
+   * 0.045 * weight * distance,
+   * but then you need to get the weight of the user. so it needs some permission.
+   */
+  private val calories: Double
+    get() = currentSteps * 0.045
+
+  /**
+   * Distance of in-database-saved steps
+   */
+  private val distance: Double
+    get() = currentSteps * 0.762
+
+  /**
+   * Number of steps counted since service start
+   */
+  abstract var currentSteps: Double
+
+  /**
+   * Reset in-memory session state before a new counting session starts.
+   */
+  protected open fun resetSessionState() {
+  }
+
+  /**
+   * Start date of the step counting. UTC milliseconds
+   */
+  private var startDate: Long = System.currentTimeMillis()
+
+  /**
+   * End date of the step counting. UTC milliseconds
+   */
+  private val endDate: Long
+    get() = System.currentTimeMillis()
+
+  private val sensorDelay: Int
+    get() =
+      when (samplingPeriodUs) {
+        SensorManager.SENSOR_DELAY_FASTEST -> 0
+        SensorManager.SENSOR_DELAY_GAME -> 20000
+        SensorManager.SENSOR_DELAY_UI -> 66667
+        SensorManager.SENSOR_DELAY_NORMAL -> 200000
+        else -> samplingPeriodUs
+      }
+
+  /**
+   * this class is not implemented Service class now, but made it work so
+   * @see android.content.Context.startService
+   * @see android.content.Context.stopService
+   * @see SensorManager.registerListener
+   */
+  fun startService(startDateMillis: Long? = null) {
+    startDate =
+      startDateMillis?.takeIf { it > 0 } ?: System.currentTimeMillis()
+    resetSessionState()
+    counterModule.sendDeviceEvent("stepsSensorInfo", stepsSensorInfo)
+    Log.d(TAG_NAME, "SensorManager.stepsSensorInfo: $stepsSensorInfo")
+    sensorManager.registerListener(this, detectedSensor, samplingPeriodUs)
+  }
+
+  /**
+   * this class is not implemented Service class now, but made it work so
+   * @see android.content.Context.startService
+   * @see android.content.Context.stopService
+   * @see SensorManager.unregisterListener
+   */
+  fun stopService() {
+    Log.d(TAG_NAME, "SensorListenService.stopService")
+    sensorManager.unregisterListener(this)
+  }
+
+  /**
+   * Called when there is a new sensor event.  Note that "on changed"
+   * is somewhat of a misnomer, as this will also be called if we have a
+   * new reading from a sensor with the exact same sensor values (but a
+   * newer timestamp).
+   * See [SensorManager][android.hardware.SensorManager]
+   * for details on possible sensor types.
+   * See also [SensorEvent][android.hardware.SensorEvent].
+   *
+   * **NOTE1:** The application doesn't own the [event][android.hardware.SensorEvent]
+   * object passed as a parameter and therefore cannot hold on to it.
+   * The object may be part of an internal pool and may be reused by
+   * the framework. If you need to hold on to the event, you must make a copy.
+   *
+   * **NOTE2:** Since the timestamp delivered from JavaScript is based on milliseconds,
+   * mistakes can occur if the timestamp of sensor events recorded every moment in nanoseconds is delivered as it is.
+   * Thus, we convert timestamp (nanoseconds recorded in sensor events) using [toMillis][java.util.concurrent.TimeUnit.toMillis] method,
+   * or call [currentTimeInMillis][System.currentTimeMillis] method according to the function execution time.
+   *
+   * @param event the [SensorEvent][android.hardware.SensorEvent].
+   * @see <a href="https://developer.android.com/reference/android/hardware/SensorEvent">Hardware Activity Sensors</a>
+   * @see <a href="https://developer.android.com/reference/android/hardware/SensorEvent#sensor.type_accelerometer:">Accelerometer Sensor Event</a>
+   * @see <a href="https://developer.android.com/reference/android/hardware/Sensor#TYPE_STEP_COUNTER">Step Counter Sensor Event</a>
+   * @see <a href="https://developer.android.com/reference/android/hardware/Sensor#REPORTING_MODE_ON_CHANGE">Reporting Mode On Change</a>
+   */
+  override fun onSensorChanged(event: SensorEvent?) {
+    if (event?.sensor == null ||
+      event.sensor != detectedSensor ||
+      event.sensor.type != sensorType ||
+      detectedSensor?.type != event.sensor.type
+    ) {
+      return
+    }
+    if (updateCurrentSteps(event.values)) {
+      counterModule.sendDeviceEvent("stepCounterUpdate", stepsParamsMap)
+    }
+  }
+
+  /**
+   * abstract method to update the current steps
+   * implemented in [StepCounterService] and [AccelerometerService]
+   * with different motion sensor handling algorithm.
+   * @param eventData the detected vector of sensor event
+   * @return if the current steps is updated, return true, otherwise return false
+   */
+  abstract fun updateCurrentSteps(eventData: FloatArray): Boolean
+
+  /**
+   * Called when the accuracy of the registered sensor has changed.
+   *
+   * Unlike onSensorChanged(), this is only called when this accuracy value changes.
+   * See the SENSOR_STATUS_* constants in
+   * [SensorManager][android.hardware.SensorManager] for details.
+   *
+   * @param sensor The [Sensor][android.hardware.Sensor] that has accuracy changed.
+   * @param accuracy The new accuracy of this sensor, one of
+   * `SensorManager.SENSOR_STATUS_*`
+   */
+  override fun onAccuracyChanged(
+    sensor: Sensor?,
+    accuracy: Int,
+  ) {
+    Log.d(TAG_NAME, "onAccuracyChanged.accuracy $accuracy")
+    Log.d(TAG_NAME, "onAccuracyChanged.sensor: $sensor")
+  }
+
+  /**
+   * Called either when the host activity receives a resume event or
+   * if the native module that implements this is initialized while the host activity is already
+   * resumed. Always called for the most current activity.
+   * @see Activity.onResume
+   */
+  override fun onHostResume() {
+  }
+
+  /**
+   * Called when host activity receives pause event.
+   * Always called for the most current activity.
+   * @see Activity.onPause
+   */
+  override fun onHostPause() {
+  }
+
+  /**
+   * Called when host activity receives destroy event.
+   * Only called for the last React activity to be destroyed.
+   * @see Activity.onDestroy
+   */
+  override fun onHostDestroy() {
+    this.stopService()
+  }
+
+  companion object {
+    val TAG_NAME: String = SensorListenService::class.java.name
+  }
+}
+
+private fun WritableMap.putNumber(
+  key: String,
+  number: Number,
+) {
+  when (number) {
+    is Double -> putDouble(key, number)
+    is Int -> putInt(key, number)
+    else -> putDouble(key, number.toDouble())
+  }
+}