@doorstepai/dropoff-sdk 1.0.31 → 2.0.0

package/android/build.gradle

@@ -86,7 +86,8 @@ 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:1.0.18")
+  implementation("ai.doorstep.com:doorstepai-dropoff-sdk:2.0.0")
   api "org.jetbrains.kotlinx:kotlinx-serialization-json:1.5.1"
 }
 
+ 

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

@@ -8,6 +8,7 @@ import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
 import com.doorstepai.sdks.tracking.DoorstepAI
 import com.doorstepai.sdks.tracking.AddressType
+import com.doorstepai.sdks.tracking.DropoffType
 import com.facebook.react.bridge.ReadableMap
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.CoroutineScope
@@ -37,9 +38,14 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun startDeliveryByPlaceID(placeID: String, deliveryId: String, promise: Promise) {
+  fun startDeliveryByPlaceID(
+    placeID: String,
+    deliveryId: String,
+    timeoutSeconds: Double?,
+    promise: Promise
+  ) {
     try {
-      DoorstepAI.startDeliveryByPlaceID(placeID, deliveryId) { result ->
+      DoorstepAI.startDeliveryByPlaceID(placeID, deliveryId, timeoutSeconds) { result ->
         result.onSuccess { sessionId ->
           promise.resolve(sessionId)
         }.onFailure { error ->
@@ -52,9 +58,14 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
   }
 
   @ReactMethod
-  fun startDeliveryByPlusCode(plusCode: String, deliveryId: String, promise: Promise) {
+  fun startDeliveryByPlusCode(
+    plusCode: String,
+    deliveryId: String,
+    timeoutSeconds: Double?,
+    promise: Promise
+  ) {
     try {
-      DoorstepAI.startDeliveryByPlusCode(plusCode, deliveryId) { result ->
+      DoorstepAI.startDeliveryByPlusCode(plusCode, deliveryId, timeoutSeconds) { result ->
         result.onSuccess { sessionId ->
           promise.resolve(sessionId)
         }.onFailure { error ->
@@ -66,10 +77,53 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun startDeliveryByAddressString(
+    address: String,
+    deliveryId: String,
+    timeoutSeconds: Double?,
+    promise: Promise
+  ) {
+    try {
+      DoorstepAI.startDeliveryByAddressString(address, deliveryId, timeoutSeconds) { result ->
+        result.onSuccess { message ->
+          promise.resolve(message)
+        }.onFailure { error ->
+          promise.reject("DELIVERY_ERROR", error.message ?: "Promise Rejection: Failed to start delivery by address string")
+        }
+      }
+    } catch (e: Exception) {
+      promise.reject("DELIVERY_ERROR", e.message ?: "Failed to start delivery by address string")
+    }
+  }
+
+  @ReactMethod
+  fun startDeliveryByLatLng(
+    latitude: Double,
+    longitude: Double,
+    subUnit: String,
+    deliveryId: String,
+    timeoutSeconds: Double?,
+    promise: Promise
+  ) {
+    try {
+      DoorstepAI.startDeliveryByLatLng(latitude, longitude, subUnit, deliveryId, timeoutSeconds) { result ->
+        result.onSuccess { message ->
+          promise.resolve(message)
+        }.onFailure { error ->
+          promise.reject("DELIVERY_ERROR", error.message ?: "Promise Rejection: Failed to start delivery by lat/lng")
+        }
+      }
+    } catch (e: Exception) {
+      promise.reject("DELIVERY_ERROR", e.message ?: "Failed to start delivery by lat/lng")
+    }
+  }
+
   @ReactMethod
   fun startDeliveryByAddress(
     addressMap: ReadableMap,
     deliveryId: String,
+    timeoutSeconds: Double?,
     promise: Promise
   ) {
     try {
@@ -89,7 +143,7 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
         postalCode = postalCode
       )
 
-      DoorstepAI.startDeliveryByAddressType(address, deliveryId) { result ->
+      DoorstepAI.startDeliveryByAddressType(address, deliveryId, timeoutSeconds) { result ->
         result.onSuccess { sessionId ->
           promise.resolve(sessionId)
         }.onFailure { error ->
@@ -111,6 +165,26 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
     }
   }
 
+  @ReactMethod
+  fun markDropoff(deliveryId: String, dropoffType: String, promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val type = when (dropoffType.uppercase()) {
+          "POD" -> DropoffType.POD
+          "NON_POD" -> DropoffType.NON_POD
+          else -> {
+            promise.reject("DROP_OFF_TYPE_ERROR", "Invalid dropoff type: $dropoffType")
+            return@launch
+          }
+        }
+        DoorstepAI.markDropoff(deliveryId, type)
+        promise.resolve(true)
+      } catch (e: Exception) {
+        promise.reject("DROP_OFF_ERROR", e.message ?: "Failed to mark dropoff")
+      }
+    }
+  }
+
   @ReactMethod
   fun stopDelivery(deliveryId: String, promise: Promise) {
     try {
@@ -130,16 +204,90 @@ class DoorstepAIModule(private val reactContext: ReactApplicationContext) :
   fun enableDevMode(promise: Promise) {
     CoroutineScope(Dispatchers.IO).launch {
       try {
-        /*android.util.Log.i("DoorstepAI", "Attempting to enable dev mode...")
         val result = DoorstepAI.enableDevMode()
-        android.util.Log.i("DoorstepAI", "Dev mode enabled: $result")
-        promise.resolve(result)*/
+        promise.resolve(result)
       } catch (e: Exception) {
         promise.reject("DEV_MODE_ERROR", e.message ?: "Failed to enable dev mode")
       }
     }
   }
 
+  @ReactMethod
+  fun validateDevModeAccess(promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val result = DoorstepAI.validateDevModeAccess()
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject("DEV_MODE_VALIDATE_ERROR", e.message ?: "Failed to validate dev mode access")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun hasCachedData(promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val result = DoorstepAI.hasCachedData()
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject("HAS_CACHED_DATA_ERROR", e.message ?: "Failed to check cached data")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun waitForCachedDataCompletion(promise: Promise) {
+    CoroutineScope(Dispatchers.IO).launch {
+      try {
+        val result = DoorstepAI.waitForCachedDataCompletion()
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject("WAIT_CACHED_DATA_ERROR", e.message ?: "Failed while waiting for cached data completion")
+      }
+    }
+  }
+
+  @ReactMethod
+  fun isCacheProcessingInProgress(promise: Promise) {
+    try {
+      val result = DoorstepAI.isCacheProcessingInProgress()
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("CACHE_PROCESSING_STATUS_ERROR", e.message ?: "Failed to check cache processing status")
+    }
+  }
+
+  @ReactMethod
+  fun hasPendingNetworkRequests(promise: Promise) {
+    try {
+      val result = DoorstepAI.hasPendingNetworkRequests()
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("PENDING_NETWORK_REQUESTS_ERROR", e.message ?: "Failed to check pending network requests")
+    }
+  }
+
+  @ReactMethod
+  fun getPendingNetworkRequestsCount(promise: Promise) {
+    try {
+      val result = DoorstepAI.getPendingNetworkRequestsCount()
+      promise.resolve(result)
+    } catch (e: Exception) {
+      promise.reject("PENDING_NETWORK_REQUESTS_COUNT_ERROR", e.message ?: "Failed to get pending network requests count")
+    }
+  }
+
+  @ReactMethod
+  fun disableDevMode(promise: Promise) {
+    try {
+      DoorstepAI.disableDevMode()
+      promise.resolve(true)
+    } catch (e: Exception) {
+      promise.reject("DEV_MODE_DISABLE_ERROR", e.message ?: "Failed to disable dev mode")
+    }
+  }
+
   companion object {
     const val NAME = "DoorstepAI"
   }

package/ios/DoorstepAI.mm

@@ -3,25 +3,50 @@
 @interface RCT_EXTERN_MODULE(DoorstepAI, NSObject)
 
 RCT_EXTERN_METHOD(setApiKey:(NSString *)apiKey)
-RCT_EXTERN_METHOD(setDevMode:(BOOL)devModeEnabled)
+RCT_EXTERN_METHOD(enableDevMode:(NSString *)apiKey
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(startDeliveryByPlaceID:(NSString *)placeID
                  deliveryId:(NSString *)deliveryId
+                 timeoutSeconds:(NSNumber *)timeoutSeconds
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(startDeliveryByPlusCode:(NSString *)plusCode
                  deliveryId:(NSString *)deliveryId
+                 timeoutSeconds:(NSNumber *)timeoutSeconds
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(startDeliveryByAddress:(NSDictionary *)address
                  deliveryId:(NSString *)deliveryId
+                 timeoutSeconds:(NSNumber *)timeoutSeconds
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startDeliveryByAddressString:(NSString *)address
+                 deliveryId:(NSString *)deliveryId
+                 timeoutSeconds:(NSNumber *)timeoutSeconds
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(startDeliveryByLatLng:(nonnull NSNumber *)latitude
+                 longitude:(nonnull NSNumber *)longitude
+                 subUnit:(NSString *)subUnit
+                 deliveryId:(NSString *)deliveryId
+                 timeoutSeconds:(NSNumber *)timeoutSeconds
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(newEvent:(NSString *)eventName
                  deliveryId:(NSString *)deliveryId
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(markDropoff:(NSString *)deliveryId
+                 dropoffType:(NSString *)dropoffType
+                 resolver:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(stopDelivery:(NSString *)deliveryId
                  resolver:(RCTPromiseResolveBlock)resolve
                  rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(hasCachedData:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(waitForCacheDataCompletion:(RCTPromiseResolveBlock)resolve
+                 rejecter:(RCTPromiseRejectBlock)reject)
 
 @end 

package/ios/DoorstepAI.swift

@@ -24,8 +24,13 @@ class DoorstepAIBridge: NSObject {
     }
 
     @objc
-    func setDevMode(_ devModeEnabled: Bool) {
-        DoorstepAI.enableDevMode()
+    func enableDevMode(_ apiKey: NSString,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            await DoorstepAI.enableDevMode(apiKey: apiKey as String)
+            resolve(nil)
+        }
     }
 
     @objc
@@ -36,12 +41,18 @@ class DoorstepAIBridge: NSObject {
     @objc
     func startDeliveryByPlaceID(_ placeID: NSString,
                                 deliveryId: NSString,
+                                timeoutSeconds: NSNumber?,
                                 resolver resolve: @escaping RCTPromiseResolveBlock,
                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
         // Use Swift's concurrency support to call the async method.
         Task {
             do {
-                try await DoorstepAI.startDeliveryByPlaceID(placeID: placeID as String, deliveryId: deliveryId as String)
+                let timeout = timeoutSeconds?.doubleValue
+                try await DoorstepAI.startDeliveryByPlaceID(
+                    placeID: placeID as String,
+                    deliveryId: deliveryId as String,
+                    timeoutSeconds: timeout
+                )
                 resolve(nil)
             } catch {
                 reject("E_START_DELIVERY", "Failed to start delivery by Place ID: \(error.localizedDescription)", error)
@@ -52,11 +63,17 @@ class DoorstepAIBridge: NSObject {
     @objc
     func startDeliveryByPlusCode(_ plusCode: NSString,
                                  deliveryId: NSString,
+                                 timeoutSeconds: NSNumber?,
                                  resolver resolve: @escaping RCTPromiseResolveBlock,
                                  rejecter reject: @escaping RCTPromiseRejectBlock) {
         Task {
             do {
-                try await DoorstepAI.startDeliveryByPlusCode(plusCode: plusCode as String, deliveryId: deliveryId as String)
+                let timeout = timeoutSeconds?.doubleValue
+                try await DoorstepAI.startDeliveryByPlusCode(
+                    plusCode: plusCode as String,
+                    deliveryId: deliveryId as String,
+                    timeoutSeconds: timeout
+                )
                 resolve(nil)
             } catch {
                 reject("E_START_DELIVERY", "Failed to start delivery by Plus Code: \(error.localizedDescription)", error)
@@ -64,9 +81,56 @@ class DoorstepAIBridge: NSObject {
         }
     }
 
+    @objc
+    func startDeliveryByAddressString(_ address: NSString,
+                                      deliveryId: NSString,
+                                      timeoutSeconds: NSNumber?,
+                                      resolver resolve: @escaping RCTPromiseResolveBlock,
+                                      rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let timeout = timeoutSeconds?.doubleValue
+                try await DoorstepAI.startDeliveryByAddressString(
+                    address: address as String,
+                    deliveryId: deliveryId as String,
+                    timeoutSeconds: timeout
+                )
+                resolve(nil)
+            } catch {
+                reject("E_START_DELIVERY", "Failed to start delivery by Address String: \(error.localizedDescription)", error)
+            }
+        }
+    }
+
+    @objc
+    func startDeliveryByLatLng(_ latitude: NSNumber,
+                               longitude: NSNumber,
+                               subUnit: NSString,
+                               deliveryId: NSString,
+                               timeoutSeconds: NSNumber?,
+                               resolver resolve: @escaping RCTPromiseResolveBlock,
+                               rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let timeout = timeoutSeconds?.doubleValue
+                try await DoorstepAI.startDeliveryByLatLng(
+                    latitude: latitude.doubleValue,
+                    longitude: longitude.doubleValue,
+                    subUnit: subUnit as String,
+                    deliveryId: deliveryId as String,
+                    timeoutSeconds: timeout
+                )
+                resolve(nil)
+            } catch {
+                reject("E_START_DELIVERY", "Failed to start delivery by LatLng: \(error.localizedDescription)", error)
+            }
+        }
+    }
+
     @objc
     func startDeliveryByAddress(_ address: [String: Any],
                                 deliveryId: NSString,
+                                timeoutSeconds: NSNumber?,
                                 resolver resolve: @escaping RCTPromiseResolveBlock,
                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
         Task {
@@ -89,7 +153,12 @@ class DoorstepAIBridge: NSObject {
                                             administrativeAreaLevel1: administrativeAreaLevel1,
                                             postalCode: postalCode)
 
-                try await DoorstepAI.startDeliveryByAddressType(address: addressStruct, deliveryId: deliveryId as String)
+                let timeout = timeoutSeconds?.doubleValue
+                try await DoorstepAI.startDeliveryByAddressType(
+                    address: addressStruct,
+                    deliveryId: deliveryId as String,
+                    timeoutSeconds: timeout
+                )
                 resolve(nil)
             } catch let error as DoorstepAIError {
                 reject("E_START_DELIVERY", "Failed to start delivery by address: \(error.localizedDescription)", error)
@@ -114,6 +183,32 @@ class DoorstepAIBridge: NSObject {
         }
     }
 
+    @objc
+    func markDropoff(_ deliveryId: NSString,
+                     dropoffType: NSString,
+                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            do {
+                let normalized = (dropoffType as String).lowercased()
+                let type: DropoffType
+                switch normalized {
+                case "pod":
+                    type = .pod
+                case "non_pod":
+                    type = .non_pod
+                default:
+                    reject("E_DROP_OFF_TYPE", "Invalid dropoff type: \(dropoffType)", nil)
+                    return
+                }
+                try await DoorstepAI.markDropoff(deliveryId: deliveryId as String, dropoffType: type)
+                resolve(nil)
+            } catch {
+                reject("E_DROP_OFF", "Failed to mark dropoff: \(error.localizedDescription)", error)
+            }
+        }
+    }
+
     @objc
     func stopDelivery(_ deliveryId: NSString,
                       resolver resolve: @escaping RCTPromiseResolveBlock,
@@ -125,4 +220,19 @@ class DoorstepAIBridge: NSObject {
         }
     }
 
+    @objc
+    func hasCachedData(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(DoorstepAI.hasCachedData())
+    }
+
+    @objc
+    func waitForCacheDataCompletion(_ resolve: @escaping RCTPromiseResolveBlock,
+                                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        Task {
+            let result = await DoorstepAI.waitForCacheDataCompletion()
+            resolve(result)
+        }
+    }
+
 }

package/ios/DoorstepDropoffSDK.xcframework/Info.plist

@@ -10,15 +10,18 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>DoorstepDropoffSDK.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>
@@ -26,18 +29,15 @@
 			<key>DebugSymbolsPath</key>
 			<string>dSYMs</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>DoorstepDropoffSDK.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>