@blife/rn-step-counter 1.0.0

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

@@ -0,0 +1,79 @@
+package com.stepcounter.services
+
+import android.hardware.Sensor
+import android.hardware.SensorManager
+import com.stepcounter.StepCounterModule
+import java.util.concurrent.TimeUnit
+
+/**
+ * This class is responsible for listening to the step counter sensor.
+ * It is used to count the steps of the user.
+ * @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 sensorType The type of the sensor always Sensor.TYPE_STEP_COUNTER
+ * @property sensorTypeString The type of the sensor as a string. so always "Step Counter"
+ * @property sensorDelay The integer enum value of delay of the sensor.
+ *   choose between SensorManager.SENSOR_DELAY_NORMAL or SensorManager.SENSOR_DELAY_UI
+ * @property detectedSensor The sensor that is detected
+ * @property previousSteps The initial steps or the previous steps.
+ *   step counter sensor is recording since the last reboot.
+ *   so if previous step is null, we need to initialize the previous steps with the current steps minus 1.
+ * @property currentSteps The current steps
+ * @constructor Creates a new StepCounterService
+ * @see SensorListenService
+ * @see Sensor
+ * @see SensorManager
+ * @see StepCounterModule
+ * @see TimeUnit
+ * @see SensorManager.SENSOR_DELAY_NORMAL
+ * @see Sensor.TYPE_STEP_COUNTER
+ * @see SensorManager.getDefaultSensor {@link SensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER)}
+ * @see SensorListenService.updateCurrentSteps
+ * @see TimeUnit.toMillis
+ */
+class StepCounterService(
+  counterModule: StepCounterModule,
+  sensorManager: SensorManager,
+) : SensorListenService(counterModule, sensorManager) {
+  override val sensorTypeString = "Step Counter"
+  override val sensorType = Sensor.TYPE_STEP_COUNTER
+  override val detectedSensor: Sensor? = sensorManager.getDefaultSensor(sensorType)
+  private var previousSteps: Double = 0.0
+    set(value) {
+      if (field < value) {
+        field = value
+      }
+    }
+  override var currentSteps: Double = 0.0
+    set(value) {
+      if (field < value) {
+        field = value
+      }
+    }
+
+  override fun resetSessionState() {
+    previousSteps = 0.0
+    currentSteps = 0.0
+  }
+
+  /**
+   * This function is responsible for updating the current steps.
+   * @param [eventData][FloatArray(1) values][android.hardware.SensorEvent.values] The step counter event data
+   * @return The current steps
+   * @see android.hardware.SensorEvent
+   * @see android.hardware.SensorEvent.values
+   * @see android.hardware.SensorEvent.timestamp
+   */
+  override fun updateCurrentSteps(eventData: FloatArray): Boolean {
+    // if the time difference is greater than the delay, set the current steps to the step count minus the initial steps
+    // if the previous steps aren't initialized yet,
+    return if (previousSteps == 0.0) {
+      previousSteps = eventData[0].toDouble()
+      false
+    } else {
+      currentSteps = eventData[0].toDouble().minus(previousSteps)
+      // set the last update to the current time
+      true
+    }
+  }
+}

package/android/src/main/java/com/stepcounter/utils/AndroidVersionHelper.kt

@@ -0,0 +1,33 @@
+package com.stepcounter.utils
+
+import android.content.Context
+import android.content.pm.PackageManager.FEATURE_SENSOR_ACCELEROMETER
+import android.content.pm.PackageManager.FEATURE_SENSOR_STEP_COUNTER
+import android.util.Log
+import androidx.annotation.RequiresFeature
+import com.stepcounter.utils.AndroidVersionHelper.TAG_NAME
+import com.stepcounter.utils.AndroidVersionHelper.isHardwareAccelerometerEnabled
+import com.stepcounter.utils.AndroidVersionHelper.isHardwareStepCounterEnabled
+
+/**
+ * This class is responsible for the version check of the android device.
+ * It is used to check whether the device supports hardware step detection.
+ * @property TAG_NAME The name of the class
+ * @property isHardwareStepCounterEnabled Decides whether the hardware step counter should be used
+ * @property isHardwareAccelerometerEnabled Decides whether the hardware accelerometer should be used
+ */
+object AndroidVersionHelper {
+  private val TAG_NAME: String = AndroidVersionHelper::class.java.name
+
+  @RequiresFeature(name = FEATURE_SENSOR_STEP_COUNTER, enforcement = "1")
+  fun isHardwareStepCounterEnabled(context: Context): Boolean {
+    Log.d(TAG_NAME, "isHardwareStepCounterEnabled: $FEATURE_SENSOR_STEP_COUNTER")
+    return context.packageManager.hasSystemFeature(FEATURE_SENSOR_STEP_COUNTER)
+  }
+
+  @RequiresFeature(name = FEATURE_SENSOR_ACCELEROMETER, enforcement = "1")
+  fun isHardwareAccelerometerEnabled(context: Context): Boolean {
+    Log.d(TAG_NAME, "isHardwareStepCounterEnabled: $FEATURE_SENSOR_ACCELEROMETER")
+    return context.packageManager.hasSystemFeature(FEATURE_SENSOR_ACCELEROMETER)
+  }
+}

