@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/src/main/java/com/hydralib/hydrasdk/HydraCore.kt

@@ -0,0 +1,860 @@
+package com.hydralib.hydrasdk
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.annotation.RestrictTo
+import com.capillary.hydra.android.sdk.FcmConfig
+import com.capillary.hydra.android.sdk.HydraAPI
+import com.capillary.hydra.android.sdk.HydraConfig
+import com.capillary.hydra.android.sdk.InAppConfig
+import com.capillary.hydra.android.sdk.NotificationCenterConfig
+import com.capillary.hydra.android.sdk.NotificationConfig
+import com.capillary.hydra.android.sdk.UserPreferences
+import com.capillary.hydra.android.sdk.utils.Logger
+import com.capillary.hydra.gamification.GamificationFlowManager
+import com.capillary.hydra.gamification.GamificationRegion
+import com.capillary.hydra.gamification.ui.GamificationUIManager
+import com.facebook.react.ReactActivity
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.google.firebase.ktx.Firebase
+import com.google.firebase.remoteconfig.ktx.remoteConfig
+import com.google.gson.Gson
+import com.google.gson.JsonSyntaxException
+import com.google.gson.reflect.TypeToken
+import com.hydralib.eventemitter.HydraEventEmitter
+import com.hydralib.eventemitter.HydraEventType
+import com.hydralib.nativeapis.HydraFirebaseRemoteConfigKeys
+import com.hydralib.nativeapis.HydraRemoteConfig
+import com.hydralib.utils.RNHydraPreferencesManager
+import com.hydralib.utils.getDrawableId
+import okio.IOException
+
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+object HydraCore {
+  @SuppressLint("StaticFieldLeak")
+  var hydraAPI: HydraAPI? = null
+    private set
+  var appContext: Context? = null
+    private set
+  private var lastUsedHydraRemoteConfig: HydraRemoteConfig? = null
+  private var gamificationUIManager: GamificationUIManager? = null
+  private var flowManager: GamificationFlowManager? = null
+
+  internal fun getFlowManager(): GamificationFlowManager? = flowManager
+  internal fun getGamificationUIManager(): GamificationUIManager? = gamificationUIManager
+  var curReactActivity : ReactActivity? = null
+  // Screen name queued before gamificationUIManager was ready; replayed after init.
+  // Guarded by gamificationLock rather than just @Volatile — the write in
+  // gamificationScreenAppeared and the read-and-clear in initHydraInstance are each a
+  // check-then-act, and @Volatile alone only guarantees visibility, not atomicity between them.
+  private var pendingGamificationScreen: String? = null
+  private val gamificationLock = Any()
+
+  var firebaseRemoteConfigActivated = false
+
+  private fun ensureTrailingSlash(url: String): String {
+    return if (url.isEmpty()) {
+      url
+    } else {
+      if (url.endsWith("/")) url else "$url/"
+    }
+  }
+
+  private fun ensureHttps(url: String): String {
+    return if (url.isEmpty()) {
+      url
+    } else if (url.startsWith("http://")) {
+      url.replace("http://", "https://")
+    } else {
+      url
+    }
+  }
+
+  /**
+   * Sets the app context early in initialization to prevent race conditions.
+   * This should be called before any async operations that might delay initHydra().
+   */
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  fun setAppContext(context: Context) {
+    appContext = context
+  }
+
+  private fun clearPersistentData() {
+    if (appContext != null) {
+      RNHydraPreferencesManager.removeHydraRemoteConfig(appContext!!)
+      RNHydraPreferencesManager.removeHydraFirebaseRemoteConfigKeys(appContext!!)
+      Logger.d("HydraCore.clearPersistentData", "Cleared all persistent data")
+    }
+  }
+
+  fun initHydra(appContext: Context, hydraRemoteConfig: HydraRemoteConfig) {
+    HydraCore.appContext = appContext
+    initHydraInstance(hydraRemoteConfig)
+
+    Logger.d("HydraCore.initHydra", "registering listeners")
+
+    HydraPushNotification.registerListenersNotDependentOnAccountId()
+    registerAnonymousFlowCallbacks()
+    HydraPushNotification.registerHydraPushNotificationListener()
+    HydraInAppMessages.registerListener()
+    HydraInboxUI.registerListener()
+
+    sendHydraInitializationResultEvent(true)
+
+    Logger.i("HydraCore.initHydra", "HydraSDK initialized successfully")
+  }
+
+  private fun initHydraInstance(hydraRemoteConfig: HydraRemoteConfig) {
+    try {
+
+      val configFileName = if (appContext!!.assets.list("capillary")?.contains("hydra-config.json")
+          ?: false
+      ) "capillary/hydra-config.json" else "hydra-config.json"
+      val fileInString: String =
+        appContext!!.assets.open(configFileName).bufferedReader().use { it.readText() }
+      val gson = Gson()
+      val type = object : TypeToken<Map<String, Any>>() {}.type
+      val hydraConfigMap = gson.fromJson<Map<String, Any>>(fileInString, type)
+      Log.i("HydraCore.initHydra", "hydraConfigMap = $hydraConfigMap")
+
+      val accountId: String = hydraRemoteConfig.accountId
+      val baseUrl: String = ensureTrailingSlash(ensureHttps(hydraRemoteConfig.baseURL))
+      val sslPublicKey: String = hydraRemoteConfig.sslPublicKey
+      val remoteLogLevel: Int = hydraRemoteConfig.remoteDebugLevel
+      val orgId: String? = hydraRemoteConfig.orgId
+
+
+      val logLevelsMap: Map<*, *> =
+        hydraConfigMap["log_levels"] as Map<*, *>? ?: mapOf<String, Int>()
+      val pushNotificationMap: Map<*, *> =
+        hydraConfigMap["push_notification"] as Map<*, *>? ?: mapOf<String, Any>()
+      val inboxUIMap: Map<*, *> = hydraConfigMap["inbox_ui"] as Map<*, *>? ?: mapOf<String, Any>()
+
+      val captureViewPortDetails: Boolean =
+        hydraConfigMap["capture_view_port_details"] as Boolean? ?: true
+      val disableAppLaunchEvent: Boolean =
+        hydraConfigMap["disable_app_launch_event"] as Boolean? ?: false
+
+      val enableInAppMessaging: Boolean =
+        hydraConfigMap["enable_in_app_messaging"] as Boolean? ?: false
+      val enableSelfHandledInAppMessaging: Boolean =
+        hydraConfigMap["enable_in_app_messaging_in_react_native"] as Boolean? ?: false
+      val enableInboxUI: Boolean = hydraConfigMap["enable_inbox_ui"] as Boolean? ?: false
+
+      val consoleDebugLevel: Int = (hydraConfigMap["console"] as Double?)?.toInt()
+        ?: (logLevelsMap["console"] as Double?)?.toInt() ?: 4
+
+      val enableHydraSDKFirebaseRegistration: Boolean =
+        hydraConfigMap["enable_hydra_sdk_firebase_registration"] as Boolean?
+          ?: pushNotificationMap["enable_hydra_sdk_firebase_registration"] as Boolean? ?: true
+
+      val enableMultipleNotificationsInDrawer: Boolean =
+        pushNotificationMap["enable_multiple_notifications_in_drawer"] as Boolean? ?: true
+
+      val maxNotificationCountInInbox: Int =
+        (hydraConfigMap["max_notification_count"] as Double?)?.toInt()
+          ?: (inboxUIMap["max_notification_count"] as Double?)?.toInt() ?: 200
+
+
+      val fcmConfig = FcmConfig(enableHydraSDKFirebaseRegistration)
+
+      val notificationSmallIconResId =
+        getDrawableId(appContext!!, "hydra_notification_small_icon", "drawable")
+      val notificationColorResId = getDrawableId(appContext!!, "hydra_notification_color", "color")
+      if (notificationSmallIconResId == 0) {
+        Log.e(
+          "HydraCore.initHydraInstance",
+          "Could not initialize Push Notifications, notification icon is missing, please add an icon with name hydra_notification_small_icon in android/app/src/main/res/drawable folder"
+        )
+      }
+      if (notificationColorResId == 0) {
+        Log.e(
+          "HydraCore.initHydraInstance",
+          "Could not initialize Push Notifications, notification color is missing, please add a color with name hydra_notification_color in android/app/src/main/res/values/colors.xml"
+        )
+      }
+
+      var notificationConfig: NotificationConfig? = null
+      if (notificationColorResId > 0 && notificationSmallIconResId > 0) {
+        notificationConfig = NotificationConfig(
+          notificationSmallIconResId,
+          notificationColorResId,
+          enableMultipleNotificationsInDrawer,
+          isCrossPlatformEnabled = true
+        )
+      }
+
+      var inAppConfig: InAppConfig? = null
+      if (enableInAppMessaging) {
+        val inAppPlaceholderResId =
+          getDrawableId(appContext!!, "hydra_in_app_placeholder", "drawable")
+        if (inAppPlaceholderResId == 0) {
+          Log.e(
+            "HydraCore.initHydraInstance",
+            "Could not initialize InAppMessaging, the placeholder icon is missing, please add an icon with name hydra_in_app_placeholder in android/app/src/main/res/drawable folder"
+          )
+        } else {
+          inAppConfig = InAppConfig(inAppPlaceholderResId, enableSelfHandledInAppMessaging)
+        }
+      }
+
+      var notificationCenterConfig: NotificationCenterConfig? = null
+      if (enableInboxUI) {
+        val inboxUIPlaceholderResId =
+          getDrawableId(appContext!!, "hydra_inbox_ui_placeholder", "drawable")
+        if (inboxUIPlaceholderResId == 0) {
+          Log.e(
+            "HydraCore.initHydraInstance",
+            "Could not initialize InboxUI, the placeholder icon is missing, please add an icon with name hydra_inbox_ui_placeholder in android/app/src/main/res/drawable folder"
+          )
+        } else {
+          notificationCenterConfig =
+            NotificationCenterConfig(inboxUIPlaceholderResId, maxNotificationCountInInbox)
+        }
+      }
+
+      val hydraConfig: HydraConfig = HydraConfig.Builder(
+        appContext!!,
+        accountId,
+        orgId,
+        baseUrl,
+        sslPublicKey,
+        "",
+        "",
+        "",
+        captureViewPortDetails,
+        fcmConfig,
+        notificationConfig,
+        inAppConfig,
+        notificationCenterConfig,
+        disableAppLaunchEvent,
+        consoleDebugLevel - 1, //ReactNative Log level starts from 0, Android starts from -1
+        remoteLogLevel - 1 //ReactNative Log level starts from 0, Android starts from -1
+      ).apply {
+        val cgWriteKey = hydraRemoteConfig.gamificationKey ?: ""
+        val cgRegion = hydraRemoteConfig.gamificationRegion ?: ""
+        val cgBaseUrl = hydraRemoteConfig.gamificationBaseUrl ?: ""
+        if (cgWriteKey.isNotEmpty() && cgRegion.isNotEmpty()) {
+          gamificationWriteKey(cgWriteKey)
+          try {
+            gamificationRegion(GamificationRegion.valueOf(cgRegion.uppercase()))
+          } catch (_: IllegalArgumentException) {
+
+          }
+        }
+        if (cgBaseUrl.isNotEmpty()) {
+          gamificationBaseUrl(cgBaseUrl)
+        }
+      }.build()
+
+      hydraAPI = HydraAPI.instanceWithConfig(appContext!!, hydraConfig)
+
+      hydraAPI?.getGamificationManager()?.let {
+        flowManager = it
+        // Synchronized against gamificationScreenAppeared's check-then-set so a screen name
+        // set concurrently with init can't be missed by this read-and-clear.
+        val pending = synchronized(gamificationLock) {
+          gamificationUIManager = GamificationUIManager(it, appContext!!)
+          pendingGamificationScreen.also { pendingGamificationScreen = null }
+        }
+        // Replay any screen that was registered before the manager was ready.
+        if (pending != null) {
+          Handler(Looper.getMainLooper()).post {
+            val act = curReactActivity
+            if (act != null) {
+              gamificationUIManager?.onScreenChanged(act, pending)
+            }
+          }
+        }
+      }
+
+
+      lastUsedHydraRemoteConfig = hydraRemoteConfig
+
+      Logger.d(
+        "HydraCore.initHydraInstance",
+        "Hydra instance initialized with accountId: $accountId, baseUrl: $baseUrl, sslPublicKey: $sslPublicKey"
+      )
+    } catch (_: IOException) {
+      val errorMessage =
+        "Could not load hydra-config.json, save the config file to capillary folder"
+
+      sendHydraInitializationResultEvent(false, errorMessage)
+
+      Log.e(
+        "HydraCore.initHydraInstance",
+        errorMessage
+      )
+    } catch (_: JsonSyntaxException) {
+      val errorMessage = "hydra-config.json is not in correct format, please check the file"
+      sendHydraInitializationResultEvent(false, errorMessage)
+
+      Log.e("HydraCore.initHydraInstance", errorMessage)
+    }
+  }
+
+  fun sendHydraInitializationResultEvent(success: Boolean, errorMessage: String? = null) {
+    val resultMap = mutableMapOf<String, Any>()
+    resultMap["success"] = success
+    if (errorMessage != null) {
+      resultMap["errorMessage"] = errorMessage
+    }
+
+    HydraEventEmitter.sendEvent(
+      HydraEventType.ON_HYDRA_SDK_INITIALIZATION_RESULT,
+      resultMap
+    )
+  }
+
+  fun registerAnonymousFlowCallbacks(){
+    HydraAPI.setConfigFetchedCallback { isVisitorFlowEnabled ->
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_CONFIG_FETCHED_CALLBACK,
+        isVisitorFlowEnabled
+      )
+    }
+
+    HydraAPI.setLegacyFlowReadyCallback {
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_LEGACY_FLOW_READY,
+        null
+      )
+    }
+
+    HydraAPI.setVisitorSessionReadyCallback {
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_VISITOR_SESSION_READY,
+        null
+      )
+    }
+
+    HydraAPI.setUserStateChangedCallback { userState ->
+      Logger.d("HydraCore.setUserStateChangedCallback", "User state changed callback triggered: ${userState.name}")
+      HydraEventEmitter.sendEvent(
+        HydraEventType.ON_USER_STATE_CHANGED,
+        userState.name
+      )
+    }
+
+  }
+
+  fun setHydraAccountConfig(hydraAccountConfig: ReadableMap?, promise: Promise?) {
+    // Defensive null check to prevent crashes if called before initialization completes
+    if (appContext == null) {
+      Logger.e("HydraCore.setHydraAccountConfig", "Hydra SDK not initialized yet")
+      promise?.reject("Error", "Hydra SDK is still initializing. Please try again.", Throwable())
+      return
+    }
+
+    Logger.d("hydraAccountConfig", "Received account config: $hydraAccountConfig")
+    val accountIdToSet = hydraAccountConfig?.getString("accountId")
+    val baseUrlToSet = hydraAccountConfig?.getString("baseUrl")
+    val sslPublicKeyToSet = hydraAccountConfig?.getString("sslPublicKey")
+    val remoteDebugLevelToSet = hydraAccountConfig?.getInt("remoteDebugLevel")
+    val orgIdToSet = hydraAccountConfig?.getString("orgId")
+    val gamificationKeyToSet = hydraAccountConfig?.getString("gamificationKey")
+    val gamificationRegionToSet = hydraAccountConfig?.getString("gamificationRegion")
+    val gamificationBaseUrlToSet = hydraAccountConfig?.getString("gamificationBaseUrl")
+
+    if (accountIdToSet == null || accountIdToSet.isEmpty() || baseUrlToSet == null || baseUrlToSet.isEmpty() || sslPublicKeyToSet == null || sslPublicKeyToSet.isEmpty() || remoteDebugLevelToSet == null || remoteDebugLevelToSet < 0 || remoteDebugLevelToSet > 5) {
+      Logger.e("HydraCore.setHydraAccountConfig", "Invalid account config values")
+      promise?.reject("Error setting account config", "Invalid account config values", Throwable())
+      return
+    }
+
+    if (
+      lastUsedHydraRemoteConfig != null &&
+      lastUsedHydraRemoteConfig!!.accountId == accountIdToSet &&
+      lastUsedHydraRemoteConfig!!.sslPublicKey == sslPublicKeyToSet &&
+      lastUsedHydraRemoteConfig!!.baseURL == baseUrlToSet &&
+      lastUsedHydraRemoteConfig!!.remoteDebugLevel == remoteDebugLevelToSet &&
+      lastUsedHydraRemoteConfig!!.orgId == orgIdToSet &&
+      lastUsedHydraRemoteConfig!!.gamificationKey == gamificationKeyToSet &&
+      lastUsedHydraRemoteConfig!!.gamificationRegion == gamificationRegionToSet &&
+      lastUsedHydraRemoteConfig!!.gamificationBaseUrl == gamificationBaseUrlToSet
+    ) {
+      clearPersistentData()
+      RNHydraPreferencesManager.saveHydraRemoteConfig(appContext!!, lastUsedHydraRemoteConfig!!)
+      Logger.d("HydraCore.setHydraAccountConfig", "Already using these account config values")
+      promise?.resolve(true)
+      return
+    }
+
+    val remoteConfig: HydraRemoteConfig = HydraRemoteConfig.Builder(
+      accountIdToSet,
+      baseUrlToSet,
+      sslPublicKeyToSet,
+      remoteDebugLevelToSet
+    ).also { builder ->
+      orgIdToSet?.let { builder.orgId(it) }
+      gamificationKeyToSet?.let { builder.gamificationKey(it) }
+      gamificationRegionToSet?.let { builder.gamificationRegion(it) }
+      gamificationBaseUrlToSet?.let { builder.gamificationBaseUrl(it) }
+    }.build()
+
+    initHydraInstance(remoteConfig)
+    clearPersistentData()
+    RNHydraPreferencesManager.saveHydraRemoteConfig(appContext!!, remoteConfig)
+    HydraPushNotification.registerHydraPushNotificationListener()
+    HydraInAppMessages.registerListener()
+    HydraInboxUI.registerListener()
+    promise?.resolve(true)
+    Logger.d(
+      "HydraCore.setHydraAccountConfig",
+      "Updated account config successfully with accountId: $accountIdToSet, baseUrl: $baseUrlToSet, sslPublicKey: $sslPublicKeyToSet"
+    )
+  }
+
+  @RestrictTo(RestrictTo.Scope.LIBRARY)
+  fun processFirebaseRemoteConfig(
+    hydraFirebaseRemoteConfigKeys: HydraFirebaseRemoteConfigKeys
+  ): HydraRemoteConfig? {
+    val firebaseRemoteConfig = Firebase.remoteConfig
+    Log.d("HydraInitializer", "Processing remote config values")
+
+    val accountId = firebaseRemoteConfig.getString(hydraFirebaseRemoteConfigKeys.keyForAccountId)
+    val baseURL = firebaseRemoteConfig.getString(hydraFirebaseRemoteConfigKeys.keyForBaseURL)
+    val sslPublicKey = firebaseRemoteConfig.getString(hydraFirebaseRemoteConfigKeys.keyForSsl)
+    val remoteDebugLevelStr =
+      firebaseRemoteConfig.getString(hydraFirebaseRemoteConfigKeys.keyForRemoteDebugLevel)
+    val orgId = hydraFirebaseRemoteConfigKeys.keyForOrgId?.takeIf { it.isNotEmpty() }?.let {
+      firebaseRemoteConfig.getString(it).takeIf { value -> value.isNotEmpty() }
+    }
+    val gamificationKey = hydraFirebaseRemoteConfigKeys.keyForGamificationKey?.takeIf { it.isNotEmpty() }?.let {
+      firebaseRemoteConfig.getString(it).takeIf { value -> value.isNotEmpty() }
+    }
+    val gamificationRegion = hydraFirebaseRemoteConfigKeys.keyForGamificationRegion?.takeIf { it.isNotEmpty() }?.let {
+      firebaseRemoteConfig.getString(it).takeIf { value -> value.isNotEmpty() }
+    }
+    val gamificationBaseUrl = hydraFirebaseRemoteConfigKeys.keyForGamificationBaseUrl?.takeIf { it.isNotEmpty() }?.let {
+      firebaseRemoteConfig.getString(it).takeIf { value -> value.isNotEmpty() }
+    }
+
+    Log.d(
+      "HydraInitializer", """
+            Remote config values:
+            accountId: $accountId
+            baseURL: $baseURL
+            sslPublicKey: $sslPublicKey
+            remoteDebugLevel: $remoteDebugLevelStr
+            orgId: $orgId
+        """.trimIndent()
+    )
+
+    // Validate required values
+    if (accountId.isEmpty()) {
+      val errorMessage =
+        "Please add a key in firebase remote config with name \"hydra_account_id\" or pass the key name in initializeUsingFirebaseRemoteConfig"
+      Log.e("HydraInitializer", errorMessage)
+      sendHydraInitializationResultEvent(false, errorMessage)
+      return null
+    }
+    if (baseURL.isEmpty()) {
+      val errorMessage =
+        "Please add a key in firebase remote config with name \"hydra_base_url\" or pass the key name in initializeUsingFirebaseRemoteConfig"
+      Log.e("HydraInitializer", errorMessage)
+      sendHydraInitializationResultEvent(false, errorMessage)
+      return null
+    }
+    if (sslPublicKey.isEmpty()) {
+      val errorMessage =
+        "Please add a key in firebase remote config with name \"hydra_ssl_public_key\" or pass the key name in initializeUsingFirebaseRemoteConfig"
+      Log.e("HydraInitializer", errorMessage)
+      sendHydraInitializationResultEvent(false, errorMessage)
+      return null
+    }
+
+    // Initialize with the fetched values
+    HydraRemoteConfig.Builder(
+      accountId,
+      baseURL,
+      sslPublicKey,
+      remoteDebugLevelStr.toIntOrNull() ?: 0
+    ).also { builder ->
+      orgId?.let { builder.orgId(it) }
+      gamificationKey?.let { builder.gamificationKey(it) }
+      gamificationRegion?.let { builder.gamificationRegion(it) }
+      gamificationBaseUrl?.let { builder.gamificationBaseUrl(it) }
+    }.build().let { remoteConfig ->
+      Logger.d("processRemoteConfig", "Remote config values: $remoteConfig")
+      return remoteConfig
+    }
+    return null
+  }
+
+
+  fun setFirebaseRemoteConfigKeys(
+    remoteConfigKeys: ReadableMap?,
+    promise: Promise?
+  ) {
+    // Defensive null check to prevent crashes if called before initialization completes
+    if (appContext == null) {
+      Logger.e("HydraCore.setFirebaseRemoteConfigKeys", "Hydra SDK not initialized yet")
+      promise?.reject("Error", "Hydra SDK is still initializing. Please try again.", Throwable())
+      return
+    }
+
+    val keyForAccountId = remoteConfigKeys?.getString("keyForAccountId")
+    val keyForBaseUrl = remoteConfigKeys?.getString("keyForBaseUrl")
+    val keyForSsl = remoteConfigKeys?.getString("keyForSsl")
+    val keyForRemoteDebugLevel = remoteConfigKeys?.getString("keyForRemoteDebugLevel")
+    val keyForOrgId = remoteConfigKeys?.getString("keyForOrgId")
+    val keyForGamificationKey = remoteConfigKeys?.getString("keyForGamificationKey")
+    val keyForGamificationRegion = remoteConfigKeys?.getString("keyForGamificationRegion")
+    val keyForGamificationBaseUrl = remoteConfigKeys?.getString("keyForGamificationBaseUrl")
+
+    if (keyForAccountId == null || keyForAccountId.isEmpty() || keyForBaseUrl == null || keyForBaseUrl.isEmpty() || keyForSsl == null || keyForSsl.isEmpty() || keyForRemoteDebugLevel == null || keyForRemoteDebugLevel.isEmpty()) {
+      Logger.e("HydraCore.setFirebaseRemoteConfigKeys", "Invalid remote config keys")
+      promise?.reject("Error setting remote config keys", "Invalid remote config keys", Throwable())
+      return
+    }
+
+    val hydraFirebaseRemoteConfigKeys: HydraFirebaseRemoteConfigKeys =
+      HydraFirebaseRemoteConfigKeys(
+        keyForAccountId,
+        keyForBaseUrl,
+        keyForSsl,
+        keyForRemoteDebugLevel,
+        keyForOrgId,
+        keyForGamificationKey,
+        keyForGamificationRegion,
+        keyForGamificationBaseUrl
+      )
+    val hydraRemoteConfig: HydraRemoteConfig? =
+      processFirebaseRemoteConfig(hydraFirebaseRemoteConfigKeys)
+    if (hydraRemoteConfig == null) {
+      val errorMessage = "Failed to get values for these keys from Firebase remote config"
+      Logger.e("HydraCore.setFirebaseRemoteConfigKeys", errorMessage)
+      promise?.reject("Error setting remote config keys", errorMessage, Throwable())
+      return
+    } else {
+      if (
+        lastUsedHydraRemoteConfig != null &&
+        lastUsedHydraRemoteConfig!!.accountId == hydraRemoteConfig.accountId &&
+        lastUsedHydraRemoteConfig!!.sslPublicKey == hydraRemoteConfig.sslPublicKey &&
+        lastUsedHydraRemoteConfig!!.baseURL == hydraRemoteConfig.baseURL &&
+        lastUsedHydraRemoteConfig!!.remoteDebugLevel == hydraRemoteConfig.remoteDebugLevel &&
+        lastUsedHydraRemoteConfig!!.orgId == hydraRemoteConfig.orgId &&
+        lastUsedHydraRemoteConfig!!.gamificationKey == hydraRemoteConfig.gamificationKey &&
+        lastUsedHydraRemoteConfig!!.gamificationRegion == hydraRemoteConfig.gamificationRegion &&
+        lastUsedHydraRemoteConfig!!.gamificationBaseUrl == hydraRemoteConfig.gamificationBaseUrl
+      ) {
+        clearPersistentData()
+        RNHydraPreferencesManager.saveHydraFirebaseRemoteConfigKeys(
+          appContext!!,
+          hydraFirebaseRemoteConfigKeys
+        )
+        Logger.d(
+          "HydraCore.hydraFirebaseRemoteConfigKeys",
+          "Already using these account config values"
+        )
+        promise?.resolve(true)
+        return
+      } else {
+        initHydraInstance(hydraRemoteConfig)
+        clearPersistentData()
+        RNHydraPreferencesManager.saveHydraFirebaseRemoteConfigKeys(
+          appContext!!,
+          hydraFirebaseRemoteConfigKeys
+        )
+        HydraPushNotification.registerHydraPushNotificationListener()
+        HydraInAppMessages.registerListener()
+        HydraInboxUI.registerListener()
+        promise?.resolve(true)
+      }
+    }
+  }
+
+  fun updateGeoConfig(geoConfig: ReadableMap?, promise: Promise?) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.updateGeoConfig", "Hydra instance not initialized")
+      promise?.reject("Error updating geo config", "Hydra instance not initialized", Throwable())
+      return
+    }
+
+    val country: String? = geoConfig?.getString("country")
+    val city: String? = geoConfig?.getString("city")
+    val countryCode: String? = geoConfig?.getString("countryCode")
+
+    country?.let { hydraAPI!!.setCountry(country) }
+    city?.let { hydraAPI!!.setCity(city) }
+    countryCode?.let { hydraAPI!!.setCountryCode(countryCode) }
+
+    promise?.resolve(true)
+
+    Logger.d("HydraCore.updateGeoConfig", "Updated geo config successfully")
+  }
+
+  fun updatePushPreferences(customerId: String?, preferences: ReadableMap?, promise: Promise?) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.updatePushPreferences", "Hydra instance not initialized")
+      promise?.reject(
+        "Error updating push preferences",
+        "Hydra instance not initialized",
+        Throwable()
+      )
+      return
+    }
+
+    if (customerId == null) {
+      Logger.e("HydraCore.updatePushPreferences", "CustomerId can not be null")
+      promise?.reject("Error updating push preferences", "CustomerId can not be null", Throwable())
+      return
+    }
+
+    val promPushOpted = preferences?.getBoolean("promPushOpted") ?: false
+    val transPushOpted = preferences?.getBoolean("transPushOpted") ?: false
+
+    hydraAPI!!.passUserPreferences(customerId, UserPreferences(promPushOpted, transPushOpted))
+
+    Logger.d("HydraCore.updatePushPreferences", "User preferences data updated successfully!")
+    promise?.resolve(true)
+  }
+
+  fun signUp(userDetails: ReadableMap?, customData: ReadableMap?, promise: Promise?) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.signUp", "Hydra instance not initialized")
+      promise?.reject("Error Signing up", "Hydra instance not initialized", Throwable())
+      return
+    }
+
+    val customerId: String? = userDetails?.getString("customerId")
+    val firstName: String? = userDetails?.getString("firstName")
+    val lastName: String? = userDetails?.getString("lastName")
+    val email: String? = userDetails?.getString("email")
+    val phone: String? = userDetails?.getString("phone")
+
+    if (customerId == null) {
+      Logger.e("HydraCore.signUp", "CustomerId can not be null")
+      promise?.reject("Error Signing up", "CustomerId can not be null", Throwable())
+      return
+    }
+
+    hydraAPI!!.pushUserSignup(
+      customerId,
+      firstName,
+      lastName,
+      email,
+      phone,
+      customData?.let { customData.toMap() },
+    )
+
+    promise?.resolve(true)
+    Logger.d("HydraCore.signUp", "Signed up successfully")
+  }
+
+  fun signIn(userDetails: ReadableMap?, customData: ReadableMap?, promise: Promise?) {
+
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.signIn", "Hydra instance not initialized")
+      promise?.reject("Error Signing in", "Hydra instance not initialized", Throwable())
+      return
+    }
+
+    val customerId: String? = userDetails?.getString("customerId")
+    val firstName: String? = userDetails?.getString("firstName")
+    val lastName: String? = userDetails?.getString("lastName")
+    val email: String? = userDetails?.getString("email")
+    val phone: String? = userDetails?.getString("phone")
+
+    if (customerId == null) {
+      Logger.e("HydraCore.signIn", "CustomerId can not be null")
+      promise?.reject("Error Signing in", "CustomerId can not be null", Throwable())
+      return
+    }
+
+    hydraAPI!!.pushUserSignin(
+      customerId,
+      firstName,
+      lastName,
+      email,
+      phone,
+      customData?.let { customData.toMap() },
+    )
+
+    promise?.resolve(true)
+    Logger.d("HydraCore.signIn", "Signed in successfully")
+
+  }
+
+  fun updateUser(
+    userDetails: ReadableMap?,
+    customAttributes: ReadableMap?,
+    subscriptions: ReadableArray?,
+    promise: Promise?
+  ) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.updateUser", "Hydra instance not initialized")
+      promise?.reject("Error Updating user details", "Hydra instance not initialized", Throwable())
+      return
+    }
+
+    val customerId: String? = userDetails?.getString("customerId")
+    val firstName: String? = userDetails?.getString("firstName")
+    val lastName: String? = userDetails?.getString("lastName")
+    val email: String? = userDetails?.getString("email")
+    val phone: String? = userDetails?.getString("phone")
+
+    if (customerId == null) {
+      Logger.e("HydraCore.updateUser", "CustomerId can not be null")
+      promise?.reject("Error Updating user details", "CustomerId can not be null", Throwable())
+      return
+    }
+
+    hydraAPI!!.pushUserUpdate(
+      customerId,
+      firstName,
+      lastName,
+      email,
+      phone,
+      customAttributes?.let { customAttributes.toMap() },
+      subscriptions?.let { subscriptions.toList() }
+    )
+
+    promise?.resolve(true)
+    Logger.d("HydraCore.updateUser", "User details updated successfully")
+  }
+
+  fun signOut(customerId: String?, promise: Promise?) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.signOut", "Hydra instance not initialized")
+      promise?.reject("Error Signing out", "Hydra instance not initialized", Throwable())
+      return
+    }
+
+    if (customerId == null) {
+      Logger.e("HydraCore.signOut", "Customer id can not be null")
+      promise?.reject("Error Signing out", "Customer id can not be null", Throwable())
+      return
+    }
+
+    hydraAPI!!.pushUserSignOut(customerId)
+    promise?.resolve(true)
+    Logger.d("HydraCore.signOut", "User signed out successfully")
+  }
+
+  fun reportUserEvent(eventName: String?, attributes: ReadableMap?, promise: Promise?) {
+    if (hydraAPI == null) {
+      Logger.e("HydraCore.reportUserEvent", "Hydra instance not initialized")
+      promise?.reject("Error Reporting user event", "Hydra instance not initialized", Throwable())
+    }
+
+    if (eventName == null) {
+      Logger.e("HydraCore.reportUserEvent", "Event name cannot be null")
+      promise?.reject("Error Reporting user event", "Event name cannot be null", Throwable())
+    }
+
+    hydraAPI!!.pushEvent(eventName!!, attributes?.toMap())
+    promise?.resolve(true)
+    Logger.d("HydraCore.reportUserEvent", "User event reported successfully")
+  }
+
+  fun identify(userDetails: ReadableMap?, customData: ReadableMap?, promise: Promise?) {
+    signIn(userDetails, customData, promise)
+  }
+
+  fun track(eventName: String?, attributes: ReadableMap?, promise: Promise?) {
+    reportUserEvent(eventName, attributes, promise)
+  }
+
+  fun reset(customerId: String?, promise: Promise?) {
+    signOut(customerId, promise)
+  }
+
+  fun isSdkInitialized(promise: Promise?) {
+    val isInitialized = hydraAPI != null
+    Logger.d("HydraCore.isSdkInitialized", "SDK initialization status: $isInitialized")
+    promise?.resolve(isInitialized)
+  }
+
+  fun getCurrentUserState(promise: Promise?) {
+    try {
+      val userState = hydraAPI?.getCurrentUserState()
+      val stateString = userState?.name
+      Logger.d("HydraCore.getCurrentUserState", "Current user state: $stateString")
+      promise?.resolve(stateString)
+    } catch (e: Exception) {
+      Logger.e("HydraCore.getCurrentUserState", "Error getting current user state: ${e.message}")
+      promise?.reject("Error", "Failed to get current user state", e)
+    }
+  }
+
+  fun getVisitorDetails(promise: Promise?) {
+    try {
+      val anonymousId = hydraAPI?.getAnonymousId()
+      if (!anonymousId.isNullOrEmpty()) {
+        val visitorMap: WritableMap = Arguments.createMap()
+        visitorMap.putString("visitorId", anonymousId)
+        promise?.resolve(visitorMap)
+      } else {
+        Logger.d("HydraCore.getVisitorDetails", "Visitor details not available")
+        promise?.resolve(null)
+      }
+    } catch (e: Exception) {
+      Logger.e("HydraCore.getVisitorDetails", "Error getting visitor details: ${e.message}")
+      promise?.reject("Error", "Failed to get visitor details", e)
+    }
+  }
+
+  fun isVisitorFlowEnabled(promise: Promise?) {
+    try {
+      val isEnabled = if (appContext != null) {
+        HydraAPI.isVisitorFlowEnabled(appContext!!)
+      } else {
+        false
+      }
+      Logger.d("HydraCore.isVisitorFlowEnabled", "Visitor flow enabled: $isEnabled")
+      promise?.resolve(isEnabled)
+    } catch (e: Exception) {
+      Logger.e("HydraCore.isVisitorFlowEnabled", "Error checking visitor flow: ${e.message}")
+      promise?.reject("Error", "Failed to check visitor flow", e)
+    }
+  }
+
+  fun gamificationScreenAppeared(
+    screenName: String?,
+    promise: Promise?
+  ){
+    val activity = curReactActivity
+    if (activity != null) {
+      activity.runOnUiThread {
+        // Synchronized against initHydraInstance's read-and-clear so the manager readiness
+        // check and the queueing of the screen name happen atomically relative to it.
+        synchronized(gamificationLock) {
+          val manager = gamificationUIManager
+          if (manager != null) {
+            manager.onScreenChanged(activity, screenName ?: "")
+          } else {
+            pendingGamificationScreen = screenName
+          }
+        }
+      }
+    }
+    promise?.resolve(true)
+  }
+
+  fun gamificationScreenDisappeared(promise: Promise?){
+    synchronized(gamificationLock) {
+      pendingGamificationScreen = null
+    }
+    curReactActivity?.let {
+      it.runOnUiThread {
+        gamificationUIManager?.onActivityDestroyed(it)
+      }
+    }
+    promise?.resolve(true)
+  }
+
+  fun setCapToken(token: String, promise: Promise) {
+    getFlowManager()?.setCapToken(token)
+    promise.resolve(null)
+  }
+
+}