react-native-polar-bridge 0.1.1

package/android/src/main/java/com/polarbridge/PolarBridgeModule.kt

@@ -0,0 +1,182 @@
+package com.polarbridge
+
+import android.util.Log
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.polar.sdk.api.PolarBleApi
+import com.polar.sdk.api.PolarBleApiCallback
+import com.polar.sdk.api.PolarBleApiDefaultImpl
+import com.polar.sdk.api.PolarH10OfflineExerciseApi
+import com.polar.sdk.api.errors.PolarInvalidArgument
+import com.polar.sdk.api.model.*
+import io.reactivex.rxjava3.disposables.Disposable
+import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+@ReactModule(name = PolarBridgeModule.NAME)
+class PolarBridgeModule(reactContext: ReactApplicationContext) :
+  NativePolarBridgeSpec(reactContext) {
+  private val reactContext: ReactApplicationContext = reactContext
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  // Example method
+  // See https://reactnative.dev/docs/native-modules-android
+  override fun multiply(a: Double, b: Double): Double {
+    return a * b
+  }
+
+  // ATTENTION! Replace with the device ID from your device.
+  private var deviceId = "B4291522"
+
+  private var hrDisposable: Disposable? = null
+  private var scanDisposable: Disposable? = null
+
+  private val api: PolarBleApi by lazy {
+    // Notice all features are enabled
+    PolarBleApiDefaultImpl.defaultImplementation(
+      reactApplicationContext.applicationContext,
+      setOf(
+        PolarBleApi.PolarBleSdkFeature.FEATURE_HR,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_SDK_MODE,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_BATTERY_INFO,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_H10_EXERCISE_RECORDING,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_OFFLINE_RECORDING,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_ONLINE_STREAMING,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_DEVICE_TIME_SETUP,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_DEVICE_INFO,
+        PolarBleApi.PolarBleSdkFeature.FEATURE_POLAR_LED_ANIMATION
+      )
+    )
+  }
+
+  override fun connectToDevice(deviceId: String) {
+    Log.e(TAG, "Connect device: $deviceId ")
+    try {
+      api.connectToDevice(deviceId)
+    } catch(polarInvalidArgument: PolarInvalidArgument){
+      Log.e(TAG, "Failed to connect to device. Reason $polarInvalidArgument ")
+    }
+  }
+
+  override fun disconnectFromDevice(deviceId: String) {
+    Log.e(TAG, "Disconnect device: $deviceId ")
+    try {
+      api.disconnectFromDevice(deviceId)
+    } catch(polarInvalidArgument: PolarInvalidArgument){
+      Log.e(TAG, "Failed to disconnect from device. Reason $polarInvalidArgument ")
+    }
+  }
+
+  override fun scanDevices() {
+    Log.e(TAG, "Scan Devices")
+    val isDisposed = scanDisposable?.isDisposed ?: true
+    if (isDisposed) {
+      scanDisposable = api.searchForDevice()
+        .observeOn(AndroidSchedulers.mainThread())
+        .subscribe(
+          { polarDeviceInfo: PolarDeviceInfo ->
+            Log.d(TAG, "polar device found id: " + polarDeviceInfo.deviceId + " address: " + polarDeviceInfo.address + " rssi: " + polarDeviceInfo.rssi + " name: " + polarDeviceInfo.name + " isConnectable: " + polarDeviceInfo.isConnectable)
+
+            val device = Arguments.createMap().apply {
+              putString("deviceId", polarDeviceInfo.deviceId)
+              putString("address", polarDeviceInfo.address)
+              putInt("rssi", polarDeviceInfo.rssi)
+              putString("name", polarDeviceInfo.name)
+              putBoolean("isConnectable", polarDeviceInfo.isConnectable)
+            }
+            sendEvent("onDeviceFound", device)
+          },
+          { error: Throwable ->
+            Log.e(TAG, "Device scan failed. Reason $error")
+            sendEvent("onScanError", Arguments.createMap().apply {
+              putString("message", error.message)
+            })
+          },
+          {
+            Log.d(TAG, "complete")
+          }
+        )
+    } else {
+      scanDisposable?.dispose()
+      Log.d(TAG, "Device scan stopped")
+    }
+  }
+
+  val isDisposed = hrDisposable?.isDisposed ?: true
+  override fun fetchHrData(deviceId: String) {
+    Log.e(TAG, "Fetch Heart Data called on: $deviceId ")
+    try{
+      if (isDisposed) {
+        hrDisposable = api.startHrStreaming(deviceId)
+          .observeOn(AndroidSchedulers.mainThread())
+          .subscribe(
+            { hrData: PolarHrData ->
+              Log.i(TAG, "PolarHrData ${hrData.samples.size}")
+              for (sample in hrData.samples) {
+                Log.d(TAG, "HR     bpm: ${sample.hr} " +
+                  "rrs: ${sample.rrsMs} " +
+                  "rrAvailable: ${sample.rrAvailable} " +
+                  "contactStatus: ${sample.contactStatus} " +
+                  "contactStatusSupported: ${sample.contactStatusSupported}")
+
+                val event: WritableMap = Arguments.createMap()
+                event.putInt("hr", sample.hr)
+
+                val rrsArray: WritableArray = Arguments.createArray()
+                sample.rrsMs.forEach { rrsValue ->
+                  rrsArray.pushInt(rrsValue)
+                }
+                event.putArray("rrsMs", rrsArray)
+                event.putBoolean("rrAvailable", sample.rrAvailable)
+                event.putBoolean("contactStatus", sample.contactStatus)
+                event.putBoolean("contactStatusSupported", sample.contactStatusSupported)
+
+                sendEvent("PolarHrData", event)
+              }
+            },
+            { error: Throwable ->
+              Log.e(TAG, "HR stream failed. Reason $error")
+
+              val errorEvent = Arguments.createMap()
+              errorEvent.putString("error", error.toString())
+              sendEvent("PolarHrError", errorEvent)
+            },
+            {
+              Log.d(TAG, "HR stream complete")
+
+              val completeEvent = Arguments.createMap()
+              completeEvent.putString("message", "HR stream complete")
+              sendEvent("PolarHrComplete", completeEvent)
+            }
+          )
+      } else {
+        // NOTE dispose will stop streaming if it is "running"
+        hrDisposable?.dispose()
+        Log.d(TAG, "HR stream stopped")
+      }
+    } catch(polarInvalidArgument: PolarInvalidArgument){
+      Log.e(TAG, "Failed to fetch HR Data. Reason $polarInvalidArgument ")
+    }
+  }
+
+  override fun disposeHrStream(){
+    hrDisposable?.dispose()
+  }
+
+  private fun sendEvent(eventName: String, params: WritableMap?) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, params)
+  }
+
+
+  companion object {
+    const val NAME = "PolarBridge"
+    private const val TAG = "PolarBridgeModule"
+    private const val API_LOGGER_TAG = "API LOGGER"
+    private const val PERMISSION_REQUEST_CODE = 1
+  }
+}

