react-native-usesense 1.0.0 → 2.0.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.2.1
+    // because that's the first release with the vanniktech-based
+    // Maven Central artifact shape and the terminal-screen centering
+    // fix. mavenCentral() is already in the `repositories` block above,
+    // so no custom repository declaration is needed.
+    implementation "ai.usesense:sdk:4.2.1"
 
     implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '2.0.0')}"
 }

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

@@ -32,11 +32,16 @@ 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.
         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()

package/ios/UseSenseModule.swift

@@ -2,11 +2,33 @@ import Foundation
 import React
 import UseSenseSDK
 
+/// React Native bridge for the UseSense iOS SDK.
+///
+/// Exposes five JS-callable methods — `initialize`, `startVerification`,
+/// `reset`, `isInitialized`, plus RCTEventEmitter `supportedEvents`/
+/// `startObserving`/`stopObserving` — that mirror the native SDK's
+/// public API without leaking any internal scoring data through the
+/// bridge.
+///
+/// The result payload returned from `startVerification` is the
+/// five-field redacted shape defined by the native SDK's
+/// `RedactedDecisionObject`: `sessionId`, `sessionType`, `identityId`,
+/// `decision` (`APPROVE` / `REJECT` / `MANUAL_REVIEW`), `timestamp`.
+/// Pillar scores (channel trust, liveness, matchsense risk) are
+/// intentionally NOT exposed — integrators must consume those via
+/// the signed webhook delivered to their backend, never from the
+/// client. Matches the behaviour of the native Android bridge at
+/// `android/src/main/java/com/usesense/reactnative/UseSenseModule.kt`
+/// and the Flutter plugin at `ios/Classes/UseSenseFlutterPlugin.swift`.
 @objc(UseSenseModule)
 class UseSenseModule: RCTEventEmitter {
 
+    private var client: UseSense?
+    private var eventUnsubscribe: (() -> Void)?
     private var hasListeners = false
 
+    // MARK: - RCTEventEmitter
+
     override func supportedEvents() -> [String]! {
         return ["UseSenseEvent"]
     }
@@ -20,129 +42,242 @@ class UseSenseModule: RCTEventEmitter {
     }
 
     @objc
-    func initialize(_ config: NSDictionary) {
-        guard let apiKey = config["apiKey"] as? String else {
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    // MARK: - Module methods
+
+    @objc
+    func initialize(_ config: NSDictionary,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let apiKey = config["apiKey"] as? String, !apiKey.isEmpty else {
+            reject("invalid_config", "apiKey is required", nil)
             return
         }
 
-        let environment: UseSenseEnvironment = {
-            switch config["environment"] as? String {
-            case "production": return .production
-            case "sandbox": return .sandbox
-            default: return .sandbox
-            }
-        }()
+        let environment: Environment
+        switch config["environment"] as? String {
+        case "sandbox":
+            environment = .sandbox
+        case "production":
+            environment = .production
+        case "auto", nil:
+            environment = .auto
+        default:
+            environment = .auto
+        }
+
+        var brandingConfig: BrandingConfig? = nil
+        if let b = config["branding"] as? [String: Any] {
+            // iOS BrandingConfig accepts logoUrl, primaryColor, buttonRadius,
+            // fontFamily. Android-only fields (displayName, redirectUrl) are
+            // accepted by the JS API for cross-platform consistency but
+            // ignored here since the iOS SDK doesn't support them.
+            brandingConfig = BrandingConfig(
+                logoUrl: b["logoUrl"] as? String,
+                primaryColor: (b["primaryColor"] as? String) ?? "#4F7CFF",
+                buttonRadius: CGFloat((b["buttonRadius"] as? Int) ?? 10),
+                fontFamily: b["fontFamily"] as? String
+            )
+        }
 
-        let useSenseConfig = UseSenseConfig(
+        let apiEndpoint = (config["apiEndpoint"] as? String)
+            ?? UseSenseConfig.defaultEndpoint
+
+        let sdkConfig = UseSenseConfig(
+            apiEndpoint: apiEndpoint,
             apiKey: apiKey,
             environment: environment,
-            organizationId: config["organizationId"] as? String,
-            sessionType: (config["sessionType"] as? String) == "authentication" ? .authentication : .enrollment,
-            challengePolicy: {
-                switch config["challengePolicy"] as? String {
-                case "enhanced": return .enhanced
-                case "adaptive": return .adaptive
-                default: return .standard
-                }
-            }(),
-            enableAudio: config["enableAudio"] as? Bool ?? false,
-            timeout: config["timeout"] as? TimeInterval ?? 60000,
-            metadata: config["metadata"] as? [String: String]
+            branding: brandingConfig
         )
 
-        UseSense.initialize(config: useSenseConfig)
+        // Create (or replace) the client. If a previous client was
+        // active, its event subscription is disposed before we
+        // replace it so we don't accumulate stale listeners on
+        // repeated initialize() calls.
+        eventUnsubscribe?()
+        eventUnsubscribe = nil
+
+        let newClient = UseSense(config: sdkConfig)
+        eventUnsubscribe = newClient.onEvent { [weak self] event in
+            self?.emitEvent(event)
+        }
+        client = newClient
+
+        resolve(nil)
     }
 
     @objc
-    func startSession(_ options: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+    func startVerification(_ request: NSDictionary,
+                           resolver resolve: @escaping RCTPromiseResolveBlock,
+                           rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let client = client else {
+            reject("sdk_not_initialized",
+                   "UseSense SDK is not initialized. Call initialize() first.",
+                   nil)
+            return
+        }
+
+        let sessionType: SessionType = (request["sessionType"] as? String) == "authentication"
+            ? .authentication
+            : .enrollment
+
+        // The native iOS `VerificationRequest` takes an `AnyCodableValue`
+        // map for metadata. RN can only pass plain JSON so we coerce
+        // every value to a string — matches what the Flutter plugin
+        // does over the Pigeon channel.
+        let rawMetadata = request["metadata"] as? [String: Any]
+        let metadata: [String: AnyCodableValue]? = rawMetadata?.mapValues { value in
+            if let s = value as? String { return .string(s) }
+            if let b = value as? Bool { return .bool(b) }
+            if let i = value as? Int { return .int(i) }
+            if let d = value as? Double { return .double(d) }
+            return .string(String(describing: value))
+        }
+
+        let nativeRequest = VerificationRequest(
+            sessionType: sessionType,
+            externalUserId: request["externalUserId"] as? String,
+            identityId: request["identityId"] as? String,
+            metadata: metadata
+        )
+
         DispatchQueue.main.async {
-            guard let viewController = RCTPresentedViewController() else {
-                reject("no_view_controller", "No view controller available", nil)
+            guard let rootVC = Self.topmostViewController() else {
+                reject("no_view_controller",
+                       "No view controller available to present the camera UI.",
+                       nil)
                 return
             }
 
-            let sessionType: SessionType = (options["sessionType"] as? String) == "authentication" ? .authentication : .enrollment
-            let identityId = options["identityId"] as? String
-
-            UseSense.startSession(
-                from: viewController,
-                sessionType: sessionType,
-                identityId: identityId
-            ) { result in
+            let session = client.startVerification(request: nativeRequest)
+            let vc = UseSenseViewController(session: session) { [weak rootVC] result in
+                // The view controller dismisses itself on the main
+                // thread before invoking this closure. We're safe to
+                // resolve/reject directly without hopping.
+                _ = rootVC
                 switch result {
-                case .success(let useSenseResult):
-                    let resultDict: [String: Any] = [
-                        "sessionId": useSenseResult.sessionId,
-                        "decision": useSenseResult.decision.rawValue,
-                        "channelTrustScore": useSenseResult.channelTrustScore,
-                        "livenessScore": useSenseResult.livenessScore,
-                        "matchSenseRiskScore": useSenseResult.matchSenseRiskScore,
-                        "presenceConfidence": useSenseResult.presenceConfidence,
-                        "reasons": useSenseResult.reasons,
-                        "ruleTriggered": useSenseResult.ruleTriggered as Any,
-                        "recommendedAction": useSenseResult.recommendedAction as Any,
-                        "sessionSignature": useSenseResult.sessionSignature,
-                    ]
-                    resolve(resultDict)
-
+                case .success(let decision):
+                    resolve(Self.redactedResultDict(decision))
                 case .failure(let error):
-                    reject(error.code, error.message, nil)
+                    if error.code == .userCancelled {
+                        reject("session_cancelled",
+                               "User cancelled the verification session.",
+                               nil)
+                    } else {
+                        reject(Self.bridgeErrorCode(error.code),
+                               error.message,
+                               error)
+                    }
                 }
             }
+            vc.modalPresentationStyle = .fullScreen
+            rootVC.present(vc, animated: true)
         }
     }
 
     @objc
-    func cancelSession(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        UseSense.cancelSession()
+    func reset(_ resolve: @escaping RCTPromiseResolveBlock,
+               rejecter reject: @escaping RCTPromiseRejectBlock) {
+        eventUnsubscribe?()
+        eventUnsubscribe = nil
+        client?.reset()
+        client = nil
         resolve(nil)
     }
 
     @objc
-    func getSessionStatus(_ sessionId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        UseSense.getSessionStatus(sessionId: sessionId) { result in
-            switch result {
-            case .success(let status):
-                var dict: [String: Any] = ["status": status.status]
-                if let r = status.result {
-                    dict["result"] = [
-                        "sessionId": r.sessionId,
-                        "decision": r.decision.rawValue,
-                        "channelTrustScore": r.channelTrustScore,
-                        "livenessScore": r.livenessScore,
-                        "matchSenseRiskScore": r.matchSenseRiskScore,
-                        "presenceConfidence": r.presenceConfidence,
-                        "reasons": r.reasons,
-                        "sessionSignature": r.sessionSignature,
-                    ]
-                }
-                resolve(dict)
-            case .failure(let error):
-                reject(error.code, error.message, nil)
-            }
-        }
+    func isInitialized(_ resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(client != nil)
     }
 
-    @objc
-    func subscribeToEvents() {
-        UseSense.onEvent { [weak self] event in
-            guard let self = self, self.hasListeners else { return }
-            self.sendEvent(withName: "UseSenseEvent", body: event.toDictionary())
+    // MARK: - Private helpers
+
+    private func emitEvent(_ event: UseSenseEvent) {
+        guard hasListeners else { return }
+        let eventTypeString = Self.eventTypeString(event.type)
+        let body: [String: Any] = [
+            "type": eventTypeString,
+            "timestamp": Int64(event.timestamp.timeIntervalSince1970 * 1000),
+            "data": event.data ?? [:]
+        ]
+        DispatchQueue.main.async { [weak self] in
+            self?.sendEvent(withName: "UseSenseEvent", body: body)
         }
     }
 
-    @objc
-    func unsubscribeFromEvents() {
-        UseSense.removeEventListener()
+    /// Maps the SDK's `RedactedDecisionObject` into the exact five-field
+    /// dict the JS API exposes. Adding or returning anything beyond
+    /// these five fields would leak internal scoring data through the
+    /// bridge — do NOT add channel/liveness/matchsense scores here.
+    private static func redactedResultDict(_ decision: RedactedDecisionObject) -> [String: Any] {
+        return [
+            "sessionId": decision.sessionId,
+            "sessionType": decision.sessionType as Any,
+            "identityId": decision.identityId as Any,
+            "decision": decision.decision,
+            "timestamp": decision.timestamp,
+            // Convenience booleans computed on the native side so the
+            // JS consumer doesn't have to string-compare decision codes.
+            "isApproved": decision.isApproved,
+            "isRejected": decision.isRejected,
+            "isPendingReview": decision.isPendingReview
+        ]
     }
 
-    @objc
-    func getSdkVersion() -> String {
-        return UseSense.sdkVersion
+    private static func bridgeErrorCode(_ code: UseSenseErrorCode) -> String {
+        // Return the raw error code string (e.g. "NETWORK_ERROR"). JS
+        // consumers can key off this via UseSenseError.code. Matches the
+        // string-valued error codes the Flutter plugin emits.
+        return code.rawValue
     }
 
-    @objc
-    override static func requiresMainQueueSetup() -> Bool {
-        return false
+    private static func eventTypeString(_ type: UseSenseEventType) -> String {
+        // RN bridges typically emit UPPER_SNAKE_CASE event type strings.
+        // Map the SDK's enum cases to the same canonical form the
+        // Android bridge uses (event.type.name) so JS consumers can
+        // switch on a single constant set regardless of platform.
+        switch type {
+        case .sessionCreated: return "SESSION_CREATED"
+        case .permissionsRequested: return "PERMISSIONS_REQUESTED"
+        case .permissionsGranted: return "PERMISSIONS_GRANTED"
+        case .permissionsDenied: return "PERMISSIONS_DENIED"
+        case .captureStarted: return "CAPTURE_STARTED"
+        case .frameCaptured: return "FRAME_CAPTURED"
+        case .captureCompleted: return "CAPTURE_COMPLETED"
+        case .audioRecordStarted: return "AUDIO_RECORD_STARTED"
+        case .audioRecordCompleted: return "AUDIO_RECORD_COMPLETED"
+        case .challengeStarted: return "CHALLENGE_STARTED"
+        case .challengeCompleted: return "CHALLENGE_COMPLETED"
+        case .uploadStarted: return "UPLOAD_STARTED"
+        case .uploadProgress: return "UPLOAD_PROGRESS"
+        case .uploadCompleted: return "UPLOAD_COMPLETED"
+        case .completeStarted: return "COMPLETE_STARTED"
+        case .decisionReceived: return "DECISION_RECEIVED"
+        case .imageQualityCheck: return "IMAGE_QUALITY_CHECK"
+        case .error: return "ERROR"
+        @unknown default: return "UNKNOWN"
+        }
+    }
+
+    /// Walks the currently-presented view controller chain and returns
+    /// the topmost one — which is the correct presenter for a new
+    /// full-screen modal. `RCTPresentedViewController()` returns the
+    /// currently-displayed VC which may itself be a modal, so we
+    /// traverse to the leaf to avoid "already presenting" errors.
+    private static func topmostViewController() -> UIViewController? {
+        guard var top = UIApplication.shared.connectedScenes
+            .compactMap({ ($0 as? UIWindowScene)?.keyWindow })
+            .first?
+            .rootViewController else {
+            return RCTPresentedViewController()
+        }
+        while let presented = top.presentedViewController {
+            top = presented
+        }
+        return top
     }
 }