@wayq/beekon-rn 0.0.1 → 0.0.3

package/BeekonRn.podspec

@@ -10,9 +10,9 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  # Match RN 0.85 default Podfile floor (15.1). Native BeekonKit's floor is
-  # 15.0 so this is satisfied. Bump only if RN raises its default.
-  s.platforms    = { :ios => "15.1" }
+  # BeekonKit targets iOS 17.0 (uses CLLocationUpdate.liveUpdates). The
+  # consuming app must also target iOS 17.0 or higher.
+  s.platforms    = { :ios => "17.0" }
   s.source       = { :git => "https://github.com/wayqteam/beekon.git", :tag => "v#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"

package/README.md

@@ -2,19 +2,17 @@
 
 React Native binding for the [Beekon](https://github.com/wayqteam/beekon) location SDK.
 
-A thin pass-through over the native Android (`io.github.wayqteam:beekon`) and iOS (`BeekonKit`) libraries. The public TypeScript surface mirrors the Kotlin / Swift / Dart APIs in shape: `init / configure / start / stop`, callback-backed `state` and `positions` streams, and a `history(from, to)` query.
+A thin pass-through over the native Android (`io.github.wayqteam:beekon`) and iOS (`BeekonKit`) libraries. The public TypeScript surface mirrors the Kotlin / Swift APIs in shape: `configure / start / stop`, callback-backed `state` and `locations` streams, and a `history(from, to)` query.
 
-Built on the React Native New Architecture (TurboModules + Codegen). The binding is a thin delegation layer — all logic, persistence, and OS integration lives natively. **Writes never cross into JavaScript**: in background the JS engine isn't guaranteed to be alive, so the native libraries own the persistence path end-to-end (same rule as the Flutter binding).
-
-See [`../docs/REQUIREMENTS.md`](../docs/REQUIREMENTS.md) for the full cross-platform spec.
+Built on the React Native New Architecture (TurboModules + Codegen). The binding is a thin delegation layer — all logic, persistence, and OS integration lives natively. **Writes never cross into JavaScript**: in background the JS engine isn't guaranteed to be alive, so the native libraries own the persistence path end-to-end.
 
 ## Requirements
 
 | Area | Floor |
 |---|---|
 | React Native | 0.76+ (target 0.85) |
-| iOS | 15.1 |
-| Android | API 24 |
+| iOS | 17.0 |
+| Android | API 26 |
 | New Architecture | required (Old Arch is unsupported) |
 
 ## Install
@@ -63,22 +61,18 @@ The library does NOT request permissions itself — your app must. Use a library
 ## Usage
 
 ```ts
-import { Beekon, type BeekonState, type Position } from '@wayq/beekon-rn';
+import { Beekon, type BeekonState, type Location } from '@wayq/beekon-rn';
 
-// Subscribe — returns an unsubscribe function.
+// Subscribe — returns an unsubscribe function. State replays the latest value
+// to new subscribers; locations is broadcast (no replay).
 const offState = Beekon.onState((s: BeekonState) => console.log('state', s));
-const offPos = Beekon.onPosition((p: Position) => console.log('pos', p));
-
-// Initialize once at startup.
-await Beekon.init();
+const offLoc = Beekon.onLocation((l: Location) => console.log('location', l));
 
-// Configure (Android requires `androidNotification`; iOS ignores it).
+// Configure. Defaults: 30 s / 100 m. Pass 0 to disable a gate.
 await Beekon.configure({
-  preset: 'balanced', // or 'saver' / 'precision'
+  intervalSeconds: 10,
+  distanceMeters: 30,
   androidNotification: {
-    channelId: 'beekon_tracking',
-    channelName: 'Beekon location tracking',
-    notificationId: 1001,
     title: 'Tracking',
     text: 'Recording your route',
     smallIconResName: 'ic_notification', // drawable in your app
@@ -89,33 +83,33 @@ await Beekon.start();
 // ... later
 await Beekon.stop();
 
-// Read past positions.
-const pts = await Beekon.history(new Date(Date.now() - 3600_000), new Date());
+// Read past fixes.
+const fixes = await Beekon.history(new Date(Date.now() - 3600_000), new Date());
 
 // Cleanup.
 offState();
-offPos();
+offLoc();
 ```
 
 ## API
 
 | Method | Description |
 |---|---|
-| `Beekon.init()` | One-time initialization. Idempotent. |
-| `Beekon.configure(config)` | Set sampling / Android notification config. |
-| `Beekon.start()` | Begin tracking. State → `starting` → `tracking`. |
-| `Beekon.stop()` | Stop tracking. Idempotent. State → `stopped`. |
-| `Beekon.shutdown()` | Final teardown. Most apps don't need this. |
-| `Beekon.history(from, to)` | Read persisted positions in range. |
+| `Beekon.configure(config)` | Set sampling thresholds. Optional. |
+| `Beekon.start()` | Begin tracking. State → `tracking`. |
+| `Beekon.stop()` | Stop tracking. Idempotent. State → `stopped` (`reason: 'user'`). |
+| `Beekon.history(from, to)` | Read persisted fixes in range. |
 | `Beekon.onState(cb)` | Subscribe to state. Returns unsubscribe fn. |
-| `Beekon.onPosition(cb)` | Subscribe to gated positions. Returns unsubscribe fn. |
+| `Beekon.onLocation(cb)` | Subscribe to gated fixes. Returns unsubscribe fn. |
+
+State is a discriminated union on `kind`: `'idle' | 'tracking' | 'stopped'`. The `'stopped'` variant carries a `reason: 'user' | 'permissionDenied' | 'locationServicesDisabled' | 'system'` (`'system'` is Android-only).
 
-Errors are thrown as `Error` instances with stable platform-agnostic codes:
-`NOT_INITIALISED`, `NOT_CONFIGURED`, `PERMISSION_DENIED`, `LOCATION_SERVICES_DISABLED` (iOS), `NO_GMS_AVAILABLE` (Android), `SERVICE_FAILED`, `INTERNAL_ERROR`.
+Errors are thrown as `BeekonError` instances with `kind`:
+`'permissionDenied'`, `'locationServicesDisabled'`, `'storageFailure'`.
 
 ## Storage and retention
 
-The native SDKs persist every gated position locally (Room on Android, GRDB on iOS) — JS is a passive reader. Retention: **TTL 7 days OR most recent 100 K rows**, whichever is smaller; auto-pruned on each write batch.
+The native SDKs persist every gated fix locally (Room on Android, GRDB on iOS) — JS is a passive reader. Retention: **TTL 7 days OR most recent 100 K rows**, whichever is smaller; auto-pruned on each write batch.
 
 ## License
 

package/android/build.gradle

@@ -1,6 +1,6 @@
 buildscript {
   ext.BeekonRn = [
-    kotlinVersion: "2.0.21",
+    kotlinVersion: "2.1.20",
     minSdkVersion: 24,
     compileSdkVersion: 36,
     targetSdkVersion: 36
@@ -33,7 +33,7 @@ apply plugin: "kotlin-android"
 apply plugin: "com.facebook.react"
 
 android {
-  namespace "com.wayq.beekonrn"
+  namespace "in.wayq.beekonrn"
 
   compileSdkVersion getExtOrDefault("compileSdkVersion")
 
@@ -72,7 +72,7 @@ dependencies {
   // Native Beekon SDK — published from beekon-android/ via Maven Central.
   // Pinned exact in v0.x to avoid surprise breakage; loosen to a range when
   // the SDK reaches v1 stability.
-  implementation "io.github.wayqteam:beekon:0.0.1"
+  implementation "io.github.wayqteam:beekon:0.0.3"
   // Kotlin coroutines — required for collecting Beekon's StateFlow/SharedFlow.
   // Beekon already depends on coroutines transitively, but declaring it here
   // makes the dependency intent explicit.

package/android/src/main/java/in/wayq/beekonrn/BeekonRnModule.kt

@@ -0,0 +1,182 @@
+package `in`.wayq.beekonrn
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import `in`.wayq.beekon.Beekon
+import `in`.wayq.beekon.BeekonConfig
+import `in`.wayq.beekon.BeekonError
+import `in`.wayq.beekon.BeekonState
+import `in`.wayq.beekon.Location
+import `in`.wayq.beekon.StopReason
+import java.time.Instant
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class BeekonRnModule(private val reactContext: ReactApplicationContext) :
+  NativeBeekonRnSpec(reactContext) {
+
+  // Default dispatcher (not Main.immediate) — Codegen's emitOnX is thread-safe
+  // and marshals to JS internally, so collecting on Main buys nothing and
+  // risks jank if any mapper does work. SupervisorJob so a single failure
+  // doesn't tear down siblings.
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+  private var stateJob: Job? = null
+  private var locationsJob: Job? = null
+
+  init {
+    // Beekon.initialize is idempotent and does not start tracking. Safe to call
+    // from module construction — the application context is already alive.
+    Beekon.initialize(reactContext.applicationContext)
+    stateJob = scope.launch {
+      Beekon.state.collect { s -> emitOnState(stateToWire(s)) }
+    }
+    locationsJob = scope.launch {
+      Beekon.locations.collect { loc -> emitOnLocation(locationToWire(loc)) }
+    }
+  }
+
+  override fun configure(config: ReadableMap, promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.configure(wireToConfig(config))
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "configure failed", t)
+      }
+    }
+  }
+
+  override fun start(promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.start()
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "start failed", t)
+      }
+    }
+  }
+
+  override fun stop(promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.stop()
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "stop failed", t)
+      }
+    }
+  }
+
+  override fun history(fromMs: Double, toMs: Double, promise: Promise) {
+    scope.launch {
+      try {
+        val from = Instant.ofEpochMilli(fromMs.toLong())
+        val to = Instant.ofEpochMilli(toMs.toLong())
+        val locations = Beekon.history(from, to)
+        val arr: WritableArray = Arguments.createArray()
+        for (loc in locations) arr.pushMap(locationToWire(loc))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "history failed", t)
+      }
+    }
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    scope.cancel()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mappers (Wire ↔ Kotlin types)
+  // ---------------------------------------------------------------------------
+
+  private fun wireToConfig(map: ReadableMap): BeekonConfig {
+    val intervalSeconds = map.getDouble("intervalSeconds").toLong()
+    val distanceMeters = map.getDouble("distanceMeters")
+    val notification = map.getMap("androidNotification")
+      ?.let { wireToNotification(it) }
+      ?: BeekonConfig.Notification()
+    return BeekonConfig(
+      intervalSeconds = intervalSeconds,
+      distanceMeters = distanceMeters,
+      notification = notification,
+    )
+  }
+
+  private fun wireToNotification(map: ReadableMap): BeekonConfig.Notification {
+    val title = if (map.hasKey("title") && !map.isNull("title")) map.getString("title") else null
+    val text = if (map.hasKey("text") && !map.isNull("text")) map.getString("text") else null
+    val resName =
+      if (map.hasKey("smallIconResName") && !map.isNull("smallIconResName"))
+        map.getString("smallIconResName")
+      else null
+    val smallIcon: Int? = resName?.let {
+      val pkg = reactContext.packageName
+      val id = reactContext.resources.getIdentifier(it, "drawable", pkg)
+      if (id == 0) {
+        throw IllegalArgumentException("drawable resource '$it' not found in package '$pkg'")
+      }
+      id
+    }
+    return BeekonConfig.Notification(title = title, text = text, smallIcon = smallIcon)
+  }
+
+  private fun locationToWire(loc: Location): WritableMap {
+    val m = Arguments.createMap()
+    m.putDouble("lat", loc.lat)
+    m.putDouble("lng", loc.lng)
+    m.putDouble("timestampMs", loc.timestamp.toEpochMilli().toDouble())
+    putNullableDouble(m, "accuracy", loc.accuracy)
+    putNullableDouble(m, "speed", loc.speed)
+    putNullableDouble(m, "bearing", loc.bearing)
+    putNullableDouble(m, "altitude", loc.altitude)
+    return m
+  }
+
+  private fun putNullableDouble(map: WritableMap, key: String, value: Double?) {
+    if (value == null) map.putNull(key) else map.putDouble(key, value)
+  }
+
+  private fun stateToWire(s: BeekonState): WritableMap {
+    val m = Arguments.createMap()
+    when (s) {
+      BeekonState.Idle -> m.putString("type", "idle")
+      BeekonState.Tracking -> m.putString("type", "tracking")
+      is BeekonState.Stopped -> {
+        m.putString("type", "stopped")
+        m.putString("stopReason", stopReasonToWire(s.reason))
+      }
+    }
+    return m
+  }
+
+  private fun stopReasonToWire(r: StopReason): String = when (r) {
+    StopReason.User -> "user"
+    StopReason.PermissionDenied -> "permissionDenied"
+    StopReason.LocationServicesDisabled -> "locationServicesDisabled"
+    StopReason.System -> "system"
+  }
+
+  // Maps native error sealed types to stable JS-side codes. Same code strings
+  // on iOS so JS can switch on them platform-agnostically.
+  private fun errorCode(t: Throwable): String = when (t) {
+    is BeekonError.PermissionDenied -> "PERMISSION_DENIED"
+    is BeekonError.LocationServicesDisabled -> "LOCATION_SERVICES_DISABLED"
+    is BeekonError.StorageFailure -> "STORAGE_FAILURE"
+    else -> "INTERNAL_ERROR"
+  }
+
+  companion object {
+    const val NAME = NativeBeekonRnSpec.NAME
+  }
+}

