@wayq/beekon-rn 0.0.9 → 0.1.2

package/android/build.gradle

@@ -1,7 +1,7 @@
 buildscript {
   ext.BeekonRn = [
     kotlinVersion: "2.1.20",
-    // minSdk 26 is required by the native Beekon AAR (io.github.wayqteam:beekon).
+    // minSdk 26 is required by the native Beekon AAR (io.github.beekonlabs:beekon).
     minSdkVersion: 26,
     compileSdkVersion: 36,
     targetSdkVersion: 36
@@ -79,7 +79,7 @@ dependencies {
   // the SDK reaches v1 stability. 0.0.7 is the release that ships the license
   // API (setWrapperInfo / BeekonConfig.licenseKey / Beekon.licenseStatus);
   // 0.0.8 embeds the production ES256 verification keyset.
-  implementation "io.github.wayqteam:beekon:0.0.9"
+  implementation "io.github.beekonlabs:beekon:0.1.2"
   // 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/AndroidManifest.xml

@@ -1,2 +1,12 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!--
+      Declares the build-time license-gate product id (build-gate-v1 §6): a static
+      <meta-data> that manifest-merges into the host so the gate validates against
+      the `rn` product, mirroring the runtime setWrapperInfo("rn", …). No runtime effect.
+    -->
+    <application>
+        <meta-data
+            android:name="in.wayq.beekon.product"
+            android:value="rn" />
+    </application>
 </manifest>

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

@@ -18,8 +18,10 @@ import `in`.wayq.beekon.Beekon
 import `in`.wayq.beekon.BeekonConfig
 import `in`.wayq.beekon.BeekonException
 import `in`.wayq.beekon.BeekonGeofence
+import `in`.wayq.beekon.BeekonPermission
 import `in`.wayq.beekon.BeekonState
 import `in`.wayq.beekon.GeofenceEvent
+import `in`.wayq.beekon.GeofenceNotification
 import `in`.wayq.beekon.LicenseStatus
 import `in`.wayq.beekon.Location
 import `in`.wayq.beekon.LocationQuality
@@ -29,6 +31,12 @@ import `in`.wayq.beekon.LogEntry
 import `in`.wayq.beekon.LogLevel
 import `in`.wayq.beekon.MotionState
 import `in`.wayq.beekon.NotificationConfig
+import `in`.wayq.beekon.NotificationContent
+import `in`.wayq.beekon.NotificationDelivery
+import `in`.wayq.beekon.NotificationImportance
+import `in`.wayq.beekon.PermissionImportance
+import `in`.wayq.beekon.PermissionRequirement
+import `in`.wayq.beekon.PermissionStatus
 import `in`.wayq.beekon.StationaryMode
 import `in`.wayq.beekon.StopReason
 import `in`.wayq.beekon.SyncConfig
@@ -37,6 +45,7 @@ import `in`.wayq.beekon.SyncStatus
 import `in`.wayq.beekon.Transition
 import java.time.Instant
 import kotlinx.coroutines.CoroutineScope
+import org.json.JSONObject
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
@@ -235,6 +244,18 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     promise.resolve(licenseStatusToWire(Beekon.licenseStatus.value))
   }
 
+  override fun getPermissionStatus(promise: Promise) {
+    // Synchronous, non-throwing read on the native SDK.
+    promise.resolve(permissionStatusToWire(Beekon.getPermissionStatus()))
+  }
+
+  override fun getRequiredPermissions(promise: Promise) {
+    // Synchronous, non-throwing read on the native SDK.
+    val arr: WritableArray = Arguments.createArray()
+    for (r in Beekon.getRequiredPermissions()) arr.pushMap(permissionRequirementToWire(r))
+    promise.resolve(arr)
+  }
+
   // ---------------------------------------------------------------------------
   // Diagnostic logs (spec diagnostics/log-format-v1)
   // ---------------------------------------------------------------------------
@@ -440,6 +461,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
         radiusMeters = m.getDouble("radiusMeters"),
         notifyOnEntry = m.getBoolean("notifyOnEntry"),
         notifyOnExit = m.getBoolean("notifyOnExit"),
+        notification = GeofenceNotificationWire.decode(m.getString("notificationJson")),
       )
     }
     return out
