@wayq/beekon-rn 0.0.3 → 0.0.6

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

@@ -3,54 +3,72 @@ 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.AuthBodyFormat
+import `in`.wayq.beekon.AuthConfig
+import `in`.wayq.beekon.AuthResponseMapping
+import `in`.wayq.beekon.AuthStrategy
+import `in`.wayq.beekon.AuthTokens
 import `in`.wayq.beekon.Beekon
 import `in`.wayq.beekon.BeekonConfig
-import `in`.wayq.beekon.BeekonError
+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.LocationUnavailableReason
+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.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 
-class BeekonRnModule(private val reactContext: ReactApplicationContext) :
+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 any mapper does work. SupervisorJob so a single failure
-  // doesn't tear down siblings.
+  // 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)
-  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)) }
+    // 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)) } }
+    scope.launch { Beekon.authChanges.collect { emitOnAuthTokens(tokenRefreshToWire(it)) } }
   }
 
+  // ---------------------------------------------------------------------------
+  // Lifecycle (non-suspend native calls resolve directly)
+  // ---------------------------------------------------------------------------
+
   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)
-      }
+    try {
+      Beekon.configure(wireToConfig(config))
+      promise.resolve(null)
+    } catch (t: Throwable) {
+      promise.reject(errorCode(t), t.message ?: "configure failed", t)
     }
   }
 
@@ -76,17 +94,124 @@ class BeekonRnModule(private val reactContext: ReactApplicationContext) :
     }
   }
 
-  override fun history(fromMs: Double, toMs: Double, promise: Promise) {
+  // Calls the guarded native resume (Beekon.resumeIfNeeded), which only
+  // re-adopts a previously-active, non-user-stopped session — a no-op when
+  // already Tracking or when the user explicitly stopped (mirrors iOS).
+  override fun resumeIfNeeded(promise: Promise) {
+    scope.launch {
+      try {
+        Beekon.resumeIfNeeded()
+        promise.resolve(null)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "resumeIfNeeded failed", t)
+      }
+    }
+  }
+
+  override fun getCurrentLocation(timeoutMs: Double, accuracy: String, promise: Promise) {
+    scope.launch {
+      try {
+        // Empty accuracy is the wire encoding of "use the configured mode".
+        val mode = if (accuracy.isEmpty()) null else toAccuracyMode(accuracy)
+        val loc = Beekon.getCurrentLocation(timeoutMs.toLong(), mode)
+        val arr: WritableArray = Arguments.createArray()
+        if (loc != null) arr.pushMap(locationToWire(loc))
+        promise.resolve(arr)
+      } catch (t: Throwable) {
+        promise.reject(errorCode(t), t.message ?: "getCurrentLocation 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 locations = Beekon.history(from, to)
         val arr: WritableArray = Arguments.createArray()
-        for (loc in locations) arr.pushMap(locationToWire(loc))
+        for (loc in Beekon.getLocations(from, to)) arr.pushMap(locationToWire(loc))
         promise.resolve(arr)
       } catch (t: Throwable) {
-        promise.reject(errorCode(t), t.message ?: "history failed", t)
+        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)
       }
     }
   }
@@ -97,54 +222,182 @@ class BeekonRnModule(private val reactContext: ReactApplicationContext) :
   }
 
   // ---------------------------------------------------------------------------
-  // Mappers (Wire ↔ Kotlin types)
+  // Mappers: wire (ReadableMap/Array) → Kotlin
   // ---------------------------------------------------------------------------
 
   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()
