@wayq/beekon-rn 0.0.6 → 0.0.7

package/BeekonRn.podspec

@@ -11,7 +11,7 @@ Pod::Spec.new do |s|
   s.authors      = package["author"]
 
   # iOS 17.0 floor reflects this wrapper's React Native baseline (RN 0.85), not
-  # a BeekonKit constraint — BeekonKit 0.0.6 itself supports iOS 13+ (with
+  # a BeekonKit constraint — BeekonKit 0.0.7 itself supports iOS 13+ (with
   # 13–16 fallback paths). Kept at 17.0 to avoid any consumer regression; do not
   # lower below React Native's own minimum.
   s.platforms    = { :ios => "17.0" }

package/CHANGELOG.md

@@ -6,6 +6,30 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 Beekon is pre-1.0 — releases may contain breaking changes.
 
+## [0.0.7]
+
+Built against the native **0.0.7** API; requires native ≥ 0.0.7 at runtime.
+
+### Added
+
+- **License surface** (`license-format-v1`) — a pure pass-through to the native
+  verifier; the binding performs no validation of its own.
+  - `BeekonConfig.licenseKey` — supply a license token (a `license-format-v1`
+    JWS). The highest-priority channel, overriding the Android manifest
+    (`in.wayq.beekon.license`) / iOS `Info.plist` (`BeekonLicenseKey`) value;
+    `undefined`/blank means unset. Safe to commit to source control (app-id- and
+    product-bound).
+  - `Beekon.licenseStatus()` (one-shot) and `Beekon.onLicenseStatus(cb)`
+    (replay-1 subscription) expose the current platform's status: the
+    discriminated `LicenseStatus` union (`notDetermined` / `licensed` /
+    `evaluation` / `expired` / `updateEntitlementLapsed` / `invalid`) plus
+    `LicenseInvalidReason`. Purely observational — no status ever blocks,
+    degrades, or delays the SDK; Android and iOS may legally diverge for the
+    same app.
+  - The binding identifies itself to the verifier as the `rn` product.
+- Native pins bumped to `0.0.7` (Maven `io.github.wayqteam:beekon`, `BeekonKit`
+  xcframework).
+
 ## [0.0.6]
 
 Built against the native **0.0.6** API; requires native ≥ 0.0.6 at runtime.

package/android/build.gradle

@@ -76,8 +76,9 @@ dependencies {
   implementation "com.facebook.react:react-android"
   // 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.6"
+  // the SDK reaches v1 stability. 0.0.7 is the release that ships the license
+  // API (setWrapperInfo / BeekonConfig.licenseKey / Beekon.licenseStatus).
+  implementation "io.github.wayqteam:beekon:0.0.7"
   // 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

@@ -20,6 +20,7 @@ import `in`.wayq.beekon.BeekonException
 import `in`.wayq.beekon.BeekonGeofence
 import `in`.wayq.beekon.BeekonState
 import `in`.wayq.beekon.GeofenceEvent
+import `in`.wayq.beekon.LicenseStatus
 import `in`.wayq.beekon.Location
 import `in`.wayq.beekon.LocationQuality
 import `in`.wayq.beekon.LocationTrigger
@@ -49,6 +50,11 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
   private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
 
   init {
+    // Identify this wrapper to the native verifier (license-format-v1 §11) before
+    // any configure() can run — a direct native call, deliberately not bridged to
+    // JS. The module is constructed before its first method dispatch, so this is
+    // always set first.
+    Beekon.setWrapperInfo("rn", WRAPPER_VERSION)
     // 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)) } }
@@ -57,6 +63,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
     scope.launch { Beekon.syncStatus.collect { emitOnSyncStatus(syncStatusToWire(it)) } }
     scope.launch { Beekon.authChanges.collect { emitOnAuthTokens(tokenRefreshToWire(it)) } }
+    scope.launch { Beekon.licenseStatus.collect { emitOnLicenseStatus(licenseStatusToWire(it)) } }
   }
 
   // ---------------------------------------------------------------------------
@@ -216,6 +223,15 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  // ---------------------------------------------------------------------------
+  // License (observational only — never blocks; license-format-v1 §8)
+  // ---------------------------------------------------------------------------
+
+  override fun licenseStatus(promise: Promise) {
+    // StateFlow.value is the current, synchronously-readable status.
+    promise.resolve(licenseStatusToWire(Beekon.licenseStatus.value))
+  }
+
   override fun invalidate() {
     super.invalidate()
     scope.cancel()
@@ -249,6 +265,9 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
       detectActivity = map.getBoolean("detectActivity"),
       sync = sync,
       notification = notification ?: NotificationConfig(),
+      // Passed through verbatim; absent/null means unset — the SDK falls through
+      // to the manifest meta-data, then evaluation (license-format-v1 §9).
+      licenseKey = optString(map, "licenseKey"),
     )
   }
 
@@ -438,6 +457,33 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     return m
   }
 
+  // Reads the SDK's wire-stable names (no validation here). `tier`/`entitlements`
+  // populate only for Licensed; `reason` only for Invalid.
+  private fun licenseStatusToWire(s: LicenseStatus): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("status", s.wireName)
+    when (s) {
+      is LicenseStatus.Licensed -> {
+        m.putString("tier", s.tier)
+        val arr: WritableArray = Arguments.createArray()
+        for (e in s.entitlements) arr.pushString(e)
+        m.putArray("entitlements", arr)
+        m.putNull("reason")
+      }
+      is LicenseStatus.Invalid -> {
+        m.putNull("tier")
+        m.putArray("entitlements", Arguments.createArray())
+        m.putString("reason", s.reason.wireName)
+      }
+      else -> {
+        m.putNull("tier")
+        m.putArray("entitlements", Arguments.createArray())
+        m.putNull("reason")
+      }
+    }
+    return m
+  }
+
   private fun putNullableDouble(map: WritableMap, key: String, value: Double?) {
     if (value == null) map.putNull(key) else map.putDouble(key, value)
   }
@@ -530,5 +576,10 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
 
   companion object {
     const val NAME = NativeBeekonRnSpec.NAME
+
+    // Reported to the native verifier via setWrapperInfo (diagnostics only — the
+    // verifier consumes only the product). Keep in sync with package.json
+    // "version" on release.
+    private const val WRAPPER_VERSION = "0.0.7"
   }
 }

package/ios/BeekonRn.mm

@@ -32,6 +32,9 @@
         }
         onAuthTokens:^(NSDictionary *_Nonnull t) {
           [weakSelf emitOnAuthTokens:t];
+        }
+        onLicenseStatus:^(NSDictionary *_Nonnull ls) {
+          [weakSelf emitOnLicenseStatus:ls];
         }];
   }
   return self;
@@ -137,6 +140,13 @@
   [_impl listGeofencesWithResolver:resolve rejecter:reject];
 }
 