package/android/src/main/java/{com → in}/wayq/beekonrn/BeekonRnPackage.kt

@@ -1,4 +1,4 @@
-package com.wayq.beekonrn
+package `in`.wayq.beekonrn
 
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule

package/ios/BeekonRn.h

@@ -1,5 +1,9 @@
 #import <BeekonRnSpec/BeekonRnSpec.h>
 
-@interface BeekonRn : NSObject <NativeBeekonRnSpec>
+// Inherit from NativeBeekonRnSpecBase (codegen-provided) — it ships the
+// concrete `emitOnState:` / `emitOnLocation:` implementations that bridge
+// to JS via the EventEmitter callback. Conform to the protocol for the
+// method-side TurboModule contract.
+@interface BeekonRn : NativeBeekonRnSpecBase <NativeBeekonRnSpec>
 
 @end

package/ios/BeekonRn.mm

@@ -1,6 +1,8 @@
 #import "BeekonRn.h"
-// Auto-generated bridging header from the Swift impl in this same target.
-#import "BeekonRn-Swift.h"
+// Auto-generated bridging header from the Swift impl. With `use_frameworks!`
+// in the host Podfile (required for Swift pods), CocoaPods generates this
+// inside the BeekonRn framework, so the framework-style import is needed.
+#import <BeekonRn/BeekonRn-Swift.h>
 
 @implementation BeekonRn {
   BeekonRnImpl *_impl;
@@ -11,38 +13,31 @@
   if (self) {
     __weak __typeof(self) weakSelf = self;
     _impl = [[BeekonRnImpl alloc]
-             initWithOnState:^(NSDictionary *_Nonnull s) {
+             initOnState:^(NSDictionary *_Nonnull s) {
                [weakSelf emitOnState:s];
              }
-                  onPosition:^(NSDictionary *_Nonnull p) {
-                    [weakSelf emitOnPosition:p];
-                  }];
+              onLocation:^(NSDictionary *_Nonnull l) {
+                [weakSelf emitOnLocation:l];
+              }];
   }
   return self;
 }
 