+    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(
-      intervalSeconds = intervalSeconds,
-      distanceMeters = distanceMeters,
-      notification = notification,
+      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 {
+    val auth =
+      if (map.hasKey("auth") && !map.isNull("auth")) {
+        map.getMap("auth")?.let { wireToAuthConfig(it) }
+      } else {
+        null
+      }
+    return SyncConfig(
+      url = map.getString("url") ?: "",
+      headers = entriesToMap(map.getArray("headers")),
+      intervalSeconds = map.getDouble("intervalSeconds").toLong(),
+      batchSize = map.getDouble("batchSize").toInt(),
+      auth = auth,
     )
   }
 
-  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'")
+  private fun wireToAuthConfig(map: ReadableMap): AuthConfig {
+    val expiresAt =
+      if (map.hasKey("expiresAtMs") && !map.isNull("expiresAtMs")) {
+        // Wire carries epoch millis; the native recipe wants epoch seconds.
+        (map.getDouble("expiresAtMs") / 1000.0).toLong()
+      } else {
+        null
       }
-      id
+    val seedEpoch =
+      if (map.hasKey("seedEpoch") && !map.isNull("seedEpoch")) {
+        map.getDouble("seedEpoch").toLong()
+      } else {
+        null
+      }
+    val responseMapping =
+      if (map.hasKey("responseMapping") && !map.isNull("responseMapping")) {
+        map.getMap("responseMapping")?.let { wireToResponseMapping(it) } ?: AuthResponseMapping()
+      } else {
+        AuthResponseMapping()
+      }
+    return AuthConfig(
+      accessToken = optString(map, "accessToken"),
+      refreshToken = optString(map, "refreshToken"),
+      expiresAt = expiresAt,
+      strategy = toAuthStrategy(map.getString("strategy")),
+      refreshUrl = optString(map, "refreshUrl"),
+      refreshPayload = entriesToMap(map.getArray("refreshPayload")),
+      refreshHeaders = entriesToMap(map.getArray("refreshHeaders")),
+      refreshBodyFormat = toRefreshBodyFormat(map.getString("refreshBodyFormat")),
+      responseMapping = responseMapping,
+      skewMarginSeconds = map.getDouble("skewMarginSeconds").toLong(),
+      seedEpoch = seedEpoch,
+    )
+  }
+
+  private fun wireToResponseMapping(map: ReadableMap): AuthResponseMapping =
+    AuthResponseMapping(
+      accessToken = optString(map, "accessToken"),
+      refreshToken = optString(map, "refreshToken"),
+      expiresIn = optString(map, "expiresIn"),
+      expiresAt = optString(map, "expiresAt"),
+    )
+
+  private fun optString(map: ReadableMap, key: String): String? =
+    if (map.hasKey(key) && !map.isNull(key)) map.getString(key) else null
+
+  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
+    val smallIcon =
+      if (map.hasKey("smallIcon") && !map.isNull("smallIcon")) map.getString("smallIcon") else null
+    // Use the data-class default for `title` when the wire value is absent.
+    return if (title != null) {
+      NotificationConfig(title = title, text = text, smallIcon = smallIcon)
+    } else {
+      NotificationConfig(text = text, smallIcon = smallIcon)
     }
-    return BeekonConfig.Notification(title = title, text = text, smallIcon = smallIcon)
   }
 
+  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.putDouble("lat", loc.lat)
-    m.putDouble("lng", loc.lng)
+    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 putNullableDouble(map: WritableMap, key: String, value: Double?) {
-    if (value == null) map.putNull(key) else map.putDouble(key, value)
+  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 {
@@ -160,19 +413,118 @@ class BeekonRnModule(private val reactContext: ReactApplicationContext) :
     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 tokenRefreshToWire(t: AuthTokens): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("accessToken", t.accessToken)
+    val refreshToken = t.refreshToken
+    if (refreshToken != null) m.putString("refreshToken", refreshToken) else m.putNull("refreshToken")
+    val expiresAt = t.expiresAt
+    // Native epoch seconds → wire epoch millis.
+    if (expiresAt != null) m.putDouble("expiresAtMs", (expiresAt * 1000L).toDouble()) else m.putNull("expiresAtMs")
+    m.putDouble("epoch", t.epoch.toDouble())
+    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 toAuthStrategy(s: String?): AuthStrategy = when (s) {
+    "raw" -> AuthStrategy.Raw
+    else -> AuthStrategy.Bearer
+  }
+
+  private fun toRefreshBodyFormat(s: String?): AuthBodyFormat = when (s) {
+    "json" -> AuthBodyFormat.Json
+    else -> AuthBodyFormat.Form
+  }
+
   private fun stopReasonToWire(r: StopReason): String = when (r) {
     StopReason.User -> "user"
     StopReason.PermissionDenied -> "permissionDenied"
     StopReason.LocationServicesDisabled -> "locationServicesDisabled"
+    StopReason.LocationUnavailable -> "locationUnavailable"
     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 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 BeekonError.PermissionDenied -> "PERMISSION_DENIED"
-    is BeekonError.LocationServicesDisabled -> "LOCATION_SERVICES_DISABLED"
-    is BeekonError.StorageFailure -> "STORAGE_FAILURE"
+    is BeekonException.StorageException -> "STORAGE_FAILURE"
+    is BeekonException.InvalidGeofence -> "INVALID_GEOFENCE"
+    is BeekonException.LocationUnavailable -> when (t.reason) {
+      LocationUnavailableReason.PermissionDenied -> "PERMISSION_DENIED"
+      LocationUnavailableReason.LocationServicesDisabled -> "LOCATION_SERVICES_DISABLED"
+      LocationUnavailableReason.Unavailable -> "LOCATION_UNAVAILABLE"
+    }
     else -> "INTERNAL_ERROR"
   }