@@ -488,6 +510,7 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     m.putDouble("radiusMeters", g.radiusMeters)
     m.putBoolean("notifyOnEntry", g.notifyOnEntry)
     m.putBoolean("notifyOnExit", g.notifyOnExit)
+    g.notification?.let { m.putString("notificationJson", GeofenceNotificationWire.encode(it)) }
     return m
   }
 
@@ -513,6 +536,48 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     return m
   }
 
+  private fun permissionStatusToWire(p: PermissionStatus): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("level", permissionLevelToWire(p.level))
+    // '' is the wire encoding of null (not granted).
+    m.putString("accuracy", p.accuracy?.let { permissionAccuracyToWire(it) } ?: "")
+    return m
+  }
+
+  private fun permissionLevelToWire(l: PermissionStatus.Level): String = when (l) {
+    PermissionStatus.Level.NotDetermined -> "notDetermined"
+    PermissionStatus.Level.Denied -> "denied"
+    PermissionStatus.Level.Restricted -> "restricted"
+    PermissionStatus.Level.Foreground -> "foreground"
+    PermissionStatus.Level.Background -> "background"
+  }
+
+  private fun permissionAccuracyToWire(a: PermissionStatus.Accuracy): String = when (a) {
+    PermissionStatus.Accuracy.Full -> "full"
+    PermissionStatus.Accuracy.Reduced -> "reduced"
+  }
+
+  private fun permissionRequirementToWire(r: PermissionRequirement): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("permission", permissionKindToWire(r.permission))
+    m.putString("importance", permissionImportanceToWire(r.importance))
+    m.putBoolean("satisfied", r.satisfied)
+    m.putString("rationale", r.rationale)
+    return m
+  }
+
+  private fun permissionKindToWire(p: BeekonPermission): String = when (p) {
+    BeekonPermission.Location -> "location"
+    BeekonPermission.BackgroundLocation -> "backgroundLocation"
+    BeekonPermission.ActivityRecognition -> "activityRecognition"
+    BeekonPermission.Notifications -> "notifications"
+  }
+
+  private fun permissionImportanceToWire(i: PermissionImportance): String = when (i) {
+    PermissionImportance.Required -> "required"
+    PermissionImportance.Recommended -> "recommended"
+  }
+
   private fun syncStatusToWire(s: SyncStatus): WritableMap {
     val m = Arguments.createMap()
     when (s) {
@@ -678,6 +743,72 @@ class BeekonRnModule(reactContext: ReactApplicationContext) :
     // 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.9"
+    private const val WRAPPER_VERSION = "0.1.2"
+  }
+}
+
+/**
+ * Wrapper-local (de)serialization for [GeofenceNotification] in the canonical JSON shape shared
+ * with the native SDKs. The SDK's own `GeofenceNotificationJson` is `internal`, so the module
+ * cannot reuse it; this mirrors it exactly. Tolerant: unknown enums fall back to defaults and a
+ * malformed/empty payload yields null.
+ */
+private object GeofenceNotificationWire {
+  fun encode(n: GeofenceNotification): String {
+    val obj = JSONObject()
+    obj.put("delivery", if (n.delivery == NotificationDelivery.Cloud) "cloud" else "local")
+    n.onEnter?.let { obj.put("onEnter", contentToJson(it)) }
+    n.onExit?.let { obj.put("onExit", contentToJson(it)) }
+    return obj.toString()
+  }
+
+  fun decode(json: String?): GeofenceNotification? {
+    if (json.isNullOrBlank()) return null
+    return runCatching {
+      val obj = JSONObject(json)
+      val onEnter = contentFromJson(obj.optJSONObject("onEnter"))
+      val onExit = contentFromJson(obj.optJSONObject("onExit"))
+      if (onEnter == null && onExit == null) {
+        null
+      } else {
+        val delivery = if (obj.optString("delivery", "local") == "cloud") {
+          NotificationDelivery.Cloud
+        } else {
+          NotificationDelivery.Local
+        }
+        GeofenceNotification(onEnter = onEnter, onExit = onExit, delivery = delivery)
+      }
+    }.getOrNull()
+  }
+
+  private fun contentToJson(c: NotificationContent): JSONObject {
+    val obj = JSONObject()
+    obj.put("title", c.title)
+    obj.put("body", c.body)
+    obj.put("importance", if (c.importance == NotificationImportance.Default) "default" else "high")
+    c.deepLink?.let { obj.put("deepLink", it) }
+    if (c.data.isNotEmpty()) {
+      val data = JSONObject()
+      for ((k, v) in c.data) data.put(k, v)
+      obj.put("data", data)
+    }
+    return obj
+  }
+
+  private fun contentFromJson(obj: JSONObject?): NotificationContent? {
+    if (obj == null) return null
+    val title = obj.optString("title", "")
+    val body = obj.optString("body", "")
+    if (title.isEmpty() || body.isEmpty()) return null
+    val importance = if (obj.optString("importance", "high") == "default") {
+      NotificationImportance.Default
+    } else {
+      NotificationImportance.High
+    }
+    val deepLink = if (obj.has("deepLink") && !obj.isNull("deepLink")) obj.optString("deepLink") else null
+    val data = obj.optJSONObject("data")?.let { d ->
+      buildMap { for (key in d.keys()) put(key, d.optString(key)) }
+    } ?: emptyMap()
+    return NotificationContent(title = title, body = body, importance = importance, deepLink = deepLink, data = data)
   }
 }

