@doorstepai/dropoff-sdk-capacitor 1.0.0

package/android/src/main/java/ai/doorstep/dropoffsdk/capacitor/DoorstepAIDropoffSDKPlugin.kt

@@ -0,0 +1,291 @@
+package ai.doorstep.dropoffsdk.capacitor
+
+import android.Manifest
+import android.util.Log
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+
+import com.doorstepai.sdks.tracking.AddressType
+import com.doorstepai.sdks.tracking.DoorstepAI
+import com.doorstepai.sdks.tracking.DropoffType
+import com.doorstepai.sdks.tracking.LatLngObject
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@CapacitorPlugin(
+    name = "DoorstepAIDropoffSDK",
+    permissions = [
+        Permission(
+            alias = "location",
+            strings = [
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+            ],
+        ),
+        Permission(
+            alias = "activity",
+            strings = [Manifest.permission.ACTIVITY_RECOGNITION],
+        ),
+    ],
+)
+class DoorstepAIDropoffSDKPlugin : Plugin() {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    override fun load() {
+        super.load()
+        Log.d(TAG, "load(): plugin attached, ready for calls")
+    }
+
+    override fun handleOnDestroy() {
+        scope.cancel()
+        super.handleOnDestroy()
+    }
+
+    private fun ok(method: String, call: PluginCall) {
+        Log.d(TAG, "$method: resolved")
+        call.resolve()
+    }
+
+    private fun fail(method: String, call: PluginCall, code: String, message: String) {
+        Log.e(TAG, "$method: rejected code=$code message=$message")
+        call.reject(message, code)
+    }
+
+    companion object {
+        private const val TAG = "DoorstepAICapacitor"
+    }
+
+    @PluginMethod
+    fun init(call: PluginCall) {
+        val notificationTitle = call.getString("notificationTitle")
+        val notificationText = call.getString("notificationText")
+        Log.d(TAG, "init: title=$notificationTitle text=$notificationText")
+        val ctx = context
+        if (ctx == null) {
+            call.reject("context missing", "BAD_ARGS")
+            return
+        }
+        try {
+            DoorstepAI.init(ctx, notificationTitle, notificationText) { sdkResult ->
+                sdkResult.onSuccess {
+                    call.resolve()
+                }.onFailure { error ->
+                    call.reject(error.message ?: "Failed to initialize DoorstepAI", "INIT_ERROR")
+                }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to initialize DoorstepAI", "INIT_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun setApiKey(call: PluginCall) {
+        val key = call.getString("key") ?: return call.reject("key missing", "BAD_ARGS")
+        Log.d(TAG, "setApiKey: key=${key.take(6)}…(${key.length} chars)")
+        try {
+            DoorstepAI.setAPIKey(key)
+            ok("setApiKey", call)
+        } catch (e: Exception) {
+            fail("setApiKey", call, "SDK_ERR", e.localizedMessage ?: "setApiKey failed")
+        }
+    }
+
+    @PluginMethod
+    fun startDeliveryByPlaceID(call: PluginCall) {
+        val placeID = call.getString("placeID")
+        val deliveryId = call.getString("deliveryId")
+        val timeoutSeconds = call.getDouble("timeoutSeconds")
+        Log.d(TAG, "startDeliveryByPlaceID: placeID=$placeID deliveryId=$deliveryId timeout=$timeoutSeconds")
+        if (placeID == null || deliveryId == null) {
+            return call.reject("placeID or deliveryId missing", "BAD_ARGS")
+        }
+        try {
+            DoorstepAI.startDeliveryByPlaceID(placeID, deliveryId, timeoutSeconds) { sdkResult ->
+                sdkResult.onSuccess { call.resolve() }
+                    .onFailure { error ->
+                        call.reject(error.message ?: "Failed to start delivery by Place ID", "DELIVERY_ERROR")
+                    }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to start delivery by Place ID", "DELIVERY_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun startDeliveryByPlusCode(call: PluginCall) {
+        val plusCode = call.getString("plusCode")
+        val deliveryId = call.getString("deliveryId")
+        val timeoutSeconds = call.getDouble("timeoutSeconds")
+        if (plusCode == null || deliveryId == null) {
+            return call.reject("plusCode or deliveryId missing", "BAD_ARGS")
+        }
+        try {
+            DoorstepAI.startDeliveryByPlusCode(plusCode, deliveryId, timeoutSeconds) { sdkResult ->
+                sdkResult.onSuccess { call.resolve() }
+                    .onFailure { error ->
+                        call.reject(error.message ?: "Failed to start delivery by Plus Code", "DELIVERY_ERROR")
+                    }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to start delivery by Plus Code", "DELIVERY_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun startDeliveryByAddress(call: PluginCall) = startDeliveryByAddressTypeImpl(call)
+
+    @PluginMethod
+    fun startDeliveryByAddressType(call: PluginCall) = startDeliveryByAddressTypeImpl(call)
+
+    private fun startDeliveryByAddressTypeImpl(call: PluginCall) {
+        val addrObj = call.getObject("address")
+        val deliveryId = call.getString("deliveryId")
+        val timeoutSeconds = call.getDouble("timeoutSeconds")
+        val coordinates = parseCoordinates(call.getObject("coordinates"))
+
+        if (addrObj == null
+            || deliveryId == null
+            || !addrObj.has("streetNumber")
+            || !addrObj.has("route")
+            || !addrObj.has("locality")
+            || !addrObj.has("administrativeAreaLevel1")
+            || !addrObj.has("postalCode")
+        ) {
+            return call.reject("address map missing fields or deliveryId missing", "BAD_ARGS")
+        }
+
+        try {
+            val addressType = AddressType(
+                streetNumber = addrObj.getString("streetNumber")!!,
+                route = addrObj.getString("route")!!,
+                subPremise = addrObj.optString("subPremise", ""),
+                locality = addrObj.getString("locality")!!,
+                administrativeAreaLevel1 = addrObj.getString("administrativeAreaLevel1")!!,
+                postalCode = addrObj.getString("postalCode")!!,
+            )
+            DoorstepAI.startDeliveryByAddressType(addressType, deliveryId, coordinates, timeoutSeconds) { sdkResult ->
+                sdkResult.onSuccess { call.resolve() }
+                    .onFailure { error ->
+                        call.reject(error.message ?: "Failed to start delivery by address", "DELIVERY_ERROR")
+                    }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to start delivery by address", "DELIVERY_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun startDeliveryByAddressString(call: PluginCall) {
+        val address = call.getString("address")
+        val deliveryId = call.getString("deliveryId")
+        val timeoutSeconds = call.getDouble("timeoutSeconds")
+        val coordinates = parseCoordinates(call.getObject("coordinates"))
+        if (address == null || deliveryId == null) {
+            return call.reject("address or deliveryId missing", "BAD_ARGS")
+        }
+        try {
+            DoorstepAI.startDeliveryByAddressString(address, deliveryId, coordinates, timeoutSeconds) { sdkResult ->
+                sdkResult.onSuccess { call.resolve() }
+                    .onFailure { error ->
+                        call.reject(error.message ?: "Failed to start delivery by address string", "DELIVERY_ERROR")
+                    }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to start delivery by address string", "DELIVERY_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun startDeliveryByLatLng(call: PluginCall) {
+        val latitude = call.getDouble("latitude")
+        val longitude = call.getDouble("longitude")
+        val subUnit = call.getString("subUnit") ?: ""
+        val deliveryId = call.getString("deliveryId")
+        val timeoutSeconds = call.getDouble("timeoutSeconds")
+        Log.d(TAG, "startDeliveryByLatLng: lat=$latitude lng=$longitude subUnit='$subUnit' deliveryId=$deliveryId timeout=$timeoutSeconds")
+        if (latitude == null || longitude == null || deliveryId == null) {
+            return call.reject("latitude, longitude or deliveryId missing", "BAD_ARGS")
+        }
+        try {
+            DoorstepAI.startDeliveryByLatLng(latitude, longitude, subUnit, deliveryId, timeoutSeconds) { sdkResult ->
+                sdkResult.onSuccess { call.resolve() }
+                    .onFailure { error ->
+                        call.reject(error.message ?: "Failed to start delivery by LatLng", "DELIVERY_ERROR")
+                    }
+            }
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to start delivery by LatLng", "DELIVERY_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun markDropoff(call: PluginCall) {
+        val deliveryId = call.getString("deliveryId")
+        val dropoffTypeStr = call.getString("dropoffType")
+        Log.d(TAG, "markDropoff: deliveryId=$deliveryId type=$dropoffTypeStr")
+        if (deliveryId == null || dropoffTypeStr == null) {
+            return call.reject("deliveryId or dropoffType missing", "BAD_ARGS")
+        }
+        val dropoffType = when (dropoffTypeStr) {
+            "pod" -> DropoffType.POD
+            "non_pod" -> DropoffType.NON_POD
+            else -> return call.reject("dropoffType must be 'pod' or 'non_pod'", "BAD_ARGS")
+        }
+        scope.launch {
+            try {
+                withContext(Dispatchers.IO) {
+                    DoorstepAI.markDropoff(deliveryId, dropoffType)
+                }
+                call.resolve()
+            } catch (e: Exception) {
+                call.reject(e.message ?: "Failed to mark dropoff", "SDK_ERR")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun newEvent(call: PluginCall) {
+        val eventName = call.getString("eventName")
+        val deliveryId = call.getString("deliveryId")
+        Log.d(TAG, "newEvent: eventName=$eventName deliveryId=$deliveryId")
+        if (eventName == null || deliveryId == null) {
+            return call.reject("eventName or deliveryId missing", "BAD_ARGS")
+        }
+        try {
+            DoorstepAI.newEvent(eventName, deliveryId) { /* result swallowed in Flutter parity */ }
+            call.resolve()
+        } catch (e: Exception) {
+            call.reject(e.message ?: "Failed to save event", "EVENT_CREATION_ERROR")
+        }
+    }
+
+    @PluginMethod
+    fun stopDelivery(call: PluginCall) {
+        val deliveryId = call.getString("deliveryId") ?: return call.reject("deliveryId missing", "BAD_ARGS")
+        Log.d(TAG, "stopDelivery: deliveryId=$deliveryId")
+        try {
+            DoorstepAI.stopDelivery(deliveryId)
+            ok("stopDelivery", call)
+        } catch (e: Exception) {
+            fail("stopDelivery", call, "DELIVERY_STOP_ERROR", e.message ?: "Failed to stop delivery")
+        }
+    }
+
+    private fun parseCoordinates(obj: JSObject?): LatLngObject? {
+        if (obj == null) return null
+        val lat = obj.optDouble("lat", Double.NaN)
+        val lng = obj.optDouble("lng", Double.NaN)
+        if (lat.isNaN() || lng.isNaN()) return null
+        return LatLngObject(lat = lat, lng = lng)
+    }
+}