@hawcx/react-native-sdk 1.0.2 → 1.0.4

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/docs/RELEASE.md

@@ -36,11 +36,13 @@ This document outlines every command, directory, and deliverable required to pub
    npm test
    npm run build      # produces lib/
    ./gradlew -p android clean lintRelease testReleaseUnitTest assembleRelease publishToMavenLocal
+   Ensure to udpate api("api.hawcx:hawcx:5.1.1") version in dev_react/android/build.gradle if android aar file version changed
+   Then run ./gradlew clean assembleRelease --refresh-dependencies to test if android picks up new aar maven release
    pod lib lint HawcxReactNative.podspec
    ```
    - `./gradlew … publishToMavenLocal` validates the Android bridge (with the bundled Hawcx AAR) builds and can be published.
    - `pod lib lint` confirms the Podspec + `HawcxFramework.xcframework` remain valid.
-
+   
 3. **Update version + changelog (repo root)**
    - Edit `package.json` → bump `version` (run `npm install` afterward so `package-lock.json` picks up the new number).
    - Update `android/build.gradle`’s fallback `version` string and `example/package.json` (re-run `npm install` inside `example/` so its lockfile updates).
@@ -54,10 +56,19 @@ This document outlines every command, directory, and deliverable required to pub
     Include refreshed native artifacts (`ios/Frameworks/*.xcframework`, `android/libs/*.aar`) in the same commit when they change.
 
 4. **Smoke test the example app**
+
+   rm -rf ~/Library/Developer/Xcode/DerivedData/HawcxExampleApp*
+
    ```bash
    cd example
    npm install
-   npm run ios
+   For ios:
+   cd example/ios: pod install
+   cd .. 
+   npm run ios or npm run ios -- --no-packager
+   For android: 
+   cd example/android: ./gradlew clean
+   cd ..
    npm run android
    # Use your dev credentials in example/src/hawcx.config.ts
    cd ..

package/example/README.md

@@ -9,7 +9,7 @@ This example demonstrates the cross-platform APIs exported by `@hawcx/react-nati
    cd example
    npm install
    ```
-2. Configure credentials in `src/hawcx.config.ts`. The file ships with dev defaults—replace the API key and OAuth values with your own.
+2. Configure credentials in `src/hawcx.config.ts`. The file ships with dev defaults—replace the API key **and** `HAWCX_BASE_URL` host with your tenant’s values.
 3. **iOS only:** install pods:
    ```bash
    cd ios && pod install && cd ..

package/example/android/build.gradle

@@ -21,3 +21,15 @@ buildscript {
 }
 
 apply plugin: "com.facebook.react.rootproject"
+
+subprojects { subproject ->
+    subproject.configurations.all { config ->
+        config.resolutionStrategy.eachDependency { details ->
+            if (details.requested.group == "androidx.core" &&
+                (details.requested.name == "core" || details.requested.name == "core-ktx")) {
+                details.useVersion("1.13.1")
+                details.because("core-ktx 1.16.0 requires compileSdk/AGP 35+, but the demo targets 34/AGP 8.1.1")
+            }
+        }
+    }
+}

package/example/android/settings.gradle

@@ -1,3 +1,37 @@
+import org.gradle.api.initialization.resolve.RepositoriesMode
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
+    repositories {
+        google()
+        mavenCentral()
+        maven { url = uri("https://www.jitpack.io") }
+        maven {
+            url = uri("https://raw.githubusercontent.com/hawcx/hawcx_android_sdk/main/maven")
+            content {
+                includeGroup("api.hawcx")
+            }
+            metadataSources {
+                mavenPom()
+                artifact()
+            }
+        }
+        def localHawcxRepo = new File(rootDir, "../../../prod_android/hawcx_android_sdk/maven")
+        if (localHawcxRepo.exists()) {
+            maven {
+                url = localHawcxRepo.toURI()
+                content {
+                    includeGroup("api.hawcx")
+                }
+                metadataSources {
+                    mavenPom()
+                    artifact()
+                }
+            }
+        }
+    }
+}
+
 rootProject.name = 'com.hawcx.example'
 apply from: file("../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesSettingsGradle(settings)
 include ':app'

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.2):
+  - HawcxReactNative (1.0.4):
     - 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: f27677aa2158f6d4a0e76629d1776a2e86cda742
+  HawcxReactNative: 089e5e5b790f77ab853f4ff96723c8dd7ad1a02c
   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.2",
+  "version": "1.0.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hawcx-react-native-sdk-example",
-      "version": "1.0.2",
+      "version": "1.0.4",
       "dependencies": {
         "@hawcx/react-native-sdk": "file:..",
         "react": "18.2.0",
@@ -29,7 +29,7 @@
     },
     "..": {
       "name": "@hawcx/react-native-sdk",
-      "version": "1.0.2",
+      "version": "1.0.4",
       "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.2",
+  "version": "1.0.4",
   "private": true,
   "scripts": {
     "start": "react-native start",

package/example/src/hawcx.config.ts

@@ -4,15 +4,21 @@ import type { HawcxInitializeConfig } from '@hawcx/react-native-sdk';
  * Populate the API key locally for testing or use the in-app form.
  * Leaving it blank ensures we never ship real credentials in git history.
  */
-export const HAWCX_PROJECT_API_KEY = 'YOUR_API_KEY';
+export const HAWCX_PROJECT_API_KEY = 'ceasar2';
+export const HAWCX_BASE_URL = 'https://ceasar-api.hawcx.com';
 
 const buildDefaultConfig = (): HawcxInitializeConfig | null => {
   const trimmedKey = HAWCX_PROJECT_API_KEY.trim();
   if (!trimmedKey) {
     return null;
   }
+  const trimmedBase = HAWCX_BASE_URL.trim();
+  if (!trimmedBase) {
+    return null;
+  }
   return {
     projectApiKey: trimmedKey,
+    baseUrl: trimmedBase,
   };
 };
 

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_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>
 		<dict>
 			<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>
 	</array>
 	<key>CFBundlePackageType</key>