@doorstepai/dropoff-sdk 2.0.8 → 2.0.9

package/android/build.gradle

@@ -86,7 +86,7 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation("ai.doorstep.com:doorstepai-dropoff-sdk:2.0.10")
+  implementation("ai.doorstep.com:doorstepai-dropoff-sdk:2.0.13")
   api "org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1"
 }
 

package/android/src/main/java/com/doorstepai/dropoffsdk/DoorstepAIModule.kt

@@ -11,9 +11,19 @@ import com.doorstepai.sdks.tracking.AddressType
 import com.doorstepai.sdks.tracking.DropoffType
 import com.doorstepai.sdks.tracking.LatLngObject
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.doorstepai.sdks.tracking.DeliveryStop
+import com.doorstepai.sdks.tracking.RouteGeofenceOptions
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 
 
 class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
@@ -203,9 +213,9 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun newEvent(eventName: String, deliveryId: String, promise: Promise) {
+  fun newEvent(eventName: String, deliveryId: String, timestamp: Double?, promise: Promise) {
     try {
-      DoorstepAI.newEvent(eventName, deliveryId) { /* Callback might not be invoked or provide useful data */ }
+      DoorstepAI.newEvent(eventName, deliveryId, timestamp) { /* Callback not needed here */ }
       promise.resolve("Event $eventName triggered for $deliveryId")
     } catch (e: Exception) {
       promise.reject("EVENT_CREATION_ERROR", e.message ?: "Failed to save event")
@@ -289,7 +299,142 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
     return LatLngObject(lat = lat, lng = lng)
   }
 
+  // ---- Route geofencing ----
+
+  private val moduleScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+  private var geofenceJob: Job? = null
+
+  @ReactMethod
+  fun startRouteGeofencing(stops: ReadableArray, options: ReadableMap?, promise: Promise) {
+    try {
+      val parsed = parseStops(stops)
+      if (parsed.isEmpty()) {
+        promise.reject(
+          "ROUTE_GEOFENCING_ERROR",
+          "startRouteGeofencing requires at least one valid stop (deliveryId + latitude + longitude)"
+        )
+        return
+      }
+      DoorstepAI.startRouteGeofencing(parsed, parseRouteOptions(options)) { result ->
+        result.onSuccess { promise.resolve(true) }
+          .onFailure { promise.reject("ROUTE_GEOFENCING_ERROR", it.message ?: "Failed to start route geofencing") }
+      }
+    } catch (e: Exception) {
+      promise.reject("ROUTE_GEOFENCING_ERROR", e.message ?: "Failed to start route geofencing")
+    }
+  }
+
+  @ReactMethod
+  fun stopRouteGeofencing(promise: Promise) {
+    try {
+      DoorstepAI.stopRouteGeofencing()
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject("ROUTE_GEOFENCING_ERROR", e.message ?: "Failed to stop route geofencing")
+    }
+  }
+
+  @ReactMethod
+  fun resumeRouteGeofencingIfNeeded(promise: Promise) {
+    try {
+      DoorstepAI.resumeRouteGeofencingIfNeeded()
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject("ROUTE_GEOFENCING_ERROR", e.message ?: "Failed to resume route geofencing")
+    }
+  }
+
+  @ReactMethod
+  fun getMonitoredStops(promise: Promise) {
+    try {
+      val arr = Arguments.createArray()
+      DoorstepAI.monitoredStops.forEach { arr.pushMap(serializeStop(it)) }
+      promise.resolve(arr)
+    } catch (e: Exception) {
+      promise.reject("ROUTE_GEOFENCING_ERROR", e.message ?: "Failed to get monitored stops")
+    }
+  }
+
+  // ---- Geofence-session event stream (NativeEventEmitter) ----
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // On the first JS subscription, bridge the SDK's geofenceSessionEvents Flow
+    // to JS. A single collector serves the module lifetime (cancelled in invalidate()).
+    if (geofenceJob == null) {
+      geofenceJob = DoorstepAI.geofenceSessionEvents
+        .onEach { ev ->
+          val map = Arguments.createMap().apply {
+            putString("deliveryId", ev.deliveryId)
+            putString("type", ev.type.name) // "STARTED" | "STOPPED"
+            putString("reason", ev.reason)
+          }
+          reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit(GEOFENCE_EVENT, map)
+        }
+        .launchIn(moduleScope)
+    }
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Required stub for NativeEventEmitter on Android. The single Flow collector
+    // is torn down in invalidate(); no per-listener teardown is needed.
+  }
+
+  override fun invalidate() {
+    geofenceJob?.cancel()
+    geofenceJob = null
+    super.invalidate()
+  }
+
+  private fun parseStops(arr: ReadableArray): List<DeliveryStop> {
+    val out = mutableListOf<DeliveryStop>()
+    for (i in 0 until arr.size()) {
+      val m = arr.getMap(i) ?: continue
+      val deliveryId = if (m.hasKey("deliveryId")) m.getString("deliveryId") else null
+      if (deliveryId.isNullOrEmpty()) continue
+      if (!m.hasKey("latitude") || !m.hasKey("longitude")) continue
+      out.add(
+        DeliveryStop(
+          deliveryId = deliveryId,
+          address = if (m.hasKey("address")) m.getString("address") ?: "" else "",
+          latitude = m.getDouble("latitude"),
+          longitude = m.getDouble("longitude"),
+          radiusMeters = if (m.hasKey("radiusMeters") && !m.isNull("radiusMeters")) m.getDouble("radiusMeters") else null,
+          customerId = if (m.hasKey("customerId")) m.getString("customerId") else null,
+          driverId = if (m.hasKey("driverId")) m.getString("driverId") else null
+        )
+      )
+    }
+    return out
+  }
+
+  private fun parseRouteOptions(m: ReadableMap?): RouteGeofenceOptions {
+    if (m == null) return RouteGeofenceOptions()
+    return RouteGeofenceOptions(
+      defaultRadiusMeters = if (m.hasKey("defaultRadiusMeters") && !m.isNull("defaultRadiusMeters")) m.getDouble("defaultRadiusMeters") else 250.0,
+      timeoutSeconds = if (m.hasKey("timeoutSeconds") && !m.isNull("timeoutSeconds")) m.getDouble("timeoutSeconds") else null,
+      autoStopAfterDropoffSeconds = if (m.hasKey("autoStopAfterDropoffSeconds") && !m.isNull("autoStopAfterDropoffSeconds")) m.getDouble("autoStopAfterDropoffSeconds") else null,
+      manualForeground = if (m.hasKey("manualForeground") && !m.isNull("manualForeground")) m.getBoolean("manualForeground") else false
+    )
+  }
+
+  private fun serializeStop(s: DeliveryStop): WritableMap {
+    val m = Arguments.createMap()
+    m.putString("deliveryId", s.deliveryId)
+    m.putString("address", s.address)
+    m.putDouble("latitude", s.latitude)
+    m.putDouble("longitude", s.longitude)
+    s.radiusMeters?.let { m.putDouble("radiusMeters", it) }
+    s.customerId?.let { m.putString("customerId", it) }
+    s.driverId?.let { m.putString("driverId", it) }
+    return m
+  }
+
   companion object {
     const val NAME = "DoorstepAI"
+    private const val GEOFENCE_EVENT = "DoorstepGeofenceSessionEvent"
   }
 }