package/android/src/main/java/com/stepcounter/utils/SensorFusionMath.kt

@@ -0,0 +1,104 @@
+package com.stepcounter.utils
+
+import com.stepcounter.utils.SensorFusionMath.dot
+import com.stepcounter.utils.SensorFusionMath.norm
+import com.stepcounter.utils.SensorFusionMath.normalize
+import kotlin.math.sqrt
+
+/**
+ * This class contains all the math functions used in the sensor fusion.
+ * @property SensorFusionMath.sum
+ * @property SensorFusionMath.cross
+ * @property SensorFusionMath.norm
+ * @property SensorFusionMath.normalize
+ * @property SensorFusionMath.dot
+ * @see <a href="https://en.wikipedia.org/wiki/Euclidean_vector">Euclidean vector</a>
+ */
+object SensorFusionMath {
+  /**
+   * The summation function, also known as a sigma function, is commonly used in mathematics to denote
+   * the summation of a set of values. In the context of Euclidean vectors, the summation function can
+   * be used to calculate the length or magnitude of a vector.
+   * The Euclidean [norm], also known as the L2 [norm], of a vector `x = [x1, x2, ..., xn]` is defined as the
+   * square root of the sum of the squares of its components.
+   * @param vector The array to be calculated.
+   * @returns The sum of the array.
+   * @see <a href="https://en.wikipedia.org/wiki/Summation">Summation</a>
+   */
+  fun sum(vector: FloatArray): Float {
+    var summation = 0f
+    for (v in vector) {
+      summation += v
+    }
+    return summation
+  }
+
+  /**
+   * The cross product is a binary operation on two vectors in three-dimensional space that
+   * results in a perpendicular vector to the input vectors. It's used in math, physics, engineering,
+   * and computer programming and should not be confused with the [dot] product,
+   * which is a scalar product that measures the projection of one vector onto another.
+   * @param vectorA The first array.
+   * @param vectorB The second array.
+   * @see <a href="https://en.wikipedia.org/wiki/Cross_product">Cross product</a>
+   */
+  fun cross(
+    vectorA: FloatArray,
+    vectorB: FloatArray,
+  ): FloatArray {
+    val outVector = FloatArray(3)
+    outVector[0] = vectorA[1] * vectorB[2] - vectorA[2] * vectorB[1]
+    outVector[1] = vectorA[2] * vectorB[0] - vectorA[0] * vectorB[2]
+    outVector[2] = vectorA[0] * vectorB[1] - vectorA[1] * vectorB[0]
+    return outVector
+  }
+
+  /**
+   * In mathematics, a norm is a function from a real or complex [vector] space
+   * to the non-negative real numbers that behaves in certain ways like the distance
+   * from the origin: it commutes with scaling, obeys a form of the triangle inequality,
+   * and is zero only at the origin.
+   * @param vector The vector to be calculated.
+   * @returns The norm of the vector.
+   * @see <a href="https://en.wikipedia.org/wiki/Norm_(mathematics)#Euclidean_norm">Euclidean Normalization</a>
+   */
+  fun norm(vector: FloatArray): Float {
+    var initFloat = 0f
+    for (v in vector) {
+      initFloat += v * v
+    }
+    return sqrt(initFloat)
+  }
+
+  /**
+   * In mathematics, the dot product or scalar product is an algebraic operation
+   * that takes two equal-length sequences of numbers (usually coordinate vectors),
+   * and returns a single number.
+   * In Euclidean geometry, the dot product of the Cartesian coordinates of two vectors is widely used.
+   * @param a The first sequence of numbers.
+   * @param b The second sequence of numbers. Must be the same length as the first sequence.
+   * @returns The dot product(single number) of the two sequences of numbers.
+   * @see <a href="https://en.wikipedia.org/wiki/Dot_product">Dot product</a>
+   */
+  fun dot(
+    a: FloatArray,
+    b: FloatArray,
+  ): Float = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+
+  /**
+   * The norm function is a utility function used here to calculate the Euclidean norm of the input vector.
+   * The calculated norm value is used to normalize the input [vector] by
+   * dividing each component of the input vector by the norm value.
+   * Therefore, while both functions use the same mathematical formula for Euclidean vector normalization,
+   * they serve different purposes.
+   * The [norm] function calculates the norm of a vector, while the [normalize] function returns a new normalized vector.
+   * @param vector The input array to be normalized.
+   * @return The new normalized vector.
+   * @see SensorFusionMath.norm
+   */
+  fun normalize(vector: FloatArray): FloatArray {
+    val normed = norm(vector)
+    if (normed == 0.0f) return vector.copyOf()
+    return FloatArray(vector.size) { i -> vector[i] / normed }
+  }
+}

