@wayq/beekon-rn 0.0.1 → 0.0.5

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

@@ -0,0 +1,428 @@
+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.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import `in`.wayq.beekon.AccuracyMode
+import `in`.wayq.beekon.ActivityType
+import `in`.wayq.beekon.Beekon
+import `in`.wayq.beekon.BeekonConfig
+import `in`.wayq.beekon.BeekonException
+import `in`.wayq.beekon.BeekonGeofence
+import `in`.wayq.beekon.BeekonState
+import `in`.wayq.beekon.GeofenceEvent
+import `in`.wayq.beekon.Location
+import `in`.wayq.beekon.LocationQuality
+import `in`.wayq.beekon.LocationTrigger
+import `in`.wayq.beekon.MotionState
+import `in`.wayq.beekon.NotificationConfig
+import `in`.wayq.beekon.StationaryMode
+import `in`.wayq.beekon.StopReason
+import `in`.wayq.beekon.SyncConfig
+import `in`.wayq.beekon.SyncFailure
+import `in`.wayq.beekon.SyncStatus
+import `in`.wayq.beekon.Transition
+import java.time.Instant
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+class BeekonRnModule(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 a mapper does work. SupervisorJob so one failing collector doesn't
+  // tear down its siblings.
+  private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+  init {
+    // No Beekon.initialize() — the SDK auto-initializes via AndroidX Startup.
+    scope.launch { Beekon.state.collect { emitOnState(stateToWire(it)) } }
+    scope.launch { Beekon.locations.collect { emitOnLocation(locationToWire(it)) } }
+    scope.launch {
+      Beekon.geofenceEvents.collect { emitOnGeofenceEvent(geofenceEventToWire(it)) }
+    }
+    scope.launch { Beekon.syncStatus.collect { emitOnSyncStatus(syncStatusToWire(it)) } }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Lifecycle (non-suspend native calls resolve directly)
+  // ---------------------------------------------------------------------------
+
+  override fun configure(config: ReadableMap, promise: Promise) {
+    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)
+      }
+    }
+  }
+
+  // Android has no native resumeIfNeeded — Beekon.start() rehydrates the
+  // persisted intent (mirrors the Flutter plugin).
+  override fun resumeIfNeeded(promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.start()
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "resumeIfNeeded failed", t)
+      }
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // History
+  // ---------------------------------------------------------------------------
+
+  override fun getLocations(fromMs: Double, toMs: Double, promise: Promise) {
+    scope.launch {
+      try {
+        val from = Instant.ofEpochMilli(fromMs.toLong())
+        val to = Instant.ofEpochMilli(toMs.toLong())
+        val arr: WritableArray = Arguments.createArray()
+        for (loc in Beekon.getLocations(from, to)) arr.pushMap(locationToWire(loc))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "getLocations failed", t)
+      }
+    }
+  }
+
+  override fun deleteLocations(beforeMs: Double, promise: Promise) {
+    scope.launch {
+      try {
+        // Negative is the wire sentinel for "delete all" (no cutoff).
+        val before = if (beforeMs < 0) null else Instant.ofEpochMilli(beforeMs.toLong())
+        promise.resolve(Beekon.deleteLocations(before))
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "deleteLocations failed", t)
+      }
+    }
+  }
+
+  override fun pendingUploadCount(promise: Promise) {
+    scope.launch {
+      try {
+        promise.resolve(Beekon.pendingUploadCount())
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "pendingUploadCount failed", t)
+      }
+    }
+  }
+
+  // ---------------------------------------------------------------------------
+  // Sync
+  // ---------------------------------------------------------------------------
+
+  override fun sync(promise: Promise) {
+    Beekon.sync()
+    promise.resolve(null)
+  }
+
+  override fun setExtras(entries: ReadableArray, promise: Promise) {
+    Beekon.setExtras(entriesToMap(entries))
+    promise.resolve(null)
+  }
+
+  // ---------------------------------------------------------------------------
+  // Geofences
+  // ---------------------------------------------------------------------------
+
+  override fun addGeofences(geofences: ReadableArray, promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.addGeofences(wireToGeofences(geofences))
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "addGeofences failed", t)
+      }
+    }
+  }
+
+  override fun removeGeofences(ids: ReadableArray, promise: Promise) {
+    scope.launch {
+      try {
+        val list = (0 until ids.size()).mapNotNull { ids.getString(it) }
+        Beekon.removeGeofences(list)
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "removeGeofences failed", t)
+      }
+    }
+  }
+
+  override fun listGeofences(promise: Promise) {
+    scope.launch {
+      try {
+        val arr: WritableArray = Arguments.createArray()
+        for (g in Beekon.listGeofences()) arr.pushMap(geofenceToWire(g))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "listGeofences failed", t)
+      }
+    }
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    scope.cancel()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mappers: wire (ReadableMap/Array) → Kotlin
+  // ---------------------------------------------------------------------------
+
+  private fun wireToConfig(map: ReadableMap): BeekonConfig {
+    val sync =
+      if (map.hasKey("sync") && !map.isNull("sync")) {
+        map.getMap("sync")?.let { wireToSyncConfig(it) }
+      } else {
+        null
+      }
+    val notification =
+      if (map.hasKey("notification") && !map.isNull("notification")) {
+        map.getMap("notification")?.let { wireToNotification(it) }
+      } else {
+        null
+      }
+    return BeekonConfig(
+      minTimeBetweenLocationsSeconds =
+        map.getDouble("minTimeBetweenLocationsSeconds").toLong(),
+      minDistanceBetweenLocationsMeters =
+        map.getDouble("minDistanceBetweenLocationsMeters"),
+      accuracyMode = toAccuracyMode(map.getString("accuracyMode")),
+      whenStationary = toStationaryMode(map.getString("whenStationary")),
+      stationaryRadiusMeters = map.getDouble("stationaryRadiusMeters"),
+      detectActivity = map.getBoolean("detectActivity"),
+      sync = sync,
+      notification = notification ?: NotificationConfig(),
+    )
+  }
+
+  private fun wireToSyncConfig(map: ReadableMap): SyncConfig =
+    SyncConfig(
+      url = map.getString("url") ?: "",
+      headers = entriesToMap(map.getArray("headers")),
+      intervalSeconds = map.getDouble("intervalSeconds").toLong(),
+      batchSize = map.getDouble("batchSize").toInt(),
+    )
+
+  private fun wireToNotification(map: ReadableMap): NotificationConfig {
+    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
+    // Use the data-class default for `title` when the wire value is absent.
+    return if (title != null) {
+      NotificationConfig(title = title, text = text)
+    } else {
+      NotificationConfig(text = text)
+    }
+  }
+
+  private fun wireToGeofences(arr: ReadableArray): List<BeekonGeofence> {
+    val out = ArrayList<BeekonGeofence>(arr.size())
+    for (i in 0 until arr.size()) {
+      val m = arr.getMap(i) ?: continue
+      out += BeekonGeofence(
+        id = m.getString("id") ?: "",
+        latitude = m.getDouble("lat"),
+        longitude = m.getDouble("lng"),
+        radiusMeters = m.getDouble("radiusMeters"),
+        notifyOnEntry = m.getBoolean("notifyOnEntry"),
+        notifyOnExit = m.getBoolean("notifyOnExit"),
+      )
+    }
+    return out
+  }
+
+  private fun entriesToMap(arr: ReadableArray?): Map<String, String> {
+    if (arr == null) return emptyMap()
+    val out = LinkedHashMap<String, String>(arr.size())
+    for (i in 0 until arr.size()) {
+      val e = arr.getMap(i) ?: continue
+      val k = e.getString("key") ?: continue
+      val v = e.getString("value") ?: continue
+      out[k] = v
+    }
+    return out
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mappers: Kotlin → wire (WritableMap)
+  // ---------------------------------------------------------------------------
+
+  private fun locationToWire(loc: Location): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("id", loc.id)
+    m.putDouble("lat", loc.latitude)
+    m.putDouble("lng", loc.longitude)
+    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)
+    m.putString("quality", qualityToWire(loc.quality))
+    m.putString("trigger", triggerToWire(loc.trigger))
+    m.putString("motion", motionToWire(loc.motion))
+    val activity = loc.activity
+    if (activity != null) m.putString("activity", activityToWire(activity)) else m.putNull("activity")
+    m.putBoolean("isMock", loc.isMock)
+    return m
+  }
+
+  private fun geofenceToWire(g: BeekonGeofence): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("id", g.id)
+    m.putDouble("lat", g.latitude)
+    m.putDouble("lng", g.longitude)
+    m.putDouble("radiusMeters", g.radiusMeters)
+    m.putBoolean("notifyOnEntry", g.notifyOnEntry)
+    m.putBoolean("notifyOnExit", g.notifyOnExit)
+    return m
+  }
+
+  private fun geofenceEventToWire(e: GeofenceEvent): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("id", e.id)
+    m.putString("geofenceId", e.geofenceId)
+    m.putString("type", transitionToWire(e.type))
+    m.putDouble("timestampMs", e.timestamp.toEpochMilli().toDouble())
+    return m
+  }
+
+  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 syncStatusToWire(s: SyncStatus): WritableMap {
+    val m = Arguments.createMap()
+    when (s) {
+      SyncStatus.Idle -> m.putString("type", "idle")
+      SyncStatus.Pending -> m.putString("type", "pending")
+      is SyncStatus.Failed -> {
+        m.putString("type", "failed")
+        m.putString("failure", syncFailureToWire(s.reason))
+      }
+    }
+    return m
+  }
+
+  private fun putNullableDouble(map: WritableMap, key: String, value: Double?) {
+    if (value == null) map.putNull(key) else map.putDouble(key, value)
+  }
+
+  // ---------------------------------------------------------------------------
+  // Enum mappers
+  // ---------------------------------------------------------------------------
+
+  private fun toAccuracyMode(s: String?): AccuracyMode = when (s) {
+    "high" -> AccuracyMode.High
+    "low" -> AccuracyMode.Low
+    else -> AccuracyMode.Balanced
+  }
+
+  private fun toStationaryMode(s: String?): StationaryMode = when (s) {
+    "keepTracking" -> StationaryMode.KeepTracking
+    "pauseWithCheckIns" -> StationaryMode.PauseWithCheckIns
+    else -> StationaryMode.Pause
+  }
+
+  private fun stopReasonToWire(r: StopReason): String = when (r) {
+    StopReason.User -> "user"
+    StopReason.PermissionDenied -> "permissionDenied"
+    StopReason.LocationServicesDisabled -> "locationServicesDisabled"
+    StopReason.LocationUnavailable -> "locationUnavailable"
+    StopReason.System -> "system"
+  }
+
+  private fun syncFailureToWire(f: SyncFailure): String = when (f) {
+    SyncFailure.Auth -> "auth"
+    SyncFailure.Rejected -> "rejected"
+  }
+
+  private fun qualityToWire(q: LocationQuality): String = when (q) {
+    LocationQuality.Ok -> "ok"
+    LocationQuality.LowAccuracy -> "lowAccuracy"
+    LocationQuality.ImplausibleSpeed -> "implausibleSpeed"
+  }
+
+  private fun triggerToWire(t: LocationTrigger): String = when (t) {
+    LocationTrigger.Interval -> "interval"
+    LocationTrigger.Motion -> "motion"
+    LocationTrigger.CheckIn -> "checkIn"
+    LocationTrigger.Geofence -> "geofence"
+    LocationTrigger.Manual -> "manual"
+  }
+
+  private fun motionToWire(m: MotionState): String = when (m) {
+    MotionState.Moving -> "moving"
+    MotionState.Stationary -> "stationary"
+    MotionState.Unknown -> "unknown"
+  }
+
+  private fun activityToWire(a: ActivityType): String = when (a) {
+    ActivityType.Stationary -> "stationary"
+    ActivityType.Walking -> "walking"
+    ActivityType.Running -> "running"
+    ActivityType.Cycling -> "cycling"
+    ActivityType.Automotive -> "automotive"
+    ActivityType.Unknown -> "unknown"
+  }
+
+  private fun transitionToWire(t: Transition): String = when (t) {
+    Transition.Enter -> "enter"
+    Transition.Exit -> "exit"
+  }
+
+  // Maps native exceptions to stable JS-side codes, shared with iOS so JS can
+  // switch on them platform-agnostically.
+  private fun errorCode(t: Throwable): String = when (t) {
+    is BeekonException.StorageException -> "STORAGE_FAILURE"
+    is BeekonException.InvalidGeofence -> "INVALID_GEOFENCE"
+    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,13 @@
 #import "BeekonRn.h"
-// Auto-generated bridging header from the Swift impl in this same target.
+// Auto-generated Swift interop header for the BeekonRnImpl class. Its path
+// depends on how the host links pods: under `<BeekonRn/…>` with
+// `use_frameworks!` (framework), or as a same-target generated header with
+// static linking (the React Native default). Support both.
+#if __has_include(<BeekonRn/BeekonRn-Swift.h>)
+#import <BeekonRn/BeekonRn-Swift.h>
+#else
 #import "BeekonRn-Swift.h"
+#endif
 
 @implementation BeekonRn {
   BeekonRnImpl *_impl;
@@ -11,39 +18,43 @@
   if (self) {
     __weak __typeof(self) weakSelf = self;
     _impl = [[BeekonRnImpl alloc]
-             initWithOnState:^(NSDictionary *_Nonnull s) {
-               [weakSelf emitOnState:s];
-             }
-                  onPosition:^(NSDictionary *_Nonnull p) {
-                    [weakSelf emitOnPosition:p];
-                  }];
+        initOnState:^(NSDictionary *_Nonnull s) {
+          [weakSelf emitOnState:s];
+        }
+        onLocation:^(NSDictionary *_Nonnull l) {
+          [weakSelf emitOnLocation:l];
+        }
+        onGeofenceEvent:^(NSDictionary *_Nonnull e) {
+          [weakSelf emitOnGeofenceEvent:e];
+        }
+        onSyncStatus:^(NSDictionary *_Nonnull st) {
+          [weakSelf emitOnSyncStatus:st];
+        }];
   }
   return self;
 }
 
