react-native-usesense 1.0.0 → 2.1.0

package/android/build.gradle

@@ -35,8 +35,13 @@ repositories {
 dependencies {
     implementation "com.facebook.react:react-native:+"
 
-    // UseSense Android SDK
-    implementation "ai.usesense:sdk:1.0.0"
+    // UseSense Android SDK — published to Maven Central at
+    // central.sonatype.com/artifact/ai.usesense/sdk. Pinned to 4.3.0,
+    // the release that adds the V4 capture API + Flows runner (matches
+    // the iOS SDK 4.3.0 the plugin's podspec depends on). mavenCentral()
+    // is already in the `repositories` block above, so no custom
+    // repository declaration is needed.
+    implementation "ai.usesense:sdk:4.3.0"
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '2.0.0')}"
 }

package/android/src/main/java/com/usesense/reactnative/UseSenseFlowsModule.kt

@@ -0,0 +1,72 @@
+package com.usesense.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.usesense.sdk.flows.FlowError
+import com.usesense.sdk.flows.FlowOutcome
+import com.usesense.sdk.flows.FlowRunResult
+import com.usesense.sdk.flows.FlowRunState
+import com.usesense.sdk.flows.FlowsCallback
+import com.usesense.sdk.flows.UseSenseFlows
+
+/**
+ * React Native bridge for the UseSense Android Flows runner.
+ *
+ * Exposes a single JS-callable method, `runFlow`, that forwards into the
+ * native `UseSenseFlows.run(activity, flowRunId, sdkToken, callback)` entry
+ * point and resolves the Promise with a `FlowRunResult` map. On failure the
+ * Promise rejects with `FlowError.Code.wire` as the JS error code, mirroring
+ * the taxonomy host apps catch on every other surface.
+ *
+ * Sits alongside `UseSenseModule` (Sessions); the existing module is
+ * untouched. Sessions and Flows coexist — host apps pick one per call.
+ */
+class UseSenseFlowsModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "UseSenseFlowsModule"
+
+    @ReactMethod
+    fun runFlow(flowRunId: String?, sdkToken: String?, apiBaseUrl: String?, promise: Promise) {
+        if (flowRunId.isNullOrEmpty() || sdkToken.isNullOrEmpty()) {
+            promise.reject("unknown", "flowRunId and sdkToken are required")
+            return
+        }
+        val activity = reactContext.currentActivity ?: run {
+            promise.reject("unknown", "No current activity to launch from")
+            return
+        }
+        val baseUrl = apiBaseUrl ?: "https://api.usesense.ai"
+
+        val callback = object : FlowsCallback {
+            override fun onResult(result: FlowRunResult) {
+                val map = Arguments.createMap().apply {
+                    putString("flowRunId", result.flowRunId)
+                    putString("state", stateWire(result.state))
+                    val outcomeStr = result.outcome?.let { outcomeWire(it) }
+                    if (outcomeStr != null) putString("outcome", outcomeStr)
+                    else putNull("outcome")
+                }
+                promise.resolve(map)
+            }
+
+            override fun onError(error: FlowError) {
+                promise.reject(error.code.wire, error.message)
+            }
+        }
+
+        UseSenseFlows.run(
+            activity = activity,
+            flowRunId = flowRunId,
+            sdkToken = sdkToken,
+            callback = callback,
+            apiBaseUrl = baseUrl,
+        )
+    }
+
+    private fun stateWire(state: FlowRunState): String = state.wire
+    private fun outcomeWire(outcome: FlowOutcome): String = outcome.wire
+}

package/android/src/main/java/com/usesense/reactnative/UseSenseModule.kt

@@ -32,15 +32,29 @@ class UseSenseModule(private val reactContext: ReactApplicationContext) :
             else -> UseSenseEnvironment.AUTO
         }
 
+        // `gatewayKey` is intentionally NOT passed to UseSenseConfig.
+        // It existed on the v1.x Android SDK but was removed in v4.0
+        // when the Cloudflare Worker proxy took over gateway
+        // responsibilities server-side. The JS API no longer exposes
+        // the field; any stale JS callers that still pass it will
+        // have the key silently ignored.
+        // v4.2: Optional on-device antispoof classifier flag.
+        val antispoofOnDeviceEnabled = configMap.hasKey("antispoofOnDeviceEnabled") &&
+            configMap.getBoolean("antispoofOnDeviceEnabled")
+        // LiveSense v4 capture flow opt-in.
+        val liveSenseV4Enabled = configMap.hasKey("liveSenseV4Enabled") &&
+            configMap.getBoolean("liveSenseV4Enabled")
+
         val config = UseSenseConfig(
             apiKey = apiKey,
             environment = environment,
             baseUrl = configMap.getString("baseUrl") ?: UseSenseConfig.DEFAULT_BASE_URL,
-            gatewayKey = configMap.getString("gatewayKey"),
             branding = branding,
             googleCloudProjectNumber = if (configMap.hasKey("googleCloudProjectNumber"))
                 configMap.getDouble("googleCloudProjectNumber").toLong()
             else UseSenseConfig.DEFAULT_GOOGLE_CLOUD_PROJECT_NUMBER,
+            antispoofOnDeviceEnabled = antispoofOnDeviceEnabled,
+            liveSenseV4Enabled = liveSenseV4Enabled,
         )
 
         val context = reactContext.applicationContext