package/ios/SOMotionDetecter.h

@@ -0,0 +1,44 @@
+//  SOMotionDetecter.h
+//  MotionDetection
+//
+// The MIT License (MIT)
+//
+// Created by : Artur Mkrtchyan
+// Copyright (c) 2014 SocialObjects Software. All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE
+
+#import <Foundation/Foundation.h>
+
+@interface SOMotionDetecter : NSObject
+
++ (instancetype)sharedInstance;
+
+/**
+ * Start accelerometer updates.
+ * @param callback Will be called every time when new step is detected
+ */
+- (void)startDetectionWithUpdateBlock:(void (^)(NSError *error))callback;
+
+/**
+ * Stop motion manager accelerometer updates
+ */
+- (void)stopDetection;
+
+@end

package/ios/SOMotionDetecter.m

@@ -0,0 +1,91 @@
+//  SOMotionDetecter.m
+//  MotionDetection
+//
+//  Created by Artur on 5/15/15.
+//  Copyright (c) 2015 Artur Mkrtchyan. All rights reserved.
+//
+
+#import "SOMotionDetecter.h"
+#import <CoreMotion/CoreMotion.h>
+#import <UIKit/UIKit.h>
+
+#define kUpdateInterval 0.2f
+@interface SOMotionDetecter ()
+
+@property(strong, nonatomic) CMMotionManager *motionManager;
+@property(strong, nonatomic) NSOperationQueue *queue;
+
+@end
+
+@implementation SOMotionDetecter
+
++ (instancetype)sharedInstance {
+  static id instance;
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    instance = [self new];
+  });
+
+  return instance;
+}
+
+- (instancetype)init {
+  self = [super init];
+
+  self.motionManager = [CMMotionManager new];
+  self.motionManager.accelerometerUpdateInterval = kUpdateInterval;
+  self.motionManager.deviceMotionUpdateInterval = kUpdateInterval;
+  self.motionManager.gyroUpdateInterval = kUpdateInterval;
+  self.motionManager.magnetometerUpdateInterval = kUpdateInterval;
+  self.motionManager.showsDeviceMovementDisplay = YES;
+  self.queue = [NSOperationQueue new];
+  self.queue.maxConcurrentOperationCount = 1;
+
+  return self;
+}
+
+- (void)startDetectionWithUpdateBlock:(void (^)(NSError *))callback {
+  if (self.motionManager.isAccelerometerActive) {
+    return;
+  }
+
+  [self.motionManager
+      startAccelerometerUpdatesToQueue:self.queue
+                           withHandler:^(CMAccelerometerData *accelerometerData,
+                                         NSError *error) {
+                             if (error) {
+                               if (callback) {
+                                 dispatch_async(dispatch_get_main_queue(), ^{
+                                   callback(error);
+                                 });
+                               }
+                               return;
+                             }
+
+                             CMAcceleration acceleration =
+                                 accelerometerData.acceleration;
+
+                             CGFloat strength = 1.2f;
+                             BOOL isStep = NO;
+                             if (fabs(acceleration.x) > strength ||
+                                 fabs(acceleration.y) > strength ||
+                                 fabs(acceleration.z) > strength) {
+                               isStep = YES;
+                             }
+                             if (isStep) {
+                               if (callback) {
+                                 dispatch_async(dispatch_get_main_queue(), ^{
+                                   callback(nil);
+                                 });
+                               }
+                             }
+                           }];
+}
+
+- (void)stopDetection {
+  if (self.motionManager.isAccelerometerActive) {
+    [self.motionManager stopAccelerometerUpdates];
+  }
+}
+
+@end