package/ios/BeekonRn.mm

@@ -150,6 +150,11 @@
   [_impl licenseStatusWithResolver:resolve rejecter:reject];
 }
 
+- (void)getPermissionStatus:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [_impl getPermissionStatusWithResolver:resolve rejecter:reject];
+}
+
 // MARK: - Diagnostic logs
 
 - (void)getLog:(double)fromMs

package/ios/BeekonRn.swift

@@ -37,7 +37,7 @@ import BeekonKit
   // 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.9"
+  private static let wrapperVersion = "0.1.2"
 
   @objc public init(
     onState: @escaping (NSDictionary) -> Void,
@@ -345,6 +345,26 @@ import BeekonKit
     }
   }
 
+  @objc public func getPermissionStatusWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // `getPermissionStatus()` is `nonisolated` + synchronous — no Task/await.
+    resolve(permissionStatusToWire(Beekon.shared.getPermissionStatus()))
+  }
+
+  @objc public func getRequiredPermissionsWithResolver(
+    _ resolve: @escaping @Sendable (Any?) -> Void,
+    rejecter _: @escaping @Sendable (String?, String?, Error?) -> Void
+  ) {
+    // `getRequiredPermissions()` is actor-isolated (`await`).
+    Task { [weak self] in
+      guard let self = self else { return }
+      let requirements = await Beekon.shared.getRequiredPermissions()
+      resolve(requirements.map { self.permissionRequirementToWire($0) })
+    }
+  }
+
   // MARK: - Diagnostic logs (spec diagnostics/log-format-v1)
 
   @objc public func getLogFromMs(
@@ -496,7 +516,12 @@ import BeekonKit
           longitude: lng,
           radiusMeters: radius,
           notifyOnEntry: (m["notifyOnEntry"] as? NSNumber)?.boolValue ?? true,
-          notifyOnExit: (m["notifyOnExit"] as? NSNumber)?.boolValue ?? true
+          notifyOnExit: (m["notifyOnExit"] as? NSNumber)?.boolValue ?? true,
+          // Native `GeofenceNotification` is Codable in the canonical shape; a malformed
+          // string degrades to nil rather than failing the add.
+          notification: (m["notificationJson"] as? String).flatMap {
+            try? JSONDecoder().decode(GeofenceNotification.self, from: Data($0.utf8))
+          }
         )
       )
     }