@@ -107,6 +121,73 @@ class UseSenseModule(private val reactContext: ReactApplicationContext) :
         })
     }
 
+    /**
+     * Phase 1 ticket R-1: passthrough to UseSense.startV4Verification.
+     *
+     * The native SDK validates the request, launches the v4 capture
+     * activity, and resolves the promise with the opaque verdict.
+     */
+    @ReactMethod
+    fun startV4Verification(requestMap: ReadableMap, promise: Promise) {
+        val activity = currentActivity ?: run {
+            promise.reject("NO_ACTIVITY", "No current activity available")
+            return
+        }
+        val sessionId = requestMap.getString("sessionId")
+            ?: return promise.reject("INVALID_REQUEST", "sessionId is required")
+        val sessionToken = requestMap.getString("sessionToken")
+            ?: return promise.reject("INVALID_REQUEST", "sessionToken is required")
+        val nonce = requestMap.getString("nonce")
+            ?: return promise.reject("INVALID_REQUEST", "nonce is required")
+        val apiBaseUrl = requestMap.getString("apiBaseUrl")
+            ?: return promise.reject("INVALID_REQUEST", "apiBaseUrl is required")
+        val environment = requestMap.getString("environment") ?: "production"
+        val displayName = if (requestMap.hasKey("displayName")) requestMap.getString("displayName") else null
+        val brandColor = if (requestMap.hasKey("brandPrimaryColor"))
+            runCatching { android.graphics.Color.parseColor(requestMap.getString("brandPrimaryColor")) }.getOrNull()
+        else null
+
+        val request = com.usesense.sdk.api.V4VerificationRequest(
+            sessionId = sessionId,
+            sessionToken = sessionToken,
+            nonce = nonce,
+            apiBaseUrl = apiBaseUrl,
+            environment = environment,
+            brandPrimaryColor = brandColor,
+            displayName = displayName
+        )
+
+        UseSense.startV4Verification(activity, request, object : com.usesense.sdk.api.V4VerificationCallback {
+            override fun onComplete(verdict: com.usesense.sdk.api.V4Verdict) {
+                val map = Arguments.createMap().apply {
+                    putString("session_id", verdict.sessionId)
+                    putString("verdict", verdict.verdict.name.lowercase())
+                    putString("confidence", verdict.confidence.name.lowercase())
+                    putString("assurance_level_achieved", verdict.assuranceLevelAchieved)
+                    putString("capture_channel", "rn")
+                    if (verdict.matchSenseEmbeddingId != null) {
+                        putString("match_sense_embedding_id", verdict.matchSenseEmbeddingId)
+                    } else {
+                        putNull("match_sense_embedding_id")
+                    }
+                    putString("timestamp", verdict.timestamp)
+                }
+                promise.resolve(map)
+            }
+            override fun onFailure(error: Throwable) {
+                promise.reject("V4_FAILED", error.message ?: "v4 verification failed", error)
+            }
+            override fun onPhaseChange(phase: com.usesense.sdk.api.V4Phase) {
+                val map = Arguments.createMap().apply {
+                    putString("type", "V4_PHASE_CHANGE")
+                    putString("phase", phase.name.lowercase())
+                    putDouble("timestamp", System.currentTimeMillis().toDouble())
+                }
+                sendEvent("UseSenseEvent", map)
+            }
+        })
+    }
+
     @ReactMethod
     fun subscribeToEvents() {
         eventUnsubscribe?.invoke()

package/android/src/main/java/com/usesense/reactnative/UseSensePackage.kt

@@ -8,7 +8,12 @@ import com.facebook.react.uimanager.ViewManager
 class UseSensePackage : ReactPackage {
 
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(UseSenseModule(reactContext))
+        return listOf(
+            UseSenseModule(reactContext),
+            // Slice 5d: Flows runner module (parallel surface to Sessions, not
+            // a replacement). Host apps pick one per call.
+            UseSenseFlowsModule(reactContext),
+        )
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/ios/UseSenseFlowsModule.m

@@ -0,0 +1,20 @@
+#import <React/RCTBridgeModule.h>
+
+// Bridging header for the Flows runner module. Single JS-callable method:
+// runFlow(flowRunId, sdkToken, apiBaseUrl?). The apiBaseUrl parameter is
+// nullable from JS — pass `null` (or omit, since the JS wrapper supplies a
+// default) and the native side falls back to https://api.usesense.ai.
+@interface RCT_EXTERN_MODULE(UseSenseFlowsModule, NSObject)
+
+RCT_EXTERN_METHOD(runFlow:(NSString *)flowRunId
+                  sdkToken:(NSString *)sdkToken
+                  apiBaseUrl:(NSString * _Nullable)apiBaseUrl
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/UseSenseFlowsModule.swift

@@ -0,0 +1,111 @@
+import Foundation
+import React
+import UseSenseSDK
+
+/// React Native bridge for the UseSense iOS Flows runner.
+///
+/// Exposes a single JS-callable method, `runFlow`, that forwards into the
+/// native `UseSenseFlows.run(flowRunId:sdkToken:from:completion:)` entry
+/// point and resolves the Promise with a `FlowRunResult` map. On failure the
+/// Promise rejects with the SDK's `FlowError.Code.rawValue` as the JS error
+/// code, mirroring the taxonomy host apps catch on every other surface.
+///
+/// Sits alongside `UseSenseModule` (Sessions); the existing module is
+/// untouched. Sessions and Flows coexist — host apps pick one per call.
+@objc(UseSenseFlowsModule)
+class UseSenseFlowsModule: NSObject {
+
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        // Presentation work happens in `runFlow` after the JS call dispatches
+        // back to main via `DispatchQueue.main`. The module itself has no
+        // initialisation that must run on the main queue.
+        return false
+    }
+
+    /// `runFlow(flowRunId, sdkToken, apiBaseUrl?, resolve, reject)` — Promise.
+    /// The SDK takes care of presentation; we just resolve when the run
+    /// reaches a terminal state.
+    @objc
+    func runFlow(_ flowRunId: String,
+                 sdkToken: String,
+                 apiBaseUrl: String?,
+                 resolver resolve: @escaping RCTPromiseResolveBlock,
+                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let baseString = apiBaseUrl ?? "https://api.usesense.ai"
+        guard let baseURL = URL(string: baseString) else {
+            reject("unknown", "Invalid apiBaseUrl: \(baseString)", nil)
+            return
+        }
+        DispatchQueue.main.async {
+            guard let presenter = Self.topViewController() else {
+                reject("unknown", "No view controller to present from", nil)
+                return
+            }
+            UseSenseFlows.run(
+                flowRunId: flowRunId,
+                sdkToken: sdkToken,
+                apiBaseURL: baseURL,
+                from: presenter
+            ) { runResult in
+                switch runResult {
+                case .success(let r):
+                    resolve([
+                        "flowRunId": r.flowRunId,
+                        "state": Self.stateWire(r.state),
+                        "outcome": r.outcome.map(Self.outcomeWire) as Any,
+                    ])
+                case .failure(let e):
+                    reject(e.code.rawValue, e.message, nil)
+                }
+            }
+        }
+    }
+
+    // MARK: - Helpers (mirror UseSenseFlowsBridge in the Flutter plugin)
+
+    private static func stateWire(_ state: FlowRunState) -> String {
+        switch state {
+        case .pending: return "pending"
+        case .inProgress: return "in_progress"
+        case .stalled: return "stalled"
+        case .awaitingReview: return "awaiting_review"
+        case .completed: return "completed"
+        case .errored: return "errored"
+        case .abandoned: return "abandoned"
+        case .cancelled: return "cancelled"
+        }
+    }
+
+    private static func outcomeWire(_ outcome: FlowOutcome) -> String {
+        switch outcome {
+        case .approve: return "APPROVE"
+        case .reject: return "REJECT"
+        case .manualReview: return "MANUAL_REVIEW"
+        }
+    }
+
+    /// Find the top-most view controller to present from. Mirrors the
+    /// pattern used elsewhere in the bridge layer; works across UIKit +
+    /// SceneDelegate apps and falls back to `keyWindow.rootViewController`.
+    private static func topViewController() -> UIViewController? {
+        var root: UIViewController?
+        if #available(iOS 13.0, *) {
+            for scene in UIApplication.shared.connectedScenes {
+                guard let windowScene = scene as? UIWindowScene else { continue }
+                if let keyWindow = windowScene.windows.first(where: { $0.isKeyWindow }) ?? windowScene.windows.first {
+                    root = keyWindow.rootViewController
+                    break
+                }
+            }
+        }
+        if root == nil {
+            root = UIApplication.shared.keyWindow?.rootViewController
+        }
+        var current = root
+        while let presented = current?.presentedViewController {
+            current = presented
+        }
+        return current
+    }
+}

package/ios/UseSenseModule.m

@@ -20,6 +20,11 @@ RCT_EXTERN_METHOD(subscribeToEvents)
 
 RCT_EXTERN_METHOD(unsubscribeFromEvents)
 
+// LiveSense v4 passthrough (R-1)
+RCT_EXTERN_METHOD(startV4Verification:(NSDictionary *)request
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(getSdkVersion)
 
 @end