package/ios/DoorstepAI.mm

@@ -1,6 +1,7 @@
 #import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(DoorstepAI, NSObject)
+@interface RCT_EXTERN_MODULE(DoorstepAI, RCTEventEmitter)
 
 RCT_EXTERN_METHOD(setApiKey:(nonnull NSString *)apiKey)
 RCT_EXTERN_METHOD(requestAllPermissions:(BOOL)requestAlwaysLocation)
@@ -58,6 +59,7 @@ RCT_EXTERN_METHOD(startDeliveryByLatLng:(nonnull NSNumber *)latitude
                  rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(newEvent:(nonnull NSString *)eventName
                  deliveryId:(nonnull NSString *)deliveryId
+                 timestamp:(id)timestamp
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(markDropoff:(nonnull NSString *)deliveryId
@@ -68,4 +70,16 @@ RCT_EXTERN_METHOD(stopDelivery:(nonnull NSString *)deliveryId
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
 
+// ---- Route geofencing ----
+RCT_EXTERN_METHOD(startRouteGeofencing:(nonnull NSArray *)stops
+                 options:(nullable NSDictionary *)options
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(stopRouteGeofencing:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(resumeRouteGeofencingIfNeeded:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getMonitoredStops:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+
 @end

package/ios/DoorstepAI.swift

@@ -3,12 +3,48 @@ import React
 import DoorstepDropoffSDK
 
 @objc(DoorstepAI)
-class DoorstepAIBridge: NSObject {
+class DoorstepAIBridge: RCTEventEmitter {
     @objc
-    static func requiresMainQueueSetup() -> Bool {
+    override static func requiresMainQueueSetup() -> Bool {
         return true
     }
 
+    // MARK: - Geofence session events (RCTEventEmitter)
+
+    private static let geofenceEventName = "DoorstepGeofenceSessionEvent"
+    private var geofenceObservers: [NSObjectProtocol] = []
+
+    override func supportedEvents() -> [String]! {
+        return [DoorstepAIBridge.geofenceEventName]
+    }
+
+    /// Called by RN when the first JS listener subscribes: bridge the SDK's
+    /// NotificationCenter geofence notifications to `sendEvent`.
+    override func startObserving() {
+        let center = NotificationCenter.default
+        let started = center.addObserver(
+            forName: DoorstepAI.geofenceSessionStartedNotification, object: nil, queue: .main
+        ) { [weak self] note in self?.emitGeofenceEvent(type: "STARTED", userInfo: note.userInfo) }
+        let stopped = center.addObserver(
+            forName: DoorstepAI.geofenceSessionStoppedNotification, object: nil, queue: .main
+        ) { [weak self] note in self?.emitGeofenceEvent(type: "STOPPED", userInfo: note.userInfo) }
+        geofenceObservers = [started, stopped]
+    }
+
+    /// Called by RN when the last JS listener unsubscribes.
+    override func stopObserving() {
+        let center = NotificationCenter.default
+        geofenceObservers.forEach { center.removeObserver($0) }
+        geofenceObservers.removeAll()
+    }
+
+    private func emitGeofenceEvent(type: String, userInfo: [AnyHashable: Any]?) {
+        let deliveryId = (userInfo?["deliveryId"] as? String) ?? ""
+        let reason = (userInfo?["reason"] as? String) ?? ""
+        sendEvent(withName: DoorstepAIBridge.geofenceEventName,
+                  body: ["deliveryId": deliveryId, "type": type, "reason": reason])
+    }
+
     @objc
     func enableDevMode(_ apiKey: NSString,
                        resolver resolve: @escaping RCTPromiseResolveBlock,
@@ -221,11 +257,13 @@ class DoorstepAIBridge: NSObject {
     @objc
     func newEvent(_ eventName: NSString,
                   deliveryId: NSString,
+                  timestamp: Any?,
                   resolver resolve: @escaping RCTPromiseResolveBlock,
                   rejecter reject: @escaping RCTPromiseRejectBlock) {
         Task {
             do {
-                try await DoorstepAI.newEvent(eventName: eventName as String, deliveryId: deliveryId as String)
+                let ts = (timestamp as? NSNumber)?.doubleValue
+                try await DoorstepAI.newEvent(eventName: eventName as String, deliveryId: deliveryId as String, timestamp: ts)
                 resolve(nil)
             } catch {
                 reject("E_NEW_EVENT", "Failed to send event: \(error.localizedDescription)", error)
@@ -270,6 +308,92 @@ class DoorstepAIBridge: NSObject {
         }
     }
 
+    // MARK: - Route geofencing
+
+    @objc
+    func startRouteGeofencing(_ stops: NSArray,
+                              options: NSDictionary?,
+                              resolver resolve: @escaping RCTPromiseResolveBlock,
+                              rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let parsed: [DeliveryStop] = (stops as? [[String: Any]] ?? []).compactMap { parseDeliveryStop($0) }
+        if parsed.isEmpty {
+            reject("E_ROUTE_GEOFENCING", "startRouteGeofencing requires at least one valid stop (deliveryId + latitude + longitude)", nil)
+            return
+        }
+        let opts = parseRouteOptions(options)
+        DispatchQueue.main.async {
+            DoorstepAI.startRouteGeofencing(stops: parsed, options: opts)
+            resolve(nil)
+        }
+    }
+
+    @objc
+    func stopRouteGeofencing(_ resolve: @escaping RCTPromiseResolveBlock,
+                             rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            DoorstepAI.stopRouteGeofencing()
+            resolve(nil)
+        }
+    }
+
+    @objc
+    func resumeRouteGeofencingIfNeeded(_ resolve: @escaping RCTPromiseResolveBlock,
+                                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            DoorstepAI.resumeRouteGeofencingIfNeeded()
+            resolve(nil)
+        }
+    }
+
+    @objc
+    func getMonitoredStops(_ resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        DispatchQueue.main.async {
+            resolve(DoorstepAI.monitoredStops.map { self.serializeStop($0) })
+        }
+    }
+
+    private func parseDeliveryStop(_ raw: [String: Any]) -> DeliveryStop? {
+        guard let deliveryId = raw["deliveryId"] as? String,
+              let latitude = (raw["latitude"] as? NSNumber)?.doubleValue,
+              let longitude = (raw["longitude"] as? NSNumber)?.doubleValue else {
+            return nil
+        }
+        return DeliveryStop(
+            deliveryId: deliveryId,
+            address: (raw["address"] as? String) ?? "",
+            latitude: latitude,
+            longitude: longitude,
+            radiusMeters: (raw["radiusMeters"] as? NSNumber)?.doubleValue,
+            customerId: raw["customerId"] as? String,
+            driverId: raw["driverId"] as? String
+        )
+    }
+
+    private func parseRouteOptions(_ raw: NSDictionary?) -> RouteGeofenceOptions {
+        guard let o = raw as? [String: Any] else { return RouteGeofenceOptions() }
+        // iOS RouteGeofenceOptions has no `manualForeground` (OS owns background region
+        // monitoring); a JS-supplied manualForeground is intentionally ignored here.
+        return RouteGeofenceOptions(
+            defaultRadiusMeters: (o["defaultRadiusMeters"] as? NSNumber)?.doubleValue ?? 250,
+            timeoutSeconds: (o["timeoutSeconds"] as? NSNumber)?.doubleValue,
+            autoStopAfterDropoffSeconds: (o["autoStopAfterDropoffSeconds"] as? NSNumber)?.doubleValue
+        )
+    }
+
+    private func serializeStop(_ s: DeliveryStop) -> [String: Any] {
+        var m: [String: Any] = [
+            "deliveryId": s.deliveryId,
+            "address": s.address,
+            "latitude": s.latitude,
+            "longitude": s.longitude
+        ]
+        if let r = s.radiusMeters { m["radiusMeters"] = r }
+        if let c = s.customerId { m["customerId"] = c }
+        if let d = s.driverId { m["driverId"] = d }
+        return m
+    }
+
     private func parseCoordinates(_ raw: NSDictionary?) -> LatLngObject? {
         guard let coordinates = raw as? [String: Any],
               let lat = coordinates["lat"] as? Double,