package/ios/StepCounter.h

@@ -0,0 +1,7 @@
+#import <StepCounterSpec/StepCounterSpec.h>
+#import <React/RCTEventEmitter.h>
+#import "SOMotionDetecter.h"
+
+@interface StepCounter : RCTEventEmitter <NativeStepCounterSpec>
+
+@end

package/ios/StepCounter.mm

@@ -0,0 +1,264 @@
+#import <CoreMotion/CoreMotion.h>
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcher.h>
+#import "StepCounter.h"
+#import "SOMotionDetecter.h"
+
+@interface StepCounter ()
+@property (nonatomic, readonly) CMPedometer *pedometer;
+@property (nonatomic, strong) dispatch_queue_t stateQueue;
+
+// Session control
+@property (nonatomic, strong) NSDate *sessionStartDate;
+
+// Baseline + monotonic
+@property (nonatomic) NSInteger baselineSteps;      // steps recorded at session start
+@property (nonatomic) NSInteger lastEmittedSteps;   // last emitted delta (monotonic)
+@property (nonatomic) BOOL baselineReady;
+@end
+
+@implementation StepCounter
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+@synthesize bridge = _bridge;
+@synthesize callableJSModules = _callableJSModules;
+
+RCT_EXPORT_MODULE();
+
+- (NSArray<NSString *> *)supportedEvents {
+  return @[
+    @"StepCounter.stepCounterUpdate",
+    @"StepCounter.stepDetected",
+    @"StepCounter.errorOccurred",
+    @"StepCounter.stepsSensorInfo"
+  ];
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// In New Architecture, RCTEventEmitter.receiveEvent is not a registered callable JS module.
+// In bridgeless mode (RCTHost), _bridge is nil; events must go through callableJSModules.
+// In bridge-based New Architecture, fall back to _bridge.enqueueJSCall via RCTDeviceEventEmitter.
+- (void)sendEventWithName:(NSString *)eventName body:(id)body {
+  NSArray *args = body ? @[eventName, body] : @[eventName];
+  if (_callableJSModules) {
+    [_callableJSModules invokeModule:@"RCTDeviceEventEmitter"
+                              method:@"emit"
+                            withArgs:args];
+  } else if (_bridge) {
+    [_bridge enqueueJSCall:@"RCTDeviceEventEmitter"
+                    method:@"emit"
+                      args:args
+                completion:nil];
+  }
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+#pragma mark - Public API
+
+RCT_EXPORT_METHOD(isStepCountingSupported:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  resolve(@{
+    @"granted": @([self authorizationStatus]),
+    @"supported": @([CMPedometer isStepCountingAvailable]),
+  });
+
+  [self sendEventWithName:@"StepCounter.stepsSensorInfo"
+                     body:[self dictionaryAboutSensorInfo]];
+}
+
+RCT_EXPORT_METHOD(queryStepCounterDataBetweenDates:(NSDate *)startDate
+                  endDate:(NSDate *)endDate
+                  handler:(RCTResponseSenderBlock)handler) {
+  [self.pedometer queryPedometerDataFromDate:startDate
+                                      toDate:endDate
+                                 withHandler:^(CMPedometerData *pedometerData, NSError *error) {
+    handler(@[
+      error.description ?: [NSNull null],
+      [self dictionaryFromPedometerData:pedometerData]
+    ]);
+  }];
+}
+
+RCT_EXPORT_METHOD(startStepCounterUpdate:(double)from) {
+  // Stop any in-progress pedometer session before starting a new one.
+  [self.pedometer stopPedometerUpdates];
+
+  // --- Timestamp guard (ms vs seconds) ---
+  // Valid Unix timestamp in seconds is ~1.7–2.0e9 (2024–2033),
+  // while milliseconds is ~1.7–2.0e12.
+  double fromSeconds = (from > 1e12) ? (from / 1000.0) : from;
+
+  // Extra sanity: if caller accidentally passes ms-but-small (unlikely) or future timestamps,
+  // clamp to "now" to avoid "future date" sessions.
+  NSDate *now = [NSDate date];
+  NSDate *requested = (fromSeconds > 0) ? [NSDate dateWithTimeIntervalSince1970:fromSeconds] : now;
+  if ([requested timeIntervalSinceDate:now] > 60.0) { // > 60s into the future
+    requested = now;
+  }
+  // Reset session state atomically before starting new handlers.
+  dispatch_sync(_stateQueue, ^{
+    self->_sessionStartDate = requested;
+    self->_baselineSteps = 0;
+    self->_lastEmittedSteps = 0;
+    self->_baselineReady = NO;
+  });
+
+  // 1) Establish baseline at session start (start -> now).
+  // This makes "reset/restart" deterministic: emitted steps are delta since sessionStartDate.
+  [self.pedometer queryPedometerDataFromDate:_sessionStartDate
+                                      toDate:now
+                                 withHandler:^(CMPedometerData *data, NSError *error) {
+    dispatch_sync(self->_stateQueue, ^{
+      self->_baselineSteps = error ? 0 : data.numberOfSteps.integerValue;
+      self->_baselineReady = YES;
+    });
+    if (error) {
+      [self sendEventWithName:@"StepCounter.errorOccurred" body:error];
+    }
+  }];
+
+  // 2) Live updates from sessionStartDate.
+  [self.pedometer startPedometerUpdatesFromDate:_sessionStartDate
+                                    withHandler:^(CMPedometerData *data, NSError *error) {
+    if (error) {
+      [self sendEventWithName:@"StepCounter.errorOccurred" body:error];
+      return;
+    }
+    if (!data) return;
+
+    __block NSDictionary *body = nil;
+    dispatch_sync(self->_stateQueue, ^{
+      if (!self->_baselineReady) return;
+
+      // Filter: accept only updates whose startDate matches the session start.
+      // iOS can interleave "segment/window" updates with different startDate values.
+      NSTimeInterval startDiff = fabs([data.startDate timeIntervalSinceDate:self->_sessionStartDate]);
+      if (startDiff > 1.0) return;
+
+      NSInteger cumulative = data.numberOfSteps.integerValue;
+      NSInteger delta = cumulative - self->_baselineSteps;
+
+      // If OS performs corrections or timestamps shift, delta can go negative.
+      // Clamp + rebase to keep future deltas sane.
+      if (delta < 0) {
+        delta = 0;
+        self->_baselineSteps = cumulative;
+      }
+
+      // Monotonic guard: never emit backwards.
+      if (delta <= self->_lastEmittedSteps) return;
+      self->_lastEmittedSteps = delta;
+
+      NSMutableDictionary *mBody = [[self dictionaryFromPedometerData:data] mutableCopy];
+      mBody[@"steps"] = @(delta);
+      mBody[@"counterType"] = @"CMPedometer";
+      body = [mBody copy];
+    });
+    if (body) {
+      [self sendEventWithName:@"StepCounter.stepCounterUpdate" body:body];
+    }
+  }];
+}
+
+RCT_EXPORT_METHOD(stopStepCounterUpdate) {
+  [self.pedometer stopPedometerUpdates];
+  [[SOMotionDetecter sharedInstance] stopDetection];
+
+  dispatch_sync(_stateQueue, ^{
+    self->_sessionStartDate = nil;
+    self->_baselineSteps = 0;
+    self->_lastEmittedSteps = 0;
+    self->_baselineReady = NO;
+  });
+}
+
+RCT_EXPORT_METHOD(startStepsDetection) {
+  [[SOMotionDetecter sharedInstance]
+   startDetectionWithUpdateBlock:^(NSError *error) {
+    if (error) {
+      [self sendEventWithName:@"StepCounter.errorOccurred" body:error];
+    } else {
+      [self sendEventWithName:@"StepCounter.stepDetected" body:@true];
+    }
+  }];
+}
+
+#pragma mark - Sensor info / mapping
+
+- (NSDictionary *)dictionaryAboutSensorInfo {
+  return @{
+    @"name": @"CMPedometer",
+    @"granted": @([self authorizationStatus]),
+    @"stepCounting": @([CMPedometer isStepCountingAvailable]),
+    @"pace": @([CMPedometer isPaceAvailable]),
+    @"cadence": @([CMPedometer isCadenceAvailable]),
+    @"distance": @([CMPedometer isDistanceAvailable]),
+    @"floorCounting": @([CMPedometer isFloorCountingAvailable]),
+  };
+}
+
+- (NSDictionary *)dictionaryFromPedometerData:(CMPedometerData *)data {
+  if (!data) {
+    return @{
+      @"counterType": @"CMPedometer",
+      @"startDate": [NSNull null],
+      @"endDate": [NSNull null],
+      @"steps": [NSNull null],
+      @"distance": [NSNull null],
+      @"floorsAscended": [NSNull null],
+      @"floorsDescended": [NSNull null],
+    };
+  }
+
+  NSNumber *startDate = @((long long)(data.startDate.timeIntervalSince1970 * 1000.0));
+  NSNumber *endDate = @((long long)(data.endDate.timeIntervalSince1970 * 1000.0));
+
+  return @{
+    @"counterType": @"CMPedometer",
+    @"startDate": startDate ?: [NSNull null],
+    @"endDate": endDate ?: [NSNull null],
+    @"steps": data.numberOfSteps ?: [NSNull null],
+    @"distance": data.distance ?: [NSNull null],
+    @"floorsAscended": data.floorsAscended ?: [NSNull null],
+    @"floorsDescended": data.floorsDescended ?: [NSNull null],
+  };
+}
+
+- (BOOL)authorizationStatus {
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 110000
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpartial-availability"
+  CMAuthorizationStatus status = [CMPedometer authorizationStatus];
+  return status == CMAuthorizationStatusAuthorized;
+#pragma clang diagnostic pop
+#else
+  return NO;
+#endif
+}
+
+#pragma mark - Init
+
+- (instancetype)init {
+  self = [super init];
+  if (!self) return nil;
+
+  _pedometer = [[CMPedometer alloc] init];
+  _stateQueue = dispatch_queue_create("com.bonnmh.rnstepcounter.state", DISPATCH_QUEUE_SERIAL);
+  _baselineSteps = 0;
+  _lastEmittedSteps = 0;
+  _baselineReady = NO;
+
+  return self;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+(const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeStepCounterSpecJSI>(params);
+}
+#endif // RCT_NEW_ARCH_ENABLED
+
+@end

package/lib/module/NativeStepCounter.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { TurboModuleRegistry } from "react-native";
+
+/**
+ * `StepCountData` is an object with four properties: `distance`, `steps`, `startDate`, and `endDate`.
+ * StepCountData object - The Object that contains the step count data.
+ * counterType - The type of counter used to count the steps.
+ * steps - The number of steps taken during the time period.
+ * startDate - The start date of the data.
+ * endDate - The end date of the data.
+ * distance - The distance in meters that the user has walked or run.
+ * floorsAscended - number of floors ascended (iOS only)
+ * floorsDescended - number of floors descended (iOS only)
+ */
+
+export const NAME = "StepCounter";
+export const VERSION = "0.3.1";
+export const eventName = "StepCounter.stepCounterUpdate";
+export default TurboModuleRegistry.getEnforcing("StepCounter");
+//# sourceMappingURL=NativeStepCounter.js.map

package/lib/module/NativeStepCounter.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","NAME","VERSION","eventName","getEnforcing"],"sourceRoot":"../../src","sources":["NativeStepCounter.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;;AAIpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAWA,OAAO,MAAMC,IAAI,GAAG,aAAa;AACjC,OAAO,MAAMC,OAAO,GAAG,OAAO;AAC9B,OAAO,MAAMC,SAAS,GAAG,+BAA+B;AAkCxD,eAAeH,mBAAmB,CAACI,YAAY,CAAO,aAAa,CAAC","ignoreList":[]}