@wayq/beekon-rn 0.0.3 → 0.0.5

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

@@ -3,54 +3,65 @@ 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.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.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)) } }
   }
 
+  // ---------------------------------------------------------------------------
+  // 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 +87,108 @@ class BeekonRnModule(private val reactContext: ReactApplicationContext) :
     }
   }
 
-  override fun history(fromMs: Double, toMs: Double, promise: Promise) {
+  // 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 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 +199,126 @@ 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 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'")
-      }
-      id
+  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)
     }
-    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 +334,91 @@ 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 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"
   }
 
-  // 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"
     else -> "INTERNAL_ERROR"
   }
 

package/ios/BeekonRn.mm

@@ -1,8 +1,13 @@
 #import "BeekonRn.h"
-// Auto-generated bridging header from the Swift impl. With `use_frameworks!`
-// in the host Podfile (required for Swift pods), CocoaPods generates this
-// inside the BeekonRn framework, so the framework-style import is needed.
+// 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;
@@ -13,32 +18,43 @@
   if (self) {
     __weak __typeof(self) weakSelf = self;
     _impl = [[BeekonRnImpl alloc]
-             initOnState:^(NSDictionary *_Nonnull s) {
-               [weakSelf emitOnState:s];
-             }
-              onLocation:^(NSDictionary *_Nonnull l) {
-                [weakSelf emitOnLocation:l];
-              }];
+        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;
 }
 
+// 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];
-  [super 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. iOS
-  // ignores `androidNotification` — passed through but unused.
-  NSDictionary *dict = @{
-    @"intervalSeconds": @(config.intervalSeconds()),
-    @"distanceMeters": @(config.distanceMeters()),
-  };
-  [_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
@@ -51,11 +67,61 @@
   [_impl stopWithResolver: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)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)listGeofences:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject {
+  [_impl listGeofencesWithResolver:resolve rejecter:reject];
 }
 
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule: