@wayq/beekon-rn 0.0.5 → 0.0.6

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

@@ -9,6 +9,11 @@ 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.BeekonException
@@ -18,6 +23,7 @@ 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
@@ -50,6 +56,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       Beekon.geofenceEvents.collect { emitOnGeofenceEvent(geofenceEventToWire(it)) }
     }
     scope.launch { Beekon.syncStatus.collect { emitOnSyncStatus(syncStatusToWire(it)) } }
+    scope.launch { Beekon.authChanges.collect { emitOnAuthTokens(tokenRefreshToWire(it)) } }
   }
 
   // ---------------------------------------------------------------------------
@@ -87,12 +94,13 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  // Android has no native resumeIfNeeded — Beekon.start() rehydrates the
-  // persisted intent (mirrors the Flutter plugin).
+  // 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.start()
+        Beekon.resumeIfNeeded()
         promise.resolve(null)
       } catch (t: Throwable) {
         promise.reject(errorCode(t), t.message ?: "resumeIfNeeded failed", t)
@@ -100,6 +108,21 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  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
   // ---------------------------------------------------------------------------
@@ -229,24 +252,80 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     )
   }
 
-  private fun wireToSyncConfig(map: ReadableMap): SyncConfig =
-    SyncConfig(
+  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 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
+      }
+    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)
+      NotificationConfig(title = title, text = text, smallIcon = smallIcon)
     } else {
-      NotificationConfig(text = text)
+      NotificationConfig(text = text, smallIcon = smallIcon)
     }
   }
 
@@ -347,6 +426,18 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     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)
   }
@@ -367,6 +458,16 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     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"
@@ -419,6 +520,11 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
   private fun errorCode(t: Throwable): String = when (t) {
     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"
   }
 

package/ios/BeekonRn.mm

@@ -29,6 +29,9 @@
         }
         onSyncStatus:^(NSDictionary *_Nonnull st) {
           [weakSelf emitOnSyncStatus:st];
+        }
+        onAuthTokens:^(NSDictionary *_Nonnull t) {
+          [weakSelf emitOnAuthTokens:t];
         }];
   }
   return self;
@@ -72,6 +75,16 @@
   [_impl resumeIfNeededWithResolver:resolve rejecter:reject];
 }
 
+- (void)getCurrentLocation:(double)timeoutMs
+                  accuracy:(NSString *)accuracy
+                   resolve:(RCTPromiseResolveBlock)resolve
+                    reject:(RCTPromiseRejectBlock)reject {
+  [_impl getCurrentLocationTimeoutMs:timeoutMs
+                            accuracy:accuracy
+                            resolver:resolve
+                            rejecter:reject];
+}
+
 // MARK: - History
 
 - (void)getLocations:(double)fromMs

package/ios/BeekonRn.swift

@@ -22,22 +22,26 @@ import BeekonKit
   private let onLocationCb: (NSDictionary) -> Void
   private let onGeofenceEventCb: (NSDictionary) -> Void
   private let onSyncStatusCb: (NSDictionary) -> Void
+  private let onAuthTokensCb: (NSDictionary) -> Void
 
   private var stateTask: Task<Void, Never>?
   private var locationsTask: Task<Void, Never>?
   private var geofenceEventsTask: Task<Void, Never>?
   private var syncStatusTask: Task<Void, Never>?
+  private var authTokensTask: Task<Void, Never>?
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
     onLocation: @escaping (NSDictionary) -> Void,
     onGeofenceEvent: @escaping (NSDictionary) -> Void,
-    onSyncStatus: @escaping (NSDictionary) -> Void
+    onSyncStatus: @escaping (NSDictionary) -> Void,
+    onAuthTokens: @escaping (NSDictionary) -> Void
   ) {
     self.onStateCb = onState
     self.onLocationCb = onLocation
     self.onGeofenceEventCb = onGeofenceEvent
     self.onSyncStatusCb = onSyncStatus
+    self.onAuthTokensCb = onAuthTokens
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -63,6 +67,12 @@ import BeekonKit
         self.onSyncStatusCb(self.syncStatusToWire(status))
       }
     }
+    self.authTokensTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await tokens in await Beekon.shared.authChanges {
+        self.onAuthTokensCb(self.authTokensToWire(tokens))
+      }
+    }
   }
 
   @objc public func invalidate() {
@@ -70,10 +80,12 @@ import BeekonKit
     locationsTask?.cancel()
     geofenceEventsTask?.cancel()
     syncStatusTask?.cancel()
+    authTokensTask?.cancel()
     stateTask = nil
     locationsTask = nil
     geofenceEventsTask = nil
     syncStatusTask = nil
+    authTokensTask = nil
   }
 
   /// Register Beekon's background-refresh task and install cold-launch hooks.
@@ -132,6 +144,29 @@ import BeekonKit
     }
   }
 
+  @objc public func getCurrentLocationTimeoutMs(
+    _ timeoutMs: Double,
+    accuracy: String,
+    resolver resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter reject: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // Empty accuracy is the wire encoding of "use the configured mode".
+    let mode: AccuracyMode? = accuracy.isEmpty ? nil : accuracyModeFromWire(accuracy)
+    Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        let location = try await Beekon.shared.getCurrentLocation(
+          timeout: timeoutMs / 1000.0,
+          accuracy: mode
+        )
+        // 0- or 1-element array — empty means timeout / no fix.
+        resolve(location.map { [self.locationToWire($0)] } ?? [])
+      } catch {
+        reject(self.errorCode(error), error.localizedDescription, error)
+      }
+    }
+  }
+
   // MARK: - History
 
   @objc public func getLocationsFromMs(
@@ -266,14 +301,21 @@ import BeekonKit
 
     var sync: SyncConfig?
     if let s = d["sync"] as? NSDictionary,
-      let urlStr = s["url"] as? String,
-      let url = URL(string: urlStr) {
-      sync = SyncConfig(
-        url: url,
-        headers: entriesToDict((s["headers"] as? NSArray) ?? []),
-        intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
-        batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100
-      )
+      let urlStr = s["url"] as? String {
+      if let url = URL(string: urlStr) {
+        let auth = (s["auth"] as? NSDictionary).map { wireToAuthConfig($0) }
+        sync = SyncConfig(
+          url: url,
+          headers: entriesToDict((s["headers"] as? NSArray) ?? []),
+          intervalSeconds: (s["intervalSeconds"] as? NSNumber)?.doubleValue ?? 300,
+          batchSize: (s["batchSize"] as? NSNumber)?.intValue ?? 100,
+          auth: auth
+        )
+      } else {
+        // Don't silently drop the whole sync config on an unparseable URL —
+        // surface it so a malformed endpoint is diagnosable instead of a no-op.
+        NSLog("[BeekonRn] sync config ignored: url is not a valid URL: %@", urlStr)
+      }
     }
 
     // `notification` is Android-only — iOS ignores it.
@@ -321,6 +363,35 @@ import BeekonKit
     return out
   }
 
+  private func wireToAuthConfig(_ d: NSDictionary) -> AuthConfig {
+    // Wire carries epoch millis; the native recipe wants epoch seconds.
+    let expiresAt = (d["expiresAtMs"] as? NSNumber).map { $0.doubleValue / 1000.0 }
+    let responseMapping = (d["responseMapping"] as? NSDictionary)
+      .map { wireToResponseMapping($0) } ?? AuthResponseMapping()
+    return AuthConfig(
+      accessToken: d["accessToken"] as? String,
+      refreshToken: d["refreshToken"] as? String,
+      expiresAt: expiresAt,
+      strategy: authStrategyFromWire(d["strategy"] as? String),
+      refreshUrl: (d["refreshUrl"] as? String).flatMap { URL(string: $0) },
+      refreshPayload: entriesToDict((d["refreshPayload"] as? NSArray) ?? []),
+      refreshHeaders: entriesToDict((d["refreshHeaders"] as? NSArray) ?? []),
+      refreshBodyFormat: authBodyFormatFromWire(d["refreshBodyFormat"] as? String),
+      responseMapping: responseMapping,
+      skewMarginSeconds: (d["skewMarginSeconds"] as? NSNumber)?.doubleValue ?? 60,
+      seedEpoch: (d["seedEpoch"] as? NSNumber)?.intValue
+    )
+  }
+
+  private func wireToResponseMapping(_ d: NSDictionary) -> AuthResponseMapping {
+    return AuthResponseMapping(
+      accessToken: d["accessToken"] as? String,
+      refreshToken: d["refreshToken"] as? String,
+      expiresIn: d["expiresIn"] as? String,
+      expiresAt: d["expiresAt"] as? String
+    )
+  }
+
   // MARK: - Mappers: Beekon → wire (NSDictionary)
 
   private func locationToWire(_ loc: Location) -> NSDictionary {
@@ -390,6 +461,18 @@ import BeekonKit
     }
   }
 
+  private func authTokensToWire(_ t: AuthTokens) -> NSDictionary {
+    // NSDictionary literals can't carry `nil`; optionals collapse to `NSNull`,
+    // which the Codegen layer translates back to `null` on the JS side.
+    let d = NSMutableDictionary()
+    d["accessToken"] = t.accessToken
+    d["refreshToken"] = t.refreshToken.map { $0 as Any } ?? NSNull()
+    // Native epoch seconds → wire epoch millis.
+    d["expiresAtMs"] = t.expiresAt.map { ($0 * 1000.0) as Any } ?? NSNull()
+    d["epoch"] = t.epoch
+    return d
+  }
+
   // MARK: - Enum mappers
 
   private func accuracyModeFromWire(_ s: String?) -> AccuracyMode {
@@ -408,6 +491,20 @@ import BeekonKit
     }
   }
 
+  private func authStrategyFromWire(_ s: String?) -> AuthStrategy {
+    switch s {
+    case "raw": return .raw
+    default: return .bearer
+    }
+  }
+
+  private func authBodyFormatFromWire(_ s: String?) -> AuthBodyFormat {
+    switch s {
+    case "json": return .json
+    default: return .form
+    }
+  }
+
   private func stopReasonToWire(_ r: StopReason) -> String {
     switch r {
     case .user: return "user"
@@ -483,6 +580,13 @@ import BeekonKit
       switch be {
       case .storage: return "STORAGE_FAILURE"
       case .invalidGeofence: return "INVALID_GEOFENCE"
+      case .locationUnavailable(let reason):
+        switch reason {
+        case .permissionDenied: return "PERMISSION_DENIED"
+        case .locationServicesDisabled: return "LOCATION_SERVICES_DISABLED"
+        case .unavailable: return "LOCATION_UNAVAILABLE"
+        @unknown default: return "LOCATION_UNAVAILABLE"
+        }
       @unknown default: return "INTERNAL_ERROR"
       }
     }

package/ios/Frameworks/BeekonKit.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>BeekonKit.framework/BeekonKit</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>BeekonKit.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>BeekonKit.framework/BeekonKit</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>BeekonKit.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>