@hawcx/react-native-sdk 1.0.8 → 1.1.0

package/android/src/main/java/com/hawcx/reactnative/HawcxReactNativeModule.kt

@@ -6,19 +6,25 @@ 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.LifecycleEventListener
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import com.hawcx.internal.HawcxSDK
+import com.hawcx.reactnative.v6.HawcxV6Bridge
+import com.hawcx.reactnative.v6.HawcxV6InitializeOptions
+import com.hawcx.reactnative.v6.HawcxV6StartOptions
 import com.hawcx.utils.AuthV5Callback
 
 internal const val AUTH_EVENT_NAME = "hawcx.auth.event"
 internal const val SESSION_EVENT_NAME = "hawcx.session.event"
 internal const val PUSH_EVENT_NAME = "hawcx.push.event"
+internal const val V6_FLOW_EVENT_NAME = "hawcx.v6.flow.event"
 
 @ReactModule(name = HawcxReactNativeModule.NAME)
 class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext),
+    LifecycleEventListener {
 
     companion object {
         const val NAME = "HawcxReactNative"
@@ -41,6 +47,12 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
     private var sessionCallbackProxy: SessionCallbackProxy? = null
     @Volatile
     private var pushDelegateProxy: PushDelegateProxy? = null
+    @Volatile
+    private var hawcxV6Bridge: HawcxV6Bridge? = null
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+    }
 
     override fun getName(): String = NAME
 
@@ -80,6 +92,7 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
 
         runOnUiThread {
             try {
+                resetNativeLanes(resetV6Flow = true)
                 val sdk = HawcxSDK(
                     context = applicationContext,
                     projectApiKey = projectApiKey,
@@ -93,8 +106,16 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
                 sessionCallbackProxy = sessionProxy
                 pushDelegateProxy = pushProxy
                 sdk.pushAuthDelegate = pushProxy
+                val v6Bridge = HawcxV6Bridge(eventDispatcher)
+                v6Bridge.configure(
+                    legacySdk = sdk,
+                    configId = projectApiKey,
+                    options = HawcxV6InitializeOptions.from(configMap)
+                )
+                hawcxV6Bridge = v6Bridge
                 promise.resolve(null)
             } catch (error: Exception) {
+                resetNativeLanes(resetV6Flow = true)
                 promise.reject(CODE_SDK, error.message, error)
             }
         }
@@ -140,6 +161,260 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun v6Start(options: ReadableMap?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val config = options ?: run {
+            promise.reject(CODE_INPUT, "options are required")
+            return
+        }
+
+        val startOptions = runCatching { HawcxV6StartOptions.from(config) }
+            .getOrElse { error ->
+                promise.reject(CODE_INPUT, error.message, error)
+                return
+            }
+
+        runOnUiThread {
+            runCatching {
+                bridge.start(startOptions)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6SelectMethod(methodId: String?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedMethodId = methodId?.trim().orEmpty()
+        if (sanitizedMethodId.isEmpty()) {
+            promise.reject(CODE_INPUT, "methodId is required")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.selectMethod(sanitizedMethodId)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6SubmitCode(code: String?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedCode = code?.trim().orEmpty()
+        if (sanitizedCode.isEmpty()) {
+            promise.reject(CODE_INPUT, "code is required")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.submitCode(sanitizedCode)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6SubmitTotp(code: String?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedCode = code?.trim().orEmpty()
+        if (sanitizedCode.isEmpty()) {
+            promise.reject(CODE_INPUT, "code is required")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.submitTotp(sanitizedCode)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6SubmitPhone(phone: String?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedPhone = phone?.trim().orEmpty()
+        if (sanitizedPhone.isEmpty()) {
+            promise.reject(CODE_INPUT, "phone is required")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.submitPhone(sanitizedPhone)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6Resend(promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.resend()
+            }.onSuccess { dispatched ->
+                promise.resolve(dispatched)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6Poll(promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.poll()
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6Cancel(promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.cancel()
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6Reset(promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.reset()
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6ApproveQr(rawPayload: String?, identifier: String?, rememberDevice: Boolean, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedPayload = rawPayload?.trim().orEmpty()
+        if (sanitizedPayload.isEmpty()) {
+            promise.reject(CODE_INPUT, "rawPayload is required")
+            return
+        }
+
+        val sanitizedIdentifier = identifier?.trim().orEmpty()
+        if (sanitizedIdentifier.isEmpty()) {
+            promise.reject(CODE_INPUT, "identifier is required")
+            return
+        }
+
+        runOnUiThread {
+            bridge.approveQr(
+                rawPayload = sanitizedPayload,
+                identifier = sanitizedIdentifier,
+                rememberDevice = rememberDevice
+            ) { result ->
+                result.onSuccess { outcome ->
+                    promise.resolve(
+                        Arguments.createMap().apply {
+                            putString("outcome", outcome.outcome)
+                            putString("payloadType", outcome.payloadType)
+                            outcome.userId?.takeIf { it.isNotBlank() }?.let { putString("userId", it) }
+                        }
+                    )
+                }.onFailure { error ->
+                    promise.reject(CODE_SDK, error.message, error)
+                }
+            }
+        }
+    }
+
+    @ReactMethod
+    fun v6HandleRedirectUrl(url: String?, promise: Promise) {
+        val bridge = hawcxV6Bridge ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before using V6 bridge methods")
+            return
+        }
+        val sanitizedUrl = url?.trim().orEmpty()
+        if (sanitizedUrl.isEmpty()) {
+            promise.reject(CODE_INPUT, "url is required")
+            return
+        }
+
+        runOnUiThread {
+            runCatching {
+                bridge.handleRedirectUrl(sanitizedUrl)
+            }.onSuccess {
+                promise.resolve(null)
+            }.onFailure { error ->
+                promise.reject(CODE_INPUT, error.message, error)
+            }
+        }
+    }
+
     @ReactMethod
     fun getDeviceDetails(promise: Promise) {
         val sdk = hawcxSDK ?: run {
@@ -260,6 +535,7 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
         }
 
         runOnUiThread {
+            resetV6FlowIfAvailable()
             sdk.clearSessionTokens(sanitizedUserId)
             promise.resolve(null)
         }
@@ -278,11 +554,25 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
         }
 
         runOnUiThread {
+            resetV6FlowIfAvailable()
             sdk.clearUserKeychainData(sanitizedUserId)
             promise.resolve(null)
         }
     }
 
+    @ReactMethod
+    fun clearLastLoggedInUser(promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before clearLastLoggedInUser")
+            return
+        }
+
+        runOnUiThread {
+            sdk.clearLastLoggedInUser()
+            promise.resolve(null)
+        }
+    }
+
     @ReactMethod
     fun setFcmToken(token: String?, promise: Promise) {
         val sdk = hawcxSDK ?: run {
@@ -384,4 +674,37 @@ class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
             mainHandler.post(block)
         }
     }
+
+    private fun resetV6FlowIfAvailable() {
+        hawcxV6Bridge?.let { bridge ->
+            runCatching { bridge.reset() }
+                .onFailure { error ->
+                    HawcxReactNativeLogger.w("Failed to reset V6 flow while clearing local state.", error)
+                }
+        }
+    }
+
+    override fun onHostResume() = Unit
+
+    override fun onHostPause() = Unit
+
+    override fun onHostDestroy() {
+        resetNativeLanes(resetV6Flow = true)
+    }
+
+    override fun invalidate() {
+        reactApplicationContext.removeLifecycleEventListener(this)
+        resetNativeLanes(resetV6Flow = true)
+        super.invalidate()
+    }
+
+    private fun resetNativeLanes(resetV6Flow: Boolean) {
+        hawcxV6Bridge?.dispose(resetFlow = resetV6Flow)
+        hawcxV6Bridge = null
+        hawcxSDK?.pushAuthDelegate = null
+        pushDelegateProxy = null
+        sessionCallbackProxy = null
+        authCallbackProxy = null
+        hawcxSDK = null
+    }
 }