-- (void)initialize:(RCTPromiseResolveBlock)resolve
-            reject:(RCTPromiseRejectBlock)reject {
-  [_impl initializeWithResolver:resolve rejecter:reject];
+// Called by React Native on teardown (RCTInvalidating). The Codegen base class
+// derives from NSObject, which has no `invalidate`, so there's no super to call.
+- (void)invalidate {
+  [_impl invalidate];
 }
 
-- (void)configure:(JS::NativeBeekonRn::WireConfig &)config
+/// Registers Beekon's background tasks. Call from the host AppDelegate's
+/// `application:didFinishLaunchingWithOptions:` (it must run before that method
+/// returns). Exposed as a class method so hosts don't import BeekonKit directly.
++ (void)registerBackgroundTasks {
+  [BeekonRnImpl registerBackgroundTasks];
+}
+
+// MARK: - Lifecycle
+
+- (void)configure:(NSDictionary *)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.)
-  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],
-  };
-  // Note: iOS doesn't use androidNotification — passed but ignored.
-  [_impl configure:dict resolver:resolve rejecter:reject];
+  // The config crosses as a plain dictionary (UnsafeObject); the Swift side
+  // parses it. iOS ignores `notification` (Android-only).
+  [_impl configure:config resolver:resolve rejecter:reject];
 }
 
 - (void)start:(RCTPromiseResolveBlock)resolve