package/android/src/main/java/com/polarbridge/PolarBridgePackage.kt

@@ -0,0 +1,33 @@
+package com.polarbridge
+
+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
+import java.util.HashMap
+
+class PolarBridgePackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == PolarBridgeModule.NAME) {
+      PolarBridgeModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+    return ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[PolarBridgeModule.NAME] = ReactModuleInfo(
+        PolarBridgeModule.NAME,
+        PolarBridgeModule.NAME,
+        false,  // canOverrideExistingModule
+        false,  // needsEagerInit
+        false,  // isCxxModule
+        true // isTurboModule
+      )
+      moduleInfos
+    }
+  }
+}

package/ios/PolarBridge.h

@@ -0,0 +1,6 @@
+
+#import <PolarBridge/RNPolarBridgeSpec.h>
+
+@interface PolarBridge : NSObject <NativePolarBridgeSpec>
+
+@end

package/ios/PolarBridge.mm

@@ -0,0 +1,18 @@
+#import "PolarBridge.h"
+
+@implementation PolarBridge
+RCT_EXPORT_MODULE()
+
+- (NSNumber *)multiply:(double)a b:(double)b {
+    NSNumber *result = @(a * b);
+
+    return result;
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativePolarBridgeSpecJSI>(params);
+}
+
+@end

