sonarfit-react-native 1.0.0

package/README.md

@@ -0,0 +1,153 @@
+# sonarfit-react-native
+
+React Native integration for SonarFit SDK - AI-powered workout rep counting for iOS
+
+## Features
+
+- AI-powered rep counting for squats, deadlifts, and bench press
+- Real-time workout tracking
+- Support for Apple Watch and AirPods motion sensors
+- Native iOS integration with React Native bridge
+- TypeScript support
+
+## Installation
+
+```bash
+npm install sonarfit-react-native
+```
+
+### iOS Setup
+
+1. Install CocoaPods dependencies:
+```bash
+cd ios && pod install
+```
+
+2. The SonarFit SDK requires iOS 17.0 or higher. Make sure your `Podfile` has:
+```ruby
+platform :ios, '17.0'
+```
+
+## Usage
+
+### Initialize the SDK
+
+```typescript
+import SonarFitSDK from 'sonarfit-react-native';
+
+// Initialize with your API key when your app starts
+useEffect(() => {
+  const initSDK = async () => {
+    try {
+      await SonarFitSDK.initialize('your-api-key-here');
+      console.log('SonarFit SDK initialized');
+    } catch (error) {
+      console.error('Failed to initialize SonarFit SDK:', error);
+    }
+  };
+  
+  initSDK();
+}, []);
+```
+
+### Start a Workout
+
+```typescript
+import SonarFitSDK, { WorkoutConfig } from 'sonarfit-react-native';
+
+const startWorkout = async () => {
+  const config: WorkoutConfig = {
+    workoutType: 'squat',  // 'squat' | 'deadlift' | 'benchpress'
+    sets: 3,
+    reps: 10,
+    restTime: 60,          // seconds
+    countdownDuration: 3,  // seconds
+    autoReLift: true,
+    deviceType: 'none',    // 'none' | 'watch' | 'airpods'
+  };
+
+  try {
+    const result = await SonarFitSDK.presentWorkout(config);
+    
+    if (result.completed) {
+      console.log(`Completed ${result.totalRepsCompleted}/${result.totalTargetReps} reps`);
+      console.log(`Duration: ${result.totalDuration}s`);
+      console.log(`Sets:`, result.sets);
+    } else if (result.cancelled) {
+      console.log('Workout cancelled');
+    }
+  } catch (error) {
+    console.error('Workout error:', error);
+  }
+};
+```
+
+## API Reference
+
+### `SonarFitSDK.initialize(apiKey: string): Promise<void>`
+
+Initialize the SonarFit SDK with your API key.
+
+**Parameters:**
+- `apiKey`: Your SonarFit API key
+
+### `SonarFitSDK.presentWorkout(config: WorkoutConfig): Promise<WorkoutResult>`
+
+Present the SonarFit workout UI.
+
+**Parameters:**
+- `config`: Workout configuration
+
+**Returns:**
+- `Promise<WorkoutResult>`: Workout results when complete or cancelled
+
+### Types
+
+```typescript
+interface WorkoutConfig {
+  workoutType: 'squat' | 'deadlift' | 'benchpress';
+  sets: number;
+  reps: number;
+  restTime?: number;           // default: 60
+  countdownDuration?: number;  // default: 3
+  autoReLift?: boolean;        // default: true
+  deviceType?: 'none' | 'watch' | 'airpods';  // default: 'none'
+}
+
+interface WorkoutResult {
+  completed: boolean;
+  cancelled?: boolean;
+  workoutType?: string;
+  deviceType?: string;
+  startTime?: number;
+  endTime?: number;
+  totalDuration?: number;
+  completionPercentage?: number;
+  targetSets?: number;
+  targetRepsPerSet?: number;
+  totalRepsCompleted?: number;
+  totalTargetReps?: number;
+  sets?: Array<{
+    setNumber: number;
+    repsCompleted: number;
+  }>;
+}
+```
+
+## Requirements
+
+- React Native >= 0.60
+- iOS >= 17.0
+- Xcode >= 15.0
+
+## Example
+
+See the [example](./example) directory for a complete working example app.
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit [GitHub Issues](https://github.com/sonarfit/sonarfit-react-native/issues)

package/ios/SonarFitReactNative-Bridging-Header.h

@@ -0,0 +1,9 @@
+//
+//  SonarFitReactNative-Bridging-Header.h
+//  SonarFitReactNative
+//
+//  Bridging header for React Native integration
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTViewManager.h>

package/ios/SonarFitReactNative.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface SonarFitReactNative : NSObject <RCTBridgeModule>
+
+@end

package/ios/SonarFitReactNative.m

@@ -0,0 +1,14 @@
+#import "SonarFitReactNative.h"
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(SonarFitSDKModule, NSObject)
+
+RCT_EXTERN_METHOD(initialize:(NSString *)apiKey
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(presentWorkout:(NSDictionary *)config
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/SonarFitReactNative.swift

@@ -0,0 +1,148 @@
+import Foundation
+import React
+import SonarFitKit
+
+@objc(SonarFitSDKModule)
+class SonarFitSDKModule: NSObject {
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    @objc
+    func initialize(_ apiKey: String,
+                   resolver resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+
+        SonarFitSDK.initialize(apiKey: apiKey) { success, error in
+            if success {
+                resolve(true)
+            } else {
+                reject("E_INIT_FAILED", "Failed to initialize SonarFit SDK: \(error?.localizedDescription ?? "Unknown error")", error)
+            }
+        }
+    }
+
+    @objc
+    func presentWorkout(_ config: NSDictionary,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+
+        DispatchQueue.main.async {
+            guard let rootViewController = RCTKeyWindow()?.rootViewController else {
+                reject("E_NO_ROOT_VC", "Cannot find root view controller", nil)
+                return
+            }
+
+            // Parse workout configuration
+            guard let workoutConfig = self.parseWorkoutConfig(config) else {
+                reject("E_INVALID_CONFIG", "Invalid workout configuration", nil)
+                return
+            }
+
+            // Present SonarFit workout
+            SonarFit.startWorkout(
+                config: workoutConfig,
+                from: rootViewController,
+                onCompletion: { result in
+                    if let result = result {
+                        // Convert WorkoutResult to dictionary
+                        let resultDict: [String: Any] = [
+                            "completed": result.status == .completed,
+                            "workoutType": result.workoutType.rawValue,
+                            "deviceType": result.deviceType.rawValue,
+                            "startTime": result.startTime.timeIntervalSince1970,
+                            "endTime": result.endTime.timeIntervalSince1970,
+                            "totalDuration": result.totalDuration,
+                            "completionPercentage": result.completionPercentage,
+                            "targetSets": result.targetSets,
+                            "targetRepsPerSet": result.targetRepsPerSet,
+                            "totalRepsCompleted": result.totalRepsCompleted,
+                            "totalTargetReps": result.totalTargetReps,
+                            "sets": result.sets.map { set in
+                                return [
+                                    "setNumber": set.setNumber,
+                                    "repsCompleted": set.repsCompleted
+                                ]
+                            }
+                        ]
+                        resolve(resultDict)
+                    } else {
+                        // Workout cancelled
+                        resolve([
+                            "completed": false,
+                            "cancelled": true
+                        ])
+                    }
+                },
+                onPermissionError: { error in
+                    reject("E_PERMISSION", error.localizedDescription, error)
+                }
+            )
+        }
+    }
+
+    private func parseWorkoutConfig(_ config: NSDictionary) -> WorkoutConfig? {
+        guard let workoutTypeString = config["workoutType"] as? String else {
+            return nil
+        }
+
+        let workoutType: WorkoutType
+        switch workoutTypeString.lowercased() {
+        case "squat":
+            workoutType = .squat
+        case "deadlift":
+            workoutType = .deadlift
+        case "benchpress":
+            workoutType = .benchpress
+        default:
+            return nil
+        }
+
+        guard let sets = config["sets"] as? Int,
+              let reps = config["reps"] as? Int else {
+            return nil
+        }
+
+        let restTime = config["restTime"] as? Int ?? 60
+        let countdownDuration = config["countdownDuration"] as? Int ?? 3
+        let autoReLift = config["autoReLift"] as? Bool ?? true
+
+        let deviceType: DeviceType
+        if let deviceTypeString = config["deviceType"] as? String {
+            switch deviceTypeString.lowercased() {
+            case "watch":
+                deviceType = .watch
+            case "airpods":
+                deviceType = .airpods
+            default:
+                deviceType = .none
+            }
+        } else {
+            deviceType = .none
+        }
+
+        return WorkoutConfig(
+            workoutType: workoutType,
+            sets: sets,
+            reps: reps,
+            restTime: restTime,
+            countdownDuration: countdownDuration,
+            autoReLift: autoReLift,
+            deviceType: deviceType
+        )
+    }
+}
+
+// Helper to get key window
+func RCTKeyWindow() -> UIWindow? {
+    if #available(iOS 13.0, *) {
+        return UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.isKeyWindow }
+    } else {
+        return UIApplication.shared.keyWindow
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,93 @@
+export type WorkoutType = 'squat' | 'deadlift' | 'benchpress';
+export type DeviceType = 'none' | 'watch' | 'airpods';
+export interface WorkoutConfig {
+    /** Type of workout exercise */
+    workoutType: WorkoutType;
+    /** Number of sets to complete */
+    sets: number;
+    /** Target reps per set */
+    reps: number;
+    /** Rest time between sets in seconds (default: 60) */
+    restTime?: number;
+    /** Countdown before each set in seconds (default: 3) */
+    countdownDuration?: number;
+    /** Automatically start next set after countdown (default: true) */
+    autoReLift?: boolean;
+    /** Device type to use for motion tracking (default: 'none' for auto-detect) */
+    deviceType?: DeviceType;
+}
+export interface WorkoutSet {
+    /** Set number (1-indexed) */
+    setNumber: number;
+    /** Number of reps completed in this set */
+    repsCompleted: number;
+}
+export interface WorkoutResult {
+    /** Whether the workout was completed successfully */
+    completed: boolean;
+    /** Whether the workout was cancelled by user */
+    cancelled?: boolean;
+    /** Type of workout performed */
+    workoutType?: WorkoutType;
+    /** Device used for motion tracking */
+    deviceType?: DeviceType;
+    /** Workout start timestamp (Unix epoch) */
+    startTime?: number;
+    /** Workout end timestamp (Unix epoch) */
+    endTime?: number;
+    /** Total workout duration in seconds */
+    totalDuration?: number;
+    /** Percentage of target reps completed (0.0 to 1.0) */
+    completionPercentage?: number;
+    /** Target number of sets */
+    targetSets?: number;
+    /** Target reps per set */
+    targetRepsPerSet?: number;
+    /** Total reps completed across all sets */
+    totalRepsCompleted?: number;
+    /** Total target reps for the workout */
+    totalTargetReps?: number;
+    /** Array of completed sets with rep counts */
+    sets?: WorkoutSet[];
+}
+export declare class SonarFitSDK {
+    /**
+     * Initialize the SonarFit SDK with your API key
+     * @param apiKey Your SonarFit API key
+     * @returns Promise that resolves when initialization is complete
+     * @throws Error if native module is not available or initialization fails
+     *
+     * @example
+     * ```typescript
+     * await SonarFitSDK.initialize('your-api-key-here');
+     * ```
+     */
+    static initialize(apiKey: string): Promise<void>;
+    /**
+     * Present the SonarFit workout UI modally
+     * @param config Workout configuration
+     * @returns Promise that resolves with workout result when workout completes or is cancelled
+     * @throws Error if native module is not available or workout fails
+     *
+     * @example
+     * ```typescript
+     * const result = await SonarFitSDK.presentWorkout({
+     *   workoutType: 'squat',
+     *   sets: 3,
+     *   reps: 10,
+     *   restTime: 60
+     * });
+     *
+     * if (result.completed) {
+     *   console.log(`Completed ${result.totalRepsCompleted}/${result.totalTargetReps} reps`);
+     * }
+     * ```
+     */
+    static presentWorkout(config: WorkoutConfig): Promise<WorkoutResult>;
+    /**
+     * Check if SonarFit SDK is available on this platform
+     * @returns true if the native module is available, false otherwise
+     */
+    static isAvailable(): boolean;
+}
+export default SonarFitSDK;

package/lib/index.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonarFitSDK = void 0;
+const react_native_1 = require("react-native");
+const { SonarFitSDKModule } = react_native_1.NativeModules;
+class SonarFitSDK {
+    /**
+     * Initialize the SonarFit SDK with your API key
+     * @param apiKey Your SonarFit API key
+     * @returns Promise that resolves when initialization is complete
+     * @throws Error if native module is not available or initialization fails
+     *
+     * @example
+     * ```typescript
+     * await SonarFitSDK.initialize('your-api-key-here');
+     * ```
+     */
+    static async initialize(apiKey) {
+        if (!SonarFitSDKModule) {
+            throw new Error('SonarFitSDK native module not found. Make sure you have installed the native dependencies.');
+        }
+        try {
+            await SonarFitSDKModule.initialize(apiKey);
+        }
+        catch (error) {
+            throw new Error(`SonarFit initialization failed: ${(error === null || error === void 0 ? void 0 : error.message) || error}`);
+        }
+    }
+    /**
+     * Present the SonarFit workout UI modally
+     * @param config Workout configuration
+     * @returns Promise that resolves with workout result when workout completes or is cancelled
+     * @throws Error if native module is not available or workout fails
+     *
+     * @example
+     * ```typescript
+     * const result = await SonarFitSDK.presentWorkout({
+     *   workoutType: 'squat',
+     *   sets: 3,
+     *   reps: 10,
+     *   restTime: 60
+     * });
+     *
+     * if (result.completed) {
+     *   console.log(`Completed ${result.totalRepsCompleted}/${result.totalTargetReps} reps`);
+     * }
+     * ```
+     */
+    static async presentWorkout(config) {
+        if (!SonarFitSDKModule) {
+            throw new Error('SonarFitSDK native module not found. Make sure you have installed the native dependencies.');
+        }
+        try {
+            const result = await SonarFitSDKModule.presentWorkout(config);
+            return result;
+        }
+        catch (error) {
+            throw new Error(`SonarFit workout failed: ${(error === null || error === void 0 ? void 0 : error.message) || error}`);
+        }
+    }
+    /**
+     * Check if SonarFit SDK is available on this platform
+     * @returns true if the native module is available, false otherwise
+     */
+    static isAvailable() {
+        return SonarFitSDKModule != null;
+    }
+}
+exports.SonarFitSDK = SonarFitSDK;
+exports.default = SonarFitSDK;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "sonarfit-react-native",
+  "version": "1.0.0",
+  "description": "React Native integration for SonarFit SDK - AI-powered workout rep counting",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "react-native",
+    "fitness",
+    "workout",
+    "ai",
+    "motion-tracking",
+    "rep-counting",
+    "sonarfit"
+  ],
+  "author": "SonarFit",
+  "license": "MIT",
+  "homepage": "https://github.com/sonarfit/sonarfit-react-native",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sonarfit/sonarfit-react-native.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sonarfit/sonarfit-react-native/issues"
+  },
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.72.0",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "lib/",
+    "ios/",
+    "android/",
+    "sonarfit-react-native.podspec",
+    "README.md"
+  ],
+  "react-native": "lib/index.js"
+}

package/sonarfit-react-native.podspec

@@ -0,0 +1,24 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "sonarfit-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "17.0" }
+  s.source       = { :git => "https://github.com/sonarfit/sonarfit-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.requires_arc = true
+
+  s.dependency "React-Core"
+  s.dependency "SonarFitKit-Vendored"
+
+  # Swift version
+  s.swift_version = "5.9"
+end