+// MARK: - License
+
+- (void)licenseStatus:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+  [_impl licenseStatusWithResolver:resolve rejecter:reject];
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params {
   return std::make_shared<facebook::react::NativeBeekonRnSpecJSI>(params);

package/ios/BeekonRn.swift

@@ -23,25 +23,38 @@ import BeekonKit
   private let onGeofenceEventCb: (NSDictionary) -> Void
   private let onSyncStatusCb: (NSDictionary) -> Void
   private let onAuthTokensCb: (NSDictionary) -> Void
+  private let onLicenseStatusCb: (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>?
+  private var licenseStatusTask: Task<Void, Never>?
+
+  // Reported to the native verifier via setWrapperInfo (diagnostics only — the
+  // verifier consumes only the product). Keep in sync with package.json
+  // "version" on release.
+  private static let wrapperVersion = "0.0.7"
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
     onLocation: @escaping (NSDictionary) -> Void,
     onGeofenceEvent: @escaping (NSDictionary) -> Void,
     onSyncStatus: @escaping (NSDictionary) -> Void,
-    onAuthTokens: @escaping (NSDictionary) -> Void
+    onAuthTokens: @escaping (NSDictionary) -> Void,
+    onLicenseStatus: @escaping (NSDictionary) -> Void
   ) {
+    // Identify this wrapper to the native verifier (license-format-v1 §11) before
+    // any configure() can run — a direct native call (nonisolated static),
+    // deliberately not bridged to JS.
+    Beekon.setWrapperInfo(product: "rn", version: BeekonRnImpl.wrapperVersion)
     self.onStateCb = onState
     self.onLocationCb = onLocation
     self.onGeofenceEventCb = onGeofenceEvent
     self.onSyncStatusCb = onSyncStatus
     self.onAuthTokensCb = onAuthTokens
+    self.onLicenseStatusCb = onLicenseStatus
     super.init()
     self.stateTask = Task { [weak self] in
       guard let self = self else { return }
@@ -73,6 +86,12 @@ import BeekonKit
         self.onAuthTokensCb(self.authTokensToWire(tokens))
       }
     }
+    self.licenseStatusTask = Task { [weak self] in
+      guard let self = self else { return }
+      for await status in await Beekon.shared.licenseStatusUpdates {
+        self.onLicenseStatusCb(self.licenseStatusToWire(status))
+      }
+    }
   }
 
   @objc public func invalidate() {
@@ -81,11 +100,13 @@ import BeekonKit
     geofenceEventsTask?.cancel()
     syncStatusTask?.cancel()
     authTokensTask?.cancel()
+    licenseStatusTask?.cancel()
     stateTask = nil
     locationsTask = nil
     geofenceEventsTask = nil
     syncStatusTask = nil
     authTokensTask = nil
+    licenseStatusTask = nil
   }
 
   /// Register Beekon's background-refresh task and install cold-launch hooks.
@@ -288,6 +309,19 @@ import BeekonKit
     }
   }
 
+  // MARK: - License (observational only — never blocks; license-format-v1 §8)
+
+  @objc public func licenseStatusWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    Task { [weak self] in
+      guard let self = self else { return }
+      // `licenseStatus` is an actor-isolated property — read it with `await`.
+      resolve(self.licenseStatusToWire(await Beekon.shared.licenseStatus))
+    }
+  }
+
   // MARK: - Mappers: wire (NSDictionary/NSArray) → Beekon
 
   private func wireToConfig(_ d: NSDictionary) -> BeekonConfig {
@@ -326,7 +360,10 @@ import BeekonKit
       whenStationary: stationaryModeFromWire(d["whenStationary"] as? String),
       stationaryRadiusMeters: stationaryRadius,
       detectActivity: detectActivity,
-      sync: sync
+      sync: sync,
+      // Passed through verbatim; nil/blank means unset — the SDK falls through to
+      // the Info.plist value, then evaluation (license-format-v1 §9).
+      licenseKey: d["licenseKey"] as? String
     )
   }
 
@@ -473,6 +510,54 @@ import BeekonKit
     return d
   }
 
+  private func licenseStatusToWire(_ s: LicenseStatus) -> NSDictionary {
+    // NSDictionary literals can't carry `nil`; optionals collapse to `NSNull`,
+    // which the Codegen layer translates back to `null` on the JS side. iOS has
+    // no `.wireName`, so the wire-stable strings are written literally here (as
+    // with stateToWire / syncStatusToWire). No validation — the SDK already
+    // decided the status.
+    let d = NSMutableDictionary()
+    switch s {
+    case let .licensed(tier, entitlements):
+      d["status"] = "licensed"
+      d["tier"] = tier
+      d["entitlements"] = entitlements
+      d["reason"] = NSNull()
+    case let .invalid(reason):
+      d["status"] = "invalid"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = reason.rawValue
+    case .evaluation:
+      d["status"] = "evaluation"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .expired:
+      d["status"] = "expired"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .updateEntitlementLapsed:
+      d["status"] = "updateEntitlementLapsed"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    case .notDetermined:
+      d["status"] = "notDetermined"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default:
+      d["status"] = "notDetermined"
+      d["tier"] = NSNull()
+      d["entitlements"] = [String]()
+      d["reason"] = NSNull()
+    }
+    return d
+  }
+
   // MARK: - Enum mappers
 
   private func accuracyModeFromWire(_ s: String?) -> AccuracyMode {