-- (void)initialize:(RCTPromiseResolveBlock)resolve
-            reject:(RCTPromiseRejectBlock)reject {
-  [_impl initializeWithResolver:resolve rejecter:reject];
+- (void)invalidate {
+  [_impl invalidate];
+  [super invalidate];
 }
 
 - (void)configure:(JS::NativeBeekonRn::WireConfig &)config
           resolve:(RCTPromiseResolveBlock)resolve
            reject:(RCTPromiseRejectBlock)reject {
   // Codegen passes the struct; round-trip through NSDictionary so the Swift
-  // side can decode generically without an iOS-specific spec import.
-  // (`config.toDictionary()` may also be available depending on RN version.)
+  // side can decode generically without an iOS-specific spec import. iOS
+  // ignores `androidNotification` — passed through but unused.
   NSDictionary *dict = @{
-    @"preset": config.preset() ?: @"balanced",
-    @"distanceFilterMeters": config.distanceFilterMeters().has_value()
-        ? @(config.distanceFilterMeters().value())
-        : (id)[NSNull null],
-    @"intervalMillis": config.intervalMillis().has_value()
-        ? @(config.intervalMillis().value())
-        : (id)[NSNull null],
-    @"licenseKey": config.licenseKey() ?: (id)[NSNull null],
+    @"intervalSeconds": @(config.intervalSeconds()),
+    @"distanceMeters": @(config.distanceMeters()),
   };
-  // Note: iOS doesn't use androidNotification — passed but ignored.
   [_impl configure:dict resolver:resolve rejecter:reject];
 }
 
@@ -56,11 +51,6 @@
   [_impl stopWithResolver:resolve rejecter:reject];
 }
 
-- (void)shutdown:(RCTPromiseResolveBlock)resolve
-          reject:(RCTPromiseRejectBlock)reject {
-  [_impl shutdownWithResolver:resolve rejecter:reject];
-}
-
 - (void)history:(double)fromMs
            toMs:(double)toMs
         resolve:(RCTPromiseResolveBlock)resolve