@capgo/capacitor-pedometer 7.0.0

package/CapgoCapacitorPedometer.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapgoCapacitorPedometer'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.ios.deployment_target = '14.0'
+  s.dependency 'Capacitor'
+  s.swift_version = '5.1'
+end

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Capgo
+
+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.

package/Package.swift

@@ -0,0 +1,28 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "CapgoCapacitorPedometer",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "CapgoCapacitorPedometer",
+            targets: ["CapacitorPedometerPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "7.0.0")
+    ],
+    targets: [
+        .target(
+            name: "CapacitorPedometerPlugin",
+            dependencies: [
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/CapacitorPedometerPlugin"),
+        .testTarget(
+            name: "CapacitorPedometerPluginTests",
+            dependencies: ["CapacitorPedometerPlugin"],
+            path: "ios/Tests/CapacitorPedometerPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,297 @@
+# @capgo/capacitor-pedometer
+
+Capacitor plugin for accessing pedometer data including steps, distance, pace, cadence, and floors.
+
+## Install
+
+```bash
+npm install @capgo/capacitor-pedometer
+npx cap sync
+```
+
+## Configuration
+
+### iOS
+
+Add the following to your `Info.plist`:
+
+```xml
+<key>NSMotionUsageDescription</key>
+<string>We need access to your motion data to track steps and activity</string>
+```
+
+### Android
+
+The plugin will automatically add the `ACTIVITY_RECOGNITION` permission to your `AndroidManifest.xml`.
+
+For Android 10 (API 29) and above, you need to request the `ACTIVITY_RECOGNITION` permission at runtime.
+
+## API
+
+<docgen-index>
+
+* [`getMeasurement(...)`](#getmeasurement)
+* [`isAvailable()`](#isavailable)
+* [`startMeasurementUpdates()`](#startmeasurementupdates)
+* [`stopMeasurementUpdates()`](#stopmeasurementupdates)
+* [`checkPermissions()`](#checkpermissions)
+* [`requestPermissions()`](#requestpermissions)
+* [`addListener('measurement', ...)`](#addlistenermeasurement-)
+* [`removeAllListeners()`](#removealllisteners)
+* [Interfaces](#interfaces)
+* [Type Aliases](#type-aliases)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+### getMeasurement(...)
+
+```typescript
+getMeasurement(options?: GetMeasurementOptions | undefined) => Promise<Measurement>
+```
+
+Get pedometer measurements for a specified time range.
+
+| Param         | Type                                                                    |
+| ------------- | ----------------------------------------------------------------------- |
+| **`options`** | <code><a href="#getmeasurementoptions">GetMeasurementOptions</a></code> |
+
+**Returns:** <code>Promise&lt;<a href="#measurement">Measurement</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### isAvailable()
+
+```typescript
+isAvailable() => Promise<IsAvailableResult>
+```
+
+Check which pedometer features are available on this device.
+
+**Returns:** <code>Promise&lt;<a href="#isavailableresult">IsAvailableResult</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### startMeasurementUpdates()
+
+```typescript
+startMeasurementUpdates() => Promise<void>
+```
+
+Start receiving real-time pedometer measurement updates.
+
+On **Android** and **iOS**, the `measurement` event is only fired after calling `startMeasurementUpdates()`.
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### stopMeasurementUpdates()
+
+```typescript
+stopMeasurementUpdates() => Promise<void>
+```
+
+Stop receiving real-time pedometer measurement updates.
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### checkPermissions()
+
+```typescript
+checkPermissions() => Promise<PermissionStatus>
+```
+
+Check permission to access pedometer data.
+
+On **Android**, this checks the `ACTIVITY_RECOGNITION` permission.
+On **iOS**, this checks the motion usage permission.
+
+**Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### requestPermissions()
+
+```typescript
+requestPermissions() => Promise<PermissionStatus>
+```
+
+Request permission to access pedometer data.
+
+On **Android**, this requests the `ACTIVITY_RECOGNITION` permission.
+On **iOS**, this requests motion usage permission.
+
+**Returns:** <code>Promise&lt;<a href="#permissionstatus">PermissionStatus</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### addListener('measurement', ...)
+
+```typescript
+addListener(eventName: 'measurement', listenerFunc: (event: MeasurementEvent) => void) => Promise<PluginListenerHandle>
+```
+
+Called when a new pedometer measurement is received.
+
+| Param              | Type                                                                    |
+| ------------------ | ----------------------------------------------------------------------- |
+| **`eventName`**    | <code>'measurement'</code>                                              |
+| **`listenerFunc`** | <code>(event: <a href="#measurement">Measurement</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### removeAllListeners()
+
+```typescript
+removeAllListeners() => Promise<void>
+```
+
+Remove all listeners for this plugin.
+
+**Since:** 0.0.1
+
+--------------------
+
+
+### Interfaces
+
+
+#### Measurement
+
+| Prop                    | Type                | Description                                                                         | Since |
+| ----------------------- | ------------------- | ----------------------------------------------------------------------------------- | ----- |
+| **`numberOfSteps`**     | <code>number</code> | The number of steps taken by the user.                                              | 0.0.1 |
+| **`distance`**          | <code>number</code> | The estimated distance (in meters) traveled by the user. Only available on **iOS**. | 0.0.1 |
+| **`floorsAscended`**    | <code>number</code> | The approximate number of floors ascended. Only available on **iOS**.               | 0.0.1 |
+| **`floorsDescended`**   | <code>number</code> | The approximate number of floors descended. Only available on **iOS**.              | 0.0.1 |
+| **`currentPace`**       | <code>number</code> | The current pace (in seconds per meter). Only available on **iOS**.                 | 0.0.1 |
+| **`currentCadence`**    | <code>number</code> | The current cadence (steps per second). Only available on **iOS**.                  | 0.0.1 |
+| **`averageActivePace`** | <code>number</code> | The average active pace (in seconds per meter). Only available on **iOS**.          | 0.0.1 |
+| **`startDate`**         | <code>number</code> | The start time of this measurement (milliseconds since epoch).                      | 0.0.1 |
+| **`endDate`**           | <code>number</code> | The end time of this measurement (milliseconds since epoch).                        | 0.0.1 |
+
+
+#### GetMeasurementOptions
+
+| Prop        | Type                | Description                                                                               | Since |
+| ----------- | ------------------- | ----------------------------------------------------------------------------------------- | ----- |
+| **`start`** | <code>number</code> | The start time for the measurement query (milliseconds since epoch). Required on **iOS**. | 0.0.1 |
+| **`end`**   | <code>number</code> | The end time for the measurement query (milliseconds since epoch). Required on **iOS**.   | 0.0.1 |
+
+
+#### IsAvailableResult
+
+| Prop                | Type                 | Description                                                                                               | Since |
+| ------------------- | -------------------- | --------------------------------------------------------------------------------------------------------- | ----- |
+| **`stepCounting`**  | <code>boolean</code> | Whether step counting is available.                                                                       | 0.0.1 |
+| **`distance`**      | <code>boolean</code> | Whether distance measurement is available. Only `true` on **iOS** devices that support distance tracking. | 0.0.1 |
+| **`pace`**          | <code>boolean</code> | Whether pace measurement is available. Only `true` on **iOS** devices that support pace tracking.         | 0.0.1 |
+| **`cadence`**       | <code>boolean</code> | Whether cadence measurement is available. Only `true` on **iOS** devices that support cadence tracking.   | 0.0.1 |
+| **`floorCounting`** | <code>boolean</code> | Whether floor counting is available. Only `true` on **iOS** devices that support floor tracking.          | 0.0.1 |
+
+
+#### PermissionStatus
+
+| Prop                      | Type                                                                      | Description                                                                                                                                                | Since |
+| ------------------------- | ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ----- |
+| **`activityRecognition`** | <code>'prompt' \| 'prompt-with-rationale' \| 'granted' \| 'denied'</code> | Permission state for activity recognition. On **Android**, this is the `ACTIVITY_RECOGNITION` permission. On **iOS**, this is the motion usage permission. | 0.0.1 |
+
+
+#### PluginListenerHandle
+
+| Prop         | Type                                      |
+| ------------ | ----------------------------------------- |
+| **`remove`** | <code>() =&gt; Promise&lt;void&gt;</code> |
+
+
+### Type Aliases
+
+
+#### MeasurementEvent
+
+<code><a href="#measurement">Measurement</a></code>
+
+</docgen-api>
+
+## Usage
+
+```typescript
+import { CapacitorPedometer } from '@capgo/capacitor-pedometer';
+
+// Check availability
+const availability = await CapacitorPedometer.isAvailable();
+console.log('Features available:', availability);
+
+// Check and request permissions
+const permission = await CapacitorPedometer.checkPermissions();
+if (permission.activityRecognition !== 'granted') {
+  await CapacitorPedometer.requestPermissions();
+}
+
+// Start real-time updates
+await CapacitorPedometer.addListener('measurement', (data) => {
+  console.log('Steps:', data.numberOfSteps);
+  console.log('Distance:', data.distance);
+});
+
+await CapacitorPedometer.startMeasurementUpdates();
+
+// Query historical data (iOS only - requires start and end timestamps)
+const now = Date.now();
+const yesterday = now - (24 * 60 * 60 * 1000);
+const measurement = await CapacitorPedometer.getMeasurement({
+  start: yesterday,
+  end: now
+});
+
+// Stop updates
+await CapacitorPedometer.stopMeasurementUpdates();
+await CapacitorPedometer.removeAllListeners();
+```
+
+## Platform Support
+
+| Feature | Android | iOS |
+|---------|---------|-----|
+| Step Counting | ✅ | ✅ |
+| Distance | ❌ | ✅ |
+| Pace | ❌ | ✅ |
+| Cadence | ❌ | ✅ |
+| Floor Counting | ❌ | ✅ |
+| Historical Queries | ❌ | ✅ |
+
+## Notes
+
+- On **Android**, only step counting is available. The plugin uses the `TYPE_STEP_COUNTER` sensor.
+- On **iOS**, all features are available on supported devices using `CMPedometer`.
+- Historical data queries require explicit `start` and `end` timestamps on iOS.
+- Android's step counter gives cumulative steps since last device reboot; the plugin tracks the delta.
+- Measurements are paused when the app is in the background.
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,57 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.2.1'
+    androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.6.1'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace "app.capgo.pedometer"
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    testImplementation "junit:junit:$junitVersion"
+    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
+    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+</manifest>

package/android/src/main/java/app/capgo/pedometer/CapacitorPedometerPlugin.java

@@ -0,0 +1,246 @@
+package app.capgo.pedometer;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Build;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+
+@CapacitorPlugin(
+    name = "CapacitorPedometer",
+    permissions = { @Permission(strings = { Manifest.permission.ACTIVITY_RECOGNITION }, alias = "activityRecognition") }
+)
+public class CapacitorPedometerPlugin extends Plugin implements SensorEventListener {
+
+    private final String PLUGIN_VERSION = "7.0.0";
+    private static final String PERMISSION_GRANTED = "granted";
+    private static final String PERMISSION_DENIED = "denied";
+    private static final String PERMISSION_PROMPT = "prompt";
+    private static final String PERMISSION_PROMPT_WITH_RATIONALE = "prompt-with-rationale";
+
+    @Nullable
+    private SensorManager sensorManager;
+
+    @Nullable
+    private Sensor stepCounter;
+
+    private int initialStepCount = -1;
+    private int currentStepCount = 0;
+    private long measurementStartTime = 0;
+
+    private boolean updatesActive = false;
+
+    @Override
+    public void load() {
+        Context context = getContext();
+        sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+        if (sensorManager != null) {
+            stepCounter = sensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
+        }
+    }
+
+    @PluginMethod
+    public void getMeasurement(PluginCall call) {
+        if (stepCounter == null) {
+            call.reject("Step counter sensor not available on this device.");
+            return;
+        }
+
+        if (!hasActivityRecognitionPermission()) {
+            call.reject("Activity recognition permission not granted.");
+            return;
+        }
+
+        JSObject result = createMeasurementObject();
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void isAvailable(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("stepCounting", stepCounter != null);
+        // Android doesn't support these advanced features
+        result.put("distance", false);
+        result.put("pace", false);
+        result.put("cadence", false);
+        result.put("floorCounting", false);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void startMeasurementUpdates(PluginCall call) {
+        if (stepCounter == null) {
+            call.reject("Step counter sensor not available on this device.");
+            return;
+        }
+
+        if (!hasActivityRecognitionPermission()) {
+            call.reject("Activity recognition permission not granted.");
+            return;
+        }
+
+        if (updatesActive) {
+            call.resolve();
+            return;
+        }
+
+        measurementStartTime = System.currentTimeMillis();
+        initialStepCount = -1;
+
+        if (sensorManager != null && sensorManager.registerListener(this, stepCounter, SensorManager.SENSOR_DELAY_UI)) {
+            updatesActive = true;
+            call.resolve();
+        } else {
+            call.reject("Failed to register step counter listener.");
+        }
+    }
+
+    @PluginMethod
+    public void stopMeasurementUpdates(PluginCall call) {
+        if (sensorManager != null && updatesActive) {
+            sensorManager.unregisterListener(this);
+            updatesActive = false;
+            initialStepCount = -1;
+            currentStepCount = 0;
+        }
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void checkPermissions(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("activityRecognition", getPermissionState());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void requestPermissions(PluginCall call) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            if (getPermissionState(Manifest.permission.ACTIVITY_RECOGNITION) != PermissionState.GRANTED) {
+                requestPermissionForAlias("activityRecognition", call, "permissionCallback");
+            } else {
+                JSObject result = new JSObject();
+                result.put("activityRecognition", PERMISSION_GRANTED);
+                call.resolve(result);
+            }
+        } else {
+            // No permission needed on older Android versions
+            JSObject result = new JSObject();
+            result.put("activityRecognition", PERMISSION_GRANTED);
+            call.resolve(result);
+        }
+    }
+
+    @PermissionCallback
+    private void permissionCallback(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("activityRecognition", getPermissionState());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void removeAllListeners(PluginCall call) {
+        super.removeAllListeners(call);
+    }
+
+    @Override
+    public void handleOnPause() {
+        if (sensorManager != null && updatesActive) {
+            sensorManager.unregisterListener(this);
+        }
+        super.handleOnPause();
+    }
+
+    @Override
+    public void handleOnResume() {
+        super.handleOnResume();
+        if (updatesActive && sensorManager != null && stepCounter != null && hasActivityRecognitionPermission()) {
+            sensorManager.registerListener(this, stepCounter, SensorManager.SENSOR_DELAY_UI);
+        }
+    }
+
+    @Override
+    public void handleOnDestroy() {
+        if (sensorManager != null) {
+            sensorManager.unregisterListener(this);
+        }
+        super.handleOnDestroy();
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (event.sensor.getType() != Sensor.TYPE_STEP_COUNTER) {
+            return;
+        }
+
+        int totalSteps = (int) event.values[0];
+
+        if (initialStepCount == -1) {
+            initialStepCount = totalSteps;
+            currentStepCount = 0;
+        } else {
+            currentStepCount = totalSteps - initialStepCount;
+        }
+
+        JSObject payload = createMeasurementObject();
+        notifyListeners("measurement", payload);
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        // No-op
+    }
+
+    private JSObject createMeasurementObject() {
+        JSObject measurement = new JSObject();
+        measurement.put("numberOfSteps", currentStepCount);
+        measurement.put("startDate", measurementStartTime);
+        measurement.put("endDate", System.currentTimeMillis());
+        return measurement;
+    }
+
+    private boolean hasActivityRecognitionPermission() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            return getPermissionState(Manifest.permission.ACTIVITY_RECOGNITION) == PermissionState.GRANTED;
+        }
+        return true; // No permission needed on older Android versions
+    }
+
+    private String getPermissionState() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            PermissionState state = getPermissionState(Manifest.permission.ACTIVITY_RECOGNITION);
+            switch (state) {
+                case GRANTED:
+                    return PERMISSION_GRANTED;
+                case DENIED:
+                    return PERMISSION_DENIED;
+                default:
+                    return PERMISSION_PROMPT;
+            }
+        }
+        return PERMISSION_GRANTED; // No permission needed on older Android versions
+    }
+
+    @PluginMethod
+    public void getPluginVersion(final PluginCall call) {
+        try {
+            final JSObject ret = new JSObject();
+            ret.put("version", this.PLUGIN_VERSION);
+            call.resolve(ret);
+        } catch (final Exception e) {
+            call.reject("Could not get plugin version", e);
+        }
+    }
+}