@@ -565,14 +590,19 @@ import BeekonKit
   }
 
   private func geofenceToWire(_ g: BeekonGeofence) -> NSDictionary {
-    return [
-      "id": g.id,
-      "lat": g.latitude,
-      "lng": g.longitude,
-      "radiusMeters": g.radiusMeters,
-      "notifyOnEntry": g.notifyOnEntry,
-      "notifyOnExit": g.notifyOnExit,
-    ]
+    let m = NSMutableDictionary()
+    m["id"] = g.id
+    m["lat"] = g.latitude
+    m["lng"] = g.longitude
+    m["radiusMeters"] = g.radiusMeters
+    m["notifyOnEntry"] = g.notifyOnEntry
+    m["notifyOnExit"] = g.notifyOnExit
+    if let notification = g.notification,
+       let data = try? JSONEncoder().encode(notification),
+       let json = String(data: data, encoding: .utf8) {
+      m["notificationJson"] = json
+    }
+    return m
   }
 
   private func geofenceEventToWire(_ e: GeofenceEvent) -> NSDictionary {
@@ -594,6 +624,62 @@ import BeekonKit
     ]
   }
 
+  private func permissionStatusToWire(_ p: PermissionStatus) -> NSDictionary {
+    return [
+      "level": permissionLevelToWire(p.level),
+      // "" is the wire encoding of null (not granted).
+      "accuracy": p.accuracy.map { permissionAccuracyToWire($0) } ?? "",
+    ]
+  }
+
+  private func permissionLevelToWire(_ l: PermissionStatus.Level) -> String {
+    switch l {
+    case .notDetermined: return "notDetermined"
+    case .denied: return "denied"
+    case .restricted: return "restricted"
+    case .foreground: return "foreground"
+    case .background: return "background"
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default: return "notDetermined"
+    }
+  }
+
+  private func permissionAccuracyToWire(_ a: PermissionStatus.Accuracy) -> String {
+    switch a {
+    case .full: return "full"
+    case .reduced: return "reduced"
+    @unknown default: return "full"
+    }
+  }
+
+  private func permissionRequirementToWire(_ r: PermissionRequirement) -> NSDictionary {
+    return [
+      "permission": permissionKindToWire(r.permission),
+      "importance": permissionImportanceToWire(r.importance),
+      "satisfied": r.satisfied,
+      "rationale": r.rationale,
+    ]
+  }
+
+  private func permissionKindToWire(_ p: PermissionRequirement.Permission) -> String {
+    switch p {
+    case .location: return "location"
+    case .backgroundLocation: return "backgroundLocation"
+    case .activityRecognition: return "activityRecognition"
+    case .notifications: return "notifications"
+    // BeekonKit enums are non-frozen (library-evolution binary); handle unknowns.
+    @unknown default: return "location"
+    }
+  }
+
+  private func permissionImportanceToWire(_ i: PermissionRequirement.Importance) -> String {
+    switch i {
+    case .required: return "required"
+    case .recommended: return "recommended"
+    @unknown default: return "recommended"
+    }
+  }
+
   private func stateToWire(_ s: BeekonState) -> NSDictionary {
     switch s {
     case .idle:

package/ios/Frameworks/BeekonKit.xcframework/LICENSE.txt

@@ -1,9 +1,9 @@
 Beekon SDK
-Copyright (c) 2026 wayqteam. All rights reserved.
+Copyright (c) 2026 beekonlabs. All rights reserved.
 
 This software is licensed for evaluation use only. No production deployment,
 redistribution, sublicensing, or commercial use is permitted without a separate
-written agreement with wayqteam.
+written agreement with beekonlabs.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
@@ -11,4 +11,4 @@ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY ARISING
 FROM USE OF THE SOFTWARE.
 
-For licensing inquiries: contact wayqteam.
+For licensing inquiries: contact beekonlabs.