package/ios/generated/RNPolarBridgeSpec/RNPolarBridgeSpec-generated.mm

@@ -0,0 +1,74 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#import "RNPolarBridgeSpec.h"
+
+
+@implementation NativePolarBridgeSpecBase
+
+
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper
+{
+  _eventEmitterCallback = std::move(eventEmitterCallbackWrapper->_eventEmitterCallback);
+}
+@end
+
+
+namespace facebook::react {
+  
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_multiply(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, NumberKind, "multiply", @selector(multiply:b:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_connectToDevice(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "connectToDevice", @selector(connectToDevice:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_disconnectFromDevice(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "disconnectFromDevice", @selector(disconnectFromDevice:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_fetchHrData(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "fetchHrData", @selector(fetchHrData:), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_scanDevices(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "scanDevices", @selector(scanDevices), args, count);
+    }
+
+    static facebook::jsi::Value __hostFunction_NativePolarBridgeSpecJSI_disposeHrStream(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+      return static_cast<ObjCTurboModule&>(turboModule).invokeObjCMethod(rt, VoidKind, "disposeHrStream", @selector(disposeHrStream), args, count);
+    }
+
+  NativePolarBridgeSpecJSI::NativePolarBridgeSpecJSI(const ObjCTurboModule::InitParams &params)
+    : ObjCTurboModule(params) {
+      
+        methodMap_["multiply"] = MethodMetadata {2, __hostFunction_NativePolarBridgeSpecJSI_multiply};
+        
+        
+        methodMap_["connectToDevice"] = MethodMetadata {1, __hostFunction_NativePolarBridgeSpecJSI_connectToDevice};
+        
+        
+        methodMap_["disconnectFromDevice"] = MethodMetadata {1, __hostFunction_NativePolarBridgeSpecJSI_disconnectFromDevice};
+        
+        
+        methodMap_["fetchHrData"] = MethodMetadata {1, __hostFunction_NativePolarBridgeSpecJSI_fetchHrData};
+        
+        
+        methodMap_["scanDevices"] = MethodMetadata {0, __hostFunction_NativePolarBridgeSpecJSI_scanDevices};
+        
+        
+        methodMap_["disposeHrStream"] = MethodMetadata {0, __hostFunction_NativePolarBridgeSpecJSI_disposeHrStream};
+        
+  }
+} // namespace facebook::react

package/ios/generated/RNPolarBridgeSpec/RNPolarBridgeSpec.h

@@ -0,0 +1,68 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleObjCpp
+ *
+ * We create an umbrella header (and corresponding implementation) here since
+ * Cxx compilation in BUCK has a limitation: source-code producing genrule()s
+ * must have a single output. More files => more genrule()s => slower builds.
+ */
+
+#ifndef __cplusplus
+#error This file must be compiled as Obj-C++. If you are importing it, you must change your file extension to .mm.
+#endif
+
+// Avoid multiple includes of RNPolarBridgeSpec symbols
+#ifndef RNPolarBridgeSpec_H
+#define RNPolarBridgeSpec_H
+
+#import <Foundation/Foundation.h>
+#import <RCTRequired/RCTRequired.h>
+#import <RCTTypeSafety/RCTConvertHelpers.h>
+#import <RCTTypeSafety/RCTTypedModuleConstants.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTCxxConvert.h>
+#import <React/RCTManagedPointer.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <optional>
+#import <vector>
+
+
+NS_ASSUME_NONNULL_BEGIN
+
+@protocol NativePolarBridgeSpec <RCTBridgeModule, RCTTurboModule>
+
+- (NSNumber *)multiply:(double)a
+                     b:(double)b;
+- (void)connectToDevice:(NSString *)deviceId;
+- (void)disconnectFromDevice:(NSString *)deviceId;
+- (void)fetchHrData:(NSString *)deviceId;
+- (void)scanDevices;
+- (void)disposeHrStream;
+
+@end
+
+@interface NativePolarBridgeSpecBase : NSObject {
+@protected
+facebook::react::EventEmitterCallback _eventEmitterCallback;
+}
+- (void)setEventEmitterCallback:(EventEmitterCallbackWrapper *)eventEmitterCallbackWrapper;
+
+
+@end
+
+namespace facebook::react {
+  /**
+   * ObjC++ class for module 'NativePolarBridge'
+   */
+  class JSI_EXPORT NativePolarBridgeSpecJSI : public ObjCTurboModule {
+  public:
+    NativePolarBridgeSpecJSI(const ObjCTurboModule::InitParams &params);
+  };
+} // namespace facebook::react
+
+NS_ASSUME_NONNULL_END
+#endif // RNPolarBridgeSpec_H

package/ios/generated/RNPolarBridgeSpecJSI-generated.cpp

@@ -0,0 +1,66 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleCpp.js
+ */
+
+#include "RNPolarBridgeSpecJSI.h"
+
+namespace facebook::react {
+
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_multiply(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  return static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->multiply(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber(),
+    count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asNumber()
+  );
+}
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_connectToDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->connectToDevice(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_disconnectFromDevice(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->disconnectFromDevice(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_fetchHrData(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->fetchHrData(
+    rt,
+    count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asString(rt)
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_scanDevices(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->scanDevices(
+    rt
+  );
+  return jsi::Value::undefined();
+}
+static jsi::Value __hostFunction_NativePolarBridgeCxxSpecJSI_disposeHrStream(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+  static_cast<NativePolarBridgeCxxSpecJSI *>(&turboModule)->disposeHrStream(
+    rt
+  );
+  return jsi::Value::undefined();
+}
+
+NativePolarBridgeCxxSpecJSI::NativePolarBridgeCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker)
+  : TurboModule("PolarBridge", jsInvoker) {
+  methodMap_["multiply"] = MethodMetadata {2, __hostFunction_NativePolarBridgeCxxSpecJSI_multiply};
+  methodMap_["connectToDevice"] = MethodMetadata {1, __hostFunction_NativePolarBridgeCxxSpecJSI_connectToDevice};
+  methodMap_["disconnectFromDevice"] = MethodMetadata {1, __hostFunction_NativePolarBridgeCxxSpecJSI_disconnectFromDevice};
+  methodMap_["fetchHrData"] = MethodMetadata {1, __hostFunction_NativePolarBridgeCxxSpecJSI_fetchHrData};
+  methodMap_["scanDevices"] = MethodMetadata {0, __hostFunction_NativePolarBridgeCxxSpecJSI_scanDevices};
+  methodMap_["disposeHrStream"] = MethodMetadata {0, __hostFunction_NativePolarBridgeCxxSpecJSI_disposeHrStream};
+}
+
+
+} // namespace facebook::react

package/ios/generated/RNPolarBridgeSpecJSI.h

@@ -0,0 +1,116 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+  class JSI_EXPORT NativePolarBridgeCxxSpecJSI : public TurboModule {
+protected:
+  NativePolarBridgeCxxSpecJSI(std::shared_ptr<CallInvoker> jsInvoker);
+
+public:
+  virtual double multiply(jsi::Runtime &rt, double a, double b) = 0;
+  virtual void connectToDevice(jsi::Runtime &rt, jsi::String deviceId) = 0;
+  virtual void disconnectFromDevice(jsi::Runtime &rt, jsi::String deviceId) = 0;
+  virtual void fetchHrData(jsi::Runtime &rt, jsi::String deviceId) = 0;
+  virtual void scanDevices(jsi::Runtime &rt) = 0;
+  virtual void disposeHrStream(jsi::Runtime &rt) = 0;
+
+};
+
+template <typename T>
+class JSI_EXPORT NativePolarBridgeCxxSpec : public TurboModule {
+public:
+  jsi::Value create(jsi::Runtime &rt, const jsi::PropNameID &propName) override {
+    return delegate_.create(rt, propName);
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime& runtime) override {
+    return delegate_.getPropertyNames(runtime);
+  }
+
+  static constexpr std::string_view kModuleName = "PolarBridge";
+
+protected:
+  NativePolarBridgeCxxSpec(std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule(std::string{NativePolarBridgeCxxSpec::kModuleName}, jsInvoker),
+      delegate_(reinterpret_cast<T*>(this), jsInvoker) {}
+
+
+private:
+  class Delegate : public NativePolarBridgeCxxSpecJSI {
+  public:
+    Delegate(T *instance, std::shared_ptr<CallInvoker> jsInvoker) :
+      NativePolarBridgeCxxSpecJSI(std::move(jsInvoker)), instance_(instance) {
+
+    }
+
+    double multiply(jsi::Runtime &rt, double a, double b) override {
+      static_assert(
+          bridging::getParameterCount(&T::multiply) == 3,
+          "Expected multiply(...) to have 3 parameters");
+
+      return bridging::callFromJs<double>(
+          rt, &T::multiply, jsInvoker_, instance_, std::move(a), std::move(b));
+    }
+    void connectToDevice(jsi::Runtime &rt, jsi::String deviceId) override {
+      static_assert(
+          bridging::getParameterCount(&T::connectToDevice) == 2,
+          "Expected connectToDevice(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::connectToDevice, jsInvoker_, instance_, std::move(deviceId));
+    }
+    void disconnectFromDevice(jsi::Runtime &rt, jsi::String deviceId) override {
+      static_assert(
+          bridging::getParameterCount(&T::disconnectFromDevice) == 2,
+          "Expected disconnectFromDevice(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::disconnectFromDevice, jsInvoker_, instance_, std::move(deviceId));
+    }
+    void fetchHrData(jsi::Runtime &rt, jsi::String deviceId) override {
+      static_assert(
+          bridging::getParameterCount(&T::fetchHrData) == 2,
+          "Expected fetchHrData(...) to have 2 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::fetchHrData, jsInvoker_, instance_, std::move(deviceId));
+    }
+    void scanDevices(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::scanDevices) == 1,
+          "Expected scanDevices(...) to have 1 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::scanDevices, jsInvoker_, instance_);
+    }
+    void disposeHrStream(jsi::Runtime &rt) override {
+      static_assert(
+          bridging::getParameterCount(&T::disposeHrStream) == 1,
+          "Expected disposeHrStream(...) to have 1 parameters");
+
+      return bridging::callFromJs<void>(
+          rt, &T::disposeHrStream, jsInvoker_, instance_);
+    }
+
+  private:
+    friend class NativePolarBridgeCxxSpec;
+    T *instance_;
+  };
+
+  Delegate delegate_;
+};
+
+} // namespace facebook::react

package/lib/module/NativePolarBridge.ts

@@ -0,0 +1,13 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  multiply(a: number, b: number): number;
+  connectToDevice(deviceId: string): void;
+  disconnectFromDevice(deviceId: string): void;
+  fetchHrData(deviceId: string): void;
+  scanDevices(): void;
+  disposeHrStream(): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('PolarBridge');

package/lib/module/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import PolarBridge from './NativePolarBridge';
+export function multiply(a, b) {
+  return PolarBridge.multiply(a, b);
+}
+export function connectToDevice(deviceId) {
+  return PolarBridge.connectToDevice(deviceId);
+}
+export function disconnectFromDevice(deviceId) {
+  return PolarBridge.disconnectFromDevice(deviceId);
+}
+export function scanDevices() {
+  return PolarBridge.scanDevices();
+}
+export function fetchHrData(deviceId) {
+  return PolarBridge.fetchHrData(deviceId);
+}
+export function disposeHrStream() {
+  return PolarBridge.disposeHrStream();
+}
+export const emittedEventId = Object.freeze({
+  SCAN_DEVICE_FOUND: 'onDeviceFound',
+  SCAN_DEVICE_ERROR: 'onScanError',
+  SCAN_DEVICE_COMPLETE: 'onScanComplete',
+  POLAR_HR_DATA: 'PolarHrData',
+  POLAR_HR_ERROR: 'PolarHrError',
+  POLAR_HR_COMPLETE: 'PolarHrComplete'
+});
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PolarBridge","multiply","a","b","connectToDevice","deviceId","disconnectFromDevice","scanDevices","fetchHrData","disposeHrStream","emittedEventId","Object","freeze","SCAN_DEVICE_FOUND","SCAN_DEVICE_ERROR","SCAN_DEVICE_COMPLETE","POLAR_HR_DATA","POLAR_HR_ERROR","POLAR_HR_COMPLETE"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,OAAOA,WAAW,MAAM,qBAAqB;AAE7C,OAAO,SAASC,QAAQA,CAACC,CAAS,EAAEC,CAAS,EAAU;EACrD,OAAOH,WAAW,CAACC,QAAQ,CAACC,CAAC,EAAEC,CAAC,CAAC;AACnC;AAEA,OAAO,SAASC,eAAeA,CAACC,QAAgB,EAAE;EAChD,OAAOL,WAAW,CAACI,eAAe,CAACC,QAAQ,CAAC;AAC9C;AAEA,OAAO,SAASC,oBAAoBA,CAACD,QAAgB,EAAE;EACrD,OAAOL,WAAW,CAACM,oBAAoB,CAACD,QAAQ,CAAC;AACnD;AAEA,OAAO,SAASE,WAAWA,CAAA,EAAE;EAC3B,OAAOP,WAAW,CAACO,WAAW,CAAC,CAAC;AAClC;AAEA,OAAO,SAASC,WAAWA,CAACH,QAAgB,EAAE;EAC5C,OAAOL,WAAW,CAACQ,WAAW,CAACH,QAAQ,CAAC;AAC1C;AAEA,OAAO,SAASI,eAAeA,CAAA,EAAE;EAC/B,OAAOT,WAAW,CAACS,eAAe,CAAC,CAAC;AACtC;AAEA,OAAO,MAAMC,cAAc,GAAGC,MAAM,CAACC,MAAM,CAAC;EAC1CC,iBAAiB,EAAE,eAAe;EAClCC,iBAAiB,EAAE,aAAa;EAChCC,oBAAoB,EAAE,gBAAgB;EACtCC,aAAa,EAAE,aAAa;EAC5BC,cAAc,EAAE,cAAc;EAC9BC,iBAAiB,EAAE;AACrB,CAAC,CAAC","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/babel.config.d.ts

@@ -0,0 +1,2 @@
+export let presets: string[];
+//# sourceMappingURL=babel.config.d.ts.map

package/lib/typescript/babel.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel.config.d.ts","sourceRoot":"","sources":["../../babel.config.js"],"names":[],"mappings":""}

package/lib/typescript/eslint.config.d.mts

@@ -0,0 +1,3 @@
+declare const _default: import("eslint").Linter.Config<import("eslint").Linter.RulesRecord>[];
+export default _default;
+//# sourceMappingURL=eslint.config.d.mts.map

package/lib/typescript/eslint.config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eslint.config.d.mts","sourceRoot":"","sources":["../../eslint.config.mjs"],"names":[],"mappings":""}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/react-native.config.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: import("@react-native-community/cli-types").UserDependencyConfig;
+export = _exports;
+//# sourceMappingURL=react-native.config.d.ts.map

package/lib/typescript/react-native.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-native.config.d.ts","sourceRoot":"","sources":["../../react-native.config.js"],"names":[],"mappings":"wBACU,OAAO,mCAAmC,EAAE,oBAAoB"}

package/lib/typescript/src/NativePolarBridge.d.ts

@@ -0,0 +1,12 @@
+import type { TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    multiply(a: number, b: number): number;
+    connectToDevice(deviceId: string): void;
+    disconnectFromDevice(deviceId: string): void;
+    fetchHrData(deviceId: string): void;
+    scanDevices(): void;
+    disposeHrStream(): void;
+}
+declare const _default: Spec;
+export default _default;
+//# sourceMappingURL=NativePolarBridge.d.ts.map

package/lib/typescript/src/NativePolarBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativePolarBridge.d.ts","sourceRoot":"","sources":["../../../src/NativePolarBridge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGhD,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,WAAW,IAAI,IAAI,CAAC;IACpB,eAAe,IAAI,IAAI,CAAC;CACzB;;AAED,wBAAqE"}