@@ -56,16 +67,61 @@
   [_impl stopWithResolver:resolve rejecter:reject];
 }
 
-- (void)shutdown:(RCTPromiseResolveBlock)resolve
-          reject:(RCTPromiseRejectBlock)reject {
-  [_impl shutdownWithResolver:resolve rejecter:reject];
+- (void)resumeIfNeeded:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject {
+  [_impl resumeIfNeededWithResolver:resolve rejecter:reject];
+}
+
+// MARK: - History
+
+- (void)getLocations:(double)fromMs
+                toMs:(double)toMs
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+  [_impl getLocationsFromMs:fromMs toMs:toMs resolver:resolve rejecter:reject];
+}
+
+- (void)deleteLocations:(double)beforeMs
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  [_impl deleteLocationsBeforeMs:beforeMs resolver:resolve rejecter:reject];
+}
+
+- (void)pendingUploadCount:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  [_impl pendingUploadCountWithResolver:resolve rejecter:reject];
+}
+
+// MARK: - Sync
+
+- (void)sync:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject {
+  [_impl syncWithResolver:resolve rejecter:reject];
+}
+
+- (void)setExtras:(NSArray *)entries
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject {
+  [_impl setExtras:entries resolver:resolve rejecter:reject];
+}
+
+// MARK: - Geofences
+
+- (void)addGeofences:(NSArray *)geofences
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject {
+  [_impl addGeofences:geofences resolver:resolve rejecter:reject];
+}
+
+- (void)removeGeofences:(NSArray *)ids
+                resolve:(RCTPromiseResolveBlock)resolve
+                 reject:(RCTPromiseRejectBlock)reject {
+  [_impl removeGeofences:ids resolver:resolve rejecter:reject];
 }
 
-- (void)history:(double)fromMs
-           toMs:(double)toMs
-        resolve:(RCTPromiseResolveBlock)resolve
-         reject:(RCTPromiseRejectBlock)reject {
-  [_impl historyFromMs:fromMs toMs:toMs resolver:resolve rejecter:reject];
+- (void)listGeofences:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+  [_impl listGeofencesWithResolver:resolve rejecter:reject];
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule: