@hawcx/react-native-sdk 1.0.3 → 1.0.5

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

@@ -0,0 +1,387 @@
+package com.hawcx.reactnative
+
+import android.os.Handler
+import android.os.Looper
+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.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.hawcx.internal.HawcxSDK
+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"
+
+@ReactModule(name = HawcxReactNativeModule.NAME)
+class HawcxReactNativeModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    companion object {
+        const val NAME = "HawcxReactNative"
+        private const val CODE_CONFIG = "hawcx.config"
+        private const val CODE_SDK = "hawcx.sdk"
+        private const val CODE_INPUT = "hawcx.input"
+        private const val CODE_STORAGE = "hawcx.storage"
+    }
+
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val applicationContext = reactApplicationContext.applicationContext
+
+    private val eventDispatcher = HawcxEventDispatcher(reactApplicationContext)
+
+    @Volatile
+    private var hawcxSDK: HawcxSDK? = null
+    @Volatile
+    private var authCallbackProxy: AuthV5Callback? = null
+    @Volatile
+    private var sessionCallbackProxy: SessionCallbackProxy? = null
+    @Volatile
+    private var pushDelegateProxy: PushDelegateProxy? = null
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun initialize(config: ReadableMap?, promise: Promise) {
+        val configMap = config ?: run {
+            promise.reject(CODE_CONFIG, "initialize requires a configuration map")
+            return
+        }
+
+        val projectApiKey = configMap.getString("projectApiKey")?.trim().orEmpty()
+        if (projectApiKey.isEmpty()) {
+            promise.reject(CODE_CONFIG, "projectApiKey is required")
+            return
+        }
+
+        val baseUrl = when {
+            configMap.hasKey("baseUrl") && !configMap.isNull("baseUrl") ->
+                configMap.getString("baseUrl")?.trim().orEmpty()
+            configMap.hasKey("endpoints") && !configMap.isNull("endpoints") -> {
+                configMap.getMap("endpoints")?.getString("authBaseUrl")?.trim().orEmpty()
+            }
+            else -> ""
+        }
+
+        if (baseUrl.isEmpty()) {
+            promise.reject(CODE_CONFIG, "baseUrl is required")
+            return
+        }
+
+        if (configMap.hasKey("oauthConfig") && !configMap.isNull("oauthConfig")) {
+            HawcxReactNativeLogger.w(
+                "oauthConfig was provided but the Android SDK no longer accepts client credentials on-device. " +
+                    "Remove this field from initialize()."
+            )
+        }
+
+        runOnUiThread {
+            try {
+                val sdk = HawcxSDK(
+                    context = applicationContext,
+                    projectApiKey = projectApiKey,
+                    baseUrl = baseUrl
+                )
+                hawcxSDK = sdk
+                val authProxy = AuthCallbackProxy(eventDispatcher)
+                val sessionProxy = SessionCallbackProxy(eventDispatcher)
+                val pushProxy = PushDelegateProxy(eventDispatcher)
+                authCallbackProxy = authProxy
+                sessionCallbackProxy = sessionProxy
+                pushDelegateProxy = pushProxy
+                sdk.pushAuthDelegate = pushProxy
+                promise.resolve(null)
+            } catch (error: Exception) {
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun authenticate(userId: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before authenticate")
+            return
+        }
+        val callback = authCallbackProxy ?: run {
+            promise.reject(CODE_SDK, "Auth callback not configured")
+            return
+        }
+        val sanitizedUserId = userId?.trim().orEmpty()
+        if (sanitizedUserId.isEmpty()) {
+            promise.reject(CODE_INPUT, "userId cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.authenticateV5(sanitizedUserId, callback)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun submitOtp(otp: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before submitOtp")
+            return
+        }
+        val sanitizedOtp = otp?.trim().orEmpty()
+        if (sanitizedOtp.isEmpty()) {
+            promise.reject(CODE_INPUT, "otp cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.submitOtpV5(sanitizedOtp)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun getDeviceDetails(promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before getDeviceDetails")
+            return
+        }
+        val callback = sessionCallbackProxy ?: run {
+            promise.reject(CODE_SDK, "Session callback not configured")
+            return
+        }
+
+        runOnUiThread {
+            sdk.getDeviceDetails(callback)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun webLogin(pin: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before webLogin")
+            return
+        }
+        val callback = sessionCallbackProxy ?: run {
+            promise.reject(CODE_SDK, "Session callback not configured")
+            return
+        }
+        val sanitizedPin = pin?.trim().orEmpty()
+        if (sanitizedPin.isEmpty()) {
+            promise.reject(CODE_INPUT, "pin cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.webLogin(sanitizedPin, callback)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun webApprove(token: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before webApprove")
+            return
+        }
+        val callback = sessionCallbackProxy ?: run {
+            promise.reject(CODE_SDK, "Session callback not configured")
+            return
+        }
+        val sanitizedToken = token?.trim().orEmpty()
+        if (sanitizedToken.isEmpty()) {
+            promise.reject(CODE_INPUT, "token cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.webApprove(sanitizedToken, callback)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun storeBackendOAuthTokens(userId: String?, accessToken: String?, refreshToken: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before storeBackendOAuthTokens")
+            return
+        }
+        val trimmedUser = userId?.trim().orEmpty()
+        if (trimmedUser.isEmpty()) {
+            promise.reject(CODE_INPUT, "userId cannot be empty")
+            return
+        }
+
+        val trimmedAccess = accessToken?.trim().orEmpty()
+        if (trimmedAccess.isEmpty()) {
+            promise.reject(CODE_INPUT, "accessToken cannot be empty")
+            return
+        }
+
+        val refresh = refreshToken?.trim().orEmpty().ifBlank { null }
+
+        runCatching {
+            sdk.storeBackendOAuthTokens(
+                accessToken = trimmedAccess,
+                refreshToken = refresh,
+                userId = trimmedUser
+            )
+        }.onSuccess { stored ->
+            if (stored) {
+                promise.resolve(true)
+            } else {
+                promise.reject(CODE_STORAGE, "Failed to persist backend-issued tokens")
+            }
+        }.onFailure { error ->
+            promise.reject(CODE_STORAGE, error.message, error)
+        }
+    }
+
+    @ReactMethod
+    fun getLastLoggedInUser(promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before getLastLoggedInUser")
+            return
+        }
+        promise.resolve(sdk.getLastLoggedInUser())
+    }
+
+    @ReactMethod
+    fun clearSessionTokens(userId: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before clearSessionTokens")
+            return
+        }
+        val sanitizedUserId = userId?.trim().orEmpty()
+        if (sanitizedUserId.isEmpty()) {
+            promise.reject(CODE_INPUT, "userId cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.clearSessionTokens(sanitizedUserId)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun clearUserKeychainData(userId: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before clearUserKeychainData")
+            return
+        }
+        val sanitizedUserId = userId?.trim().orEmpty()
+        if (sanitizedUserId.isEmpty()) {
+            promise.reject(CODE_INPUT, "userId cannot be empty")
+            return
+        }
+
+        runOnUiThread {
+            sdk.clearUserKeychainData(sanitizedUserId)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun setFcmToken(token: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before setFcmToken")
+            return
+        }
+        val sanitizedToken = token?.trim().orEmpty()
+        if (sanitizedToken.isEmpty()) {
+            promise.reject(CODE_INPUT, "token cannot be empty")
+            return
+        }
+        runOnUiThread {
+            sdk.setFcmToken(sanitizedToken)
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun userDidAuthenticate(promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before userDidAuthenticate")
+            return
+        }
+        runOnUiThread {
+            sdk.userDidAuthenticate()
+            promise.resolve(null)
+        }
+    }
+
+    @ReactMethod
+    fun handlePushNotification(payload: ReadableMap?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before handlePushNotification")
+            return
+        }
+        val payloadMap = payload ?: run {
+            promise.reject(CODE_INPUT, "payload is required")
+            return
+        }
+
+        val stringMap = mutableMapOf<String, String>()
+        payloadMap.toHashMap().forEach { (key, value) ->
+            val valueString = value?.toString()
+            if (valueString != null) {
+                stringMap[key] = valueString
+            }
+        }
+
+        runOnUiThread {
+            sdk.handlePushNotification(stringMap)
+            promise.resolve(stringMap.containsKey("request_id"))
+        }
+    }
+
+    @ReactMethod
+    fun approvePushRequest(requestId: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before approvePushRequest")
+            return
+        }
+        val sanitizedId = requestId?.trim().orEmpty()
+        if (sanitizedId.isEmpty()) {
+            promise.reject(CODE_INPUT, "requestId cannot be empty")
+            return
+        }
+        sdk.approveLoginRequest(sanitizedId) { error ->
+            if (error == null) {
+                promise.resolve(null)
+            } else {
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    @ReactMethod
+    fun declinePushRequest(requestId: String?, promise: Promise) {
+        val sdk = hawcxSDK ?: run {
+            promise.reject(CODE_SDK, "initialize must be called before declinePushRequest")
+            return
+        }
+        val sanitizedId = requestId?.trim().orEmpty()
+        if (sanitizedId.isEmpty()) {
+            promise.reject(CODE_INPUT, "requestId cannot be empty")
+            return
+        }
+        sdk.declineLoginRequest(sanitizedId) { error ->
+            if (error == null) {
+                promise.resolve(null)
+            } else {
+                promise.reject(CODE_SDK, error.message, error)
+            }
+        }
+    }
+
+    private fun runOnUiThread(block: () -> Unit) {
+        if (Looper.getMainLooper() == Looper.myLooper()) {
+            block()
+        } else {
+            mainHandler.post(block)
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.hawcx.reactnative
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class HawcxReactNativePackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(HawcxReactNativeModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,31 @@
+package com.hawcx.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.hawcx.model.PushLoginRequestDetails
+import com.hawcx.utils.HawcxPushAuthDelegate
+
+internal class PushDelegateProxy(
+    private val dispatcher: HawcxEventDispatcher
+) : HawcxPushAuthDelegate {
+
+    override fun hawcx(didReceiveLoginRequest: String, details: PushLoginRequestDetails) {
+        val payload = Arguments.createMap().apply {
+            putString("requestId", didReceiveLoginRequest)
+            putString("ipAddress", details.ipAddress)
+            putString("deviceInfo", details.deviceInfo)
+            putString("timestamp", details.timestamp)
+            if (!details.location.isNullOrBlank()) {
+                putString("location", details.location)
+            }
+        }
+        dispatcher.emitPushEvent("push_login_request", payload)
+    }
+
+    override fun hawcx(failedToFetchLoginRequestDetails: Throwable) {
+        val payload = Arguments.createMap().apply {
+            putString("code", "push_error")
+            putString("message", failedToFetchLoginRequestDetails.message ?: "Failed to fetch login request details")
+        }
+        dispatcher.emitPushEvent("push_error", payload)
+    }
+}

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

@@ -0,0 +1,35 @@
+package com.hawcx.reactnative
+
+import com.facebook.react.bridge.Arguments
+import com.hawcx.utils.DevSessionCallback
+import com.hawcx.utils.WebLoginCallback
+import com.hawcx.utils.WebLoginError
+
+internal class SessionCallbackProxy(
+    private val dispatcher: HawcxEventDispatcher
+) : DevSessionCallback, WebLoginCallback {
+
+    override fun onSuccess() {
+        dispatcher.emitSessionEvent("session_success")
+    }
+
+    override fun onError() {
+        dispatcher.emitSessionEvent(
+            "session_error",
+            Arguments.createMap().apply {
+                putString("code", "session_error")
+                putString("message", "Failed to fetch device session")
+            }
+        )
+    }
+
+    override fun onError(webLoginErrorCode: WebLoginError, errorMessage: String) {
+        dispatcher.emitSessionEvent(
+            "session_error",
+            Arguments.createMap().apply {
+                putString("code", webLoginErrorCode.name)
+                putString("message", errorMessage)
+            }
+        )
+    }
+}

package/example/ios/Podfile.lock

@@ -11,7 +11,7 @@ PODS:
     - ReactCommon/turbomodule/core (= 0.73.9)
   - fmt (6.2.1)
   - glog (0.3.5)
-  - HawcxReactNative (1.0.3):
+  - HawcxReactNative (1.0.5):
     - React-Core
   - hermes-engine (0.73.9):
     - hermes-engine/Pre-built (= 0.73.9)
@@ -1236,7 +1236,7 @@ SPEC CHECKSUMS:
   FBReactNativeSpec: 4fe1d8c2fadc7949344b197d933f76b40401aac5
   fmt: ff9d55029c625d3757ed641535fd4a75fedc7ce9
   glog: c5d68082e772fa1c511173d6b30a9de2c05a69a2
-  HawcxReactNative: e4e76d64721d7f806116d3899ec122766d5c2b65
+  HawcxReactNative: c2a3ba90ac5c2054471b187a44676bc0864532e1
   hermes-engine: ed62e0dcd013bf4a3b487f164feec1c4e705b5b5
   libevent: 4049cae6c81cdb3654a443be001fb9bdceff7913
   RCT-Folly: cd21f1661364f975ae76b3308167ad66b09f53f5

package/example/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "hawcx-react-native-sdk-example",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hawcx-react-native-sdk-example",
-      "version": "1.0.3",
+      "version": "1.0.5",
       "dependencies": {
         "@hawcx/react-native-sdk": "file:..",
         "react": "18.2.0",
@@ -29,7 +29,7 @@
     },
     "..": {
       "name": "@hawcx/react-native-sdk",
-      "version": "1.0.3",
+      "version": "1.0.5",
       "license": "MIT",
       "devDependencies": {
         "@react-native/eslint-config": "^0.74.0",

package/example/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hawcx-react-native-sdk-example",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "private": true,
   "scripts": {
     "start": "react-native start",

package/ios/Frameworks/HawcxFramework.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>HawcxFramework.framework/HawcxFramework</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>HawcxFramework.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>
 			<string>HawcxFramework.framework/HawcxFramework</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>HawcxFramework.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>

package/ios/Frameworks/HawcxFramework.xcframework/ios-arm64/HawcxFramework.framework/Modules/HawcxFramework.swiftmodule/arm64-apple-ios.abi.json

@@ -8482,6 +8482,16 @@
           "RawDocComment"
         ]
       },
+      {
+        "kind": "Import",
+        "name": "Foundation",
+        "printedName": "Foundation",
+        "declKind": "Import",
+        "moduleName": "HawcxFramework",
+        "declAttributes": [
+          "RawDocComment"
+        ]
+      },
       {
         "kind": "Import",
         "name": "CommonCrypto",
@@ -9202,7 +9212,14 @@
     {
       "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
       "kind": "BooleanLiteral",
-      "offset": 1539,
+      "offset": 1596,
+      "length": 5,
+      "value": "false"
+    },
+    {
+      "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
+      "kind": "BooleanLiteral",
+      "offset": 1639,
       "length": 5,
       "value": "false"
     },

package/ios/Frameworks/HawcxFramework.xcframework/ios-arm64_x86_64-simulator/HawcxFramework.framework/Modules/HawcxFramework.swiftmodule/arm64-apple-ios-simulator.abi.json

@@ -8482,6 +8482,16 @@
           "RawDocComment"
         ]
       },
+      {
+        "kind": "Import",
+        "name": "Foundation",
+        "printedName": "Foundation",
+        "declKind": "Import",
+        "moduleName": "HawcxFramework",
+        "declAttributes": [
+          "RawDocComment"
+        ]
+      },
       {
         "kind": "Import",
         "name": "CommonCrypto",
@@ -9202,7 +9212,14 @@
     {
       "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
       "kind": "BooleanLiteral",
-      "offset": 1539,
+      "offset": 1596,
+      "length": 5,
+      "value": "false"
+    },
+    {
+      "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
+      "kind": "BooleanLiteral",
+      "offset": 1639,
       "length": 5,
       "value": "false"
     },

package/ios/Frameworks/HawcxFramework.xcframework/ios-arm64_x86_64-simulator/HawcxFramework.framework/Modules/HawcxFramework.swiftmodule/x86_64-apple-ios-simulator.abi.json

@@ -8482,6 +8482,16 @@
           "RawDocComment"
         ]
       },
+      {
+        "kind": "Import",
+        "name": "Foundation",
+        "printedName": "Foundation",
+        "declKind": "Import",
+        "moduleName": "HawcxFramework",
+        "declAttributes": [
+          "RawDocComment"
+        ]
+      },
       {
         "kind": "Import",
         "name": "CommonCrypto",
@@ -9202,7 +9212,14 @@
     {
       "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
       "kind": "BooleanLiteral",
-      "offset": 1539,
+      "offset": 1596,
+      "length": 5,
+      "value": "false"
+    },
+    {
+      "filePath": "\/Users\/agambhullar\/dev_ios\/ios_sdk\/HawcxFramework\/auth\/HawcxAuthV5.swift",
+      "kind": "BooleanLiteral",
+      "offset": 1639,
       "length": 5,
       "value": "false"
     },