react-native-acoustic-connect-beta 18.0.14 → 18.0.15

package/android/src/main/java/com/acousticconnectrn/HybridAcousticConnectRN.kt

@@ -13,16 +13,23 @@
 package com.acousticconnectrn
 
 import android.app.Activity
+import android.app.AlertDialog
 import android.app.Application
+import android.app.Dialog
 import android.content.Context
+import android.content.ContextWrapper
+import android.os.Build
 import android.os.Handler
 import android.os.Looper
 import android.text.TextUtils
+import android.util.Log
 import android.view.View
 import android.view.View.OnFocusChangeListener
+import android.view.WindowManager
 import android.view.inputmethod.InputMethodManager
 import android.widget.EditText
 import android.widget.TextView
+import androidx.fragment.app.DialogFragment
 import com.acoustic.connect.android.connectmod.Connect
 import com.acoustic.connect.android.connectmod.Connect.TLF_ON_FOCUS_CHANGE_IN
 import com.acoustic.connect.android.connectmod.Connect.TLF_ON_FOCUS_CHANGE_OUT
@@ -46,470 +53,759 @@ import com.facebook.react.uimanager.NativeViewHierarchyManager
 import com.facebook.react.uimanager.UIManagerModule
 import com.ibm.eo.EOCore
 import com.ibm.eo.model.EOMonitoringLevel
-import com.margelo.nitro.NitroModules
+import com.margelo.nitro.NitroModules.Companion.applicationContext
 import com.margelo.nitro.acousticconnectrn.HybridAcousticConnectRNSpec
 import com.margelo.nitro.acousticconnectrn.Variant_String_Double_Boolean
 import com.tl.uic.Tealeaf
 import com.tl.uic.model.ScreenviewType
+import com.tl.uic.util.DialogUtil
 import com.tl.uic.util.LayoutUtil
 import com.tl.uic.util.keyboardview.KeyboardView
 import java.util.Objects
 
-class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext) : HybridAcousticConnectRNSpec(), LifecycleEventListener {
-
-  init {
-    // Add your listener logic here
-    println("HybridAcousticConnectRNSpec has been initialized")
-
-    Handler(Looper.getMainLooper()).post {
-      if (reactContext.hasActiveCatalystInstance()) {
-        reactContext.addLifecycleEventListener(this)
-      } else {
-        println("ReactContext is not ready. LifecycleEventListener not registered.")
-      }
-    }
-  }
-
-  /**
-   * Sets the module's boolean configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
-   *
-   * @param key        Map Key.
-   * @param value      Boolean Value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun setBooleanConfigItemForKey(
-    key: String,
-    value: Boolean,
-    moduleName: String
-  ): Boolean {
-    val result: Boolean =
-      EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
-    return result
-  }
-
-  /**
-   * Sets the module's string configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
-   *
-   * @param key        Map Key.
-   * @param value      String Value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun setStringItemForKey(
-    key: String,
-    value: String,
-    moduleName: String
-  ): Boolean {
-    val result = EOCore.updateConfig(key, value, EOCore.getLifecycleObject(moduleName))
-    return result
-  }
-
-  /**
-   * Sets the module's number configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
-   *
-   * @param key        Map Key.
-   * @param value      Number Value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun setNumberItemForKey(
-    key: String,
-    value: Double,
-    moduleName: String
-  ): Boolean {
-    val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
-    return result
-  }
-
-  /**
-   * Sets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
-   *
-   * @param key        Map Key.
-   * @param value      Map Value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @param promise    Javascript Promise interface.
-   */
-  override fun setConfigItemForKey(
-    key: String,
-    value: Variant_String_Double_Boolean,
-    moduleName: String
-  ): Boolean {
-    val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
-    return result
-  }
-
-  /**
-   * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a BOOL value.
-   *
-   * @param theDefault In case no value if found, use this value as default.
-   * @param key        Key value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun getBooleanConfigItemForKey(
-    theDefault: Boolean,
-    key: String,
-    moduleName: String
-  ): Boolean {
-    val result = EOCore.getConfigItemBoolean(key, EOCore.getLifecycleObject(moduleName))
-    if (result == false) {
-      return theDefault
-    }
-    return result
-  }
-
-  /**
-   * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a String value.
-   *
-   * @param theDefault In case no value if found, use this value as default.
-   * @param key        Key value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return String value if the operation was successful, null otherwise.
-   */
-  override fun getStringItemForKey(theDefault: String, key: String, moduleName: String): String? {
-    var result = EOCore.getConfigItemString(key, EOCore.getLifecycleObject(moduleName))
-    if (TextUtils.isEmpty(result)) {
-      result = theDefault
-    }
-    return result
-  }
-
-  /**
-   * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a double value.
-   *
-   * @param theDefault In case no value if found, use this value as default.
-   * @param key        Key value.
-   * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
-   * @return Double value if the operation was successful, 0.0 otherwise.
-   */
-  override fun getNumberItemForKey(theDefault: Double, key: String, moduleName: String): Double {
-    var result = EOCore.getConfigItemDouble(key, EOCore.getLifecycleObject(moduleName))
-    if (result == -1.0) {
-      result = theDefault
-    }
-    return result
-  }
-
-  /**
-   * Logs a custom event with the specified name and values.
-   *
-   * @param eventName The name of the event to be logged this will appear in the posted json.
-   * @param values    A map of values associated with the event.
-   * @param level     Set a custom log level to the event. This will override the configured log level for that event.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logCustomEvent(
-    eventName: String,
-    values: Map<String, Variant_String_Double_Boolean>,
-    level: Double
-  ): Boolean {
-    val result = Connect.logCustomEvent(eventName, convertToMap(values), level.toInt())
-    return result
-  }
-
-  /**
-   * Logs a signal with the specified values.
-   *
-   * @param values A map of values associated with the signal.
-   * @param level  Set a custom log level to the event. This will override the configured log level for that event.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logSignal(
-    values: Map<String, Variant_String_Double_Boolean>,
-    level: Double
-  ): Boolean {
-    val result = Connect.logSignal(convertToMapAny(values), level.toInt())
-    return result
-  }
-
-  /**
-   * Logs an exception event with the specified message and stack information.
-   *
-   * @param message    The message associated with the exception.
-   * @param stackInfo  The stack information associated with the exception.
-   * @param unhandled  Indicates whether the exception is unhandled.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logExceptionEvent(message: String, stackInfo: String, unhandled: Boolean): Boolean {
-    val result = Connect.logExceptionEvent("React Plugin", message, stackInfo, unhandled)
-    return result
-  }
-
-  /**
-   * Logs the current location.
-   *
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logLocation(): Boolean {
-    val result = logGeolocation(EOMonitoringLevel.kEOMonitoringLevelInfo.value)
-    return result
-  }
-
-  /**
-   * Logs the current location with the specified latitude and longitude.
-   *
-   * @param latitude  The latitude of the location.
-   * @param longitude The longitude of the location.
-   * @param level     Set a custom log level to the event. This will override the configured log level for that event.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logLocationWithLatitudeLongitude(
-    latitude: Double,
-    longitude: Double,
-    level: Double
-  ): Boolean {
-    val result = logLocationUpdateEventWithLatitude(latitude, longitude, level.toInt())
-    return result
-  }
-
-  /**
-   * Log click events on react native control.
-   *
-   * @param target    Target id of the control.
-   * @param controlId Accessibility ID(virtual id).
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logClickEvent(target: Double, controlId: String): Boolean {
-    var result = false
-    try {
-      val context: ReactApplicationContext = reactContext
-      // Add UI-block so we can get a valid reference to the map-view
-      val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-      Objects.requireNonNull<UIManagerModule?>(uiManager)
-        .addUIBlock { nvhm: NativeViewHierarchyManager ->
-          val view = nvhm.resolveView(target.toInt())
-          if (view == null) {
-            result = false
-          } else {
-            if (view is EditText) {
-              addFocusAndRegister(view, null, getCurrentActivity()!!)
+
+class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext) : HybridAcousticConnectRNSpec(),
+    LifecycleEventListener {
+
+    init {
+        // Add your listener logic here
+        Log.v(TAG, "HybridAcousticConnectRNSpec has been initialized")
+
+        Handler(Looper.getMainLooper()).post {
+            if (reactContext.hasActiveCatalystInstance()) {
+                reactContext.addLifecycleEventListener(this)
             } else {
-              if (!TextUtils.isEmpty(controlId)) {
-                logEvent(view, "click", controlId)
-              } else {
-                logEvent(view, "click")
-              }
+                Log.v(TAG, "ReactContext is not ready. LifecycleEventListener not registered.")
             }
-            result = true
-          }
         }
-    } catch (e: java.lang.Exception) {
-      // Handle the exception
-      result = false
-    }
-    return result
-  }
-
-  /**
-   * Log click events on react native control.
-   *
-   * @param target    Target id of the control.
-   * @return True if the operation was successful, false otherwise.
-   */
-  fun logClickEvent(target: Double): Boolean {
-    var result = false
-    try {
-      val context: ReactApplicationContext = reactContext
-      // Add UI-block so we can get a valid reference to the map-view
-      val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-      Objects.requireNonNull<UIManagerModule?>(uiManager)
-        .addUIBlock { nvhm: NativeViewHierarchyManager ->
-          val view = nvhm.resolveView(target.toInt())
-          if (view == null) {
+    }
+
+    /**
+     * Sets the module's boolean configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
+     *
+     * @param key        Map Key.
+     * @param value      Boolean Value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun setBooleanConfigItemForKey(
+        key: String,
+        value: Boolean,
+        moduleName: String
+    ): Boolean {
+        val result: Boolean =
+            EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
+        return result
+    }
+
+    /**
+     * Sets the module's string configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
+     *
+     * @param key        Map Key.
+     * @param value      String Value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun setStringItemForKey(
+        key: String,
+        value: String,
+        moduleName: String
+    ): Boolean {
+        val result = EOCore.updateConfig(key, value, EOCore.getLifecycleObject(moduleName))
+        return result
+    }
+
+    /**
+     * Sets the module's number configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
+     *
+     * @param key        Map Key.
+     * @param value      Number Value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun setNumberItemForKey(
+        key: String,
+        value: Double,
+        moduleName: String
+    ): Boolean {
+        val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
+        return result
+    }
+
+    /**
+     * Sets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
+     *
+     * @param key        Map Key.
+     * @param value      Map Value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @param promise    Javascript Promise interface.
+     */
+    override fun setConfigItemForKey(
+        key: String,
+        value: Variant_String_Double_Boolean,
+        moduleName: String
+    ): Boolean {
+        val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
+        return result
+    }
+
+    /**
+     * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a BOOL value.
+     *
+     * @param theDefault In case no value if found, use this value as default.
+     * @param key        Key value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun getBooleanConfigItemForKey(
+        theDefault: Boolean,
+        key: String,
+        moduleName: String
+    ): Boolean {
+        val result = EOCore.getConfigItemBoolean(key, EOCore.getLifecycleObject(moduleName))
+        if (result == false) {
+            return theDefault
+        }
+        return result
+    }
+
+    /**
+     * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a String value.
+     *
+     * @param theDefault In case no value if found, use this value as default.
+     * @param key        Key value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return String value if the operation was successful, null otherwise.
+     */
+    override fun getStringItemForKey(theDefault: String, key: String, moduleName: String): String? {
+        var result = EOCore.getConfigItemString(key, EOCore.getLifecycleObject(moduleName))
+        if (TextUtils.isEmpty(result)) {
+            result = theDefault
+        }
+        return result
+    }
+
+    /**
+     * Gets the module's configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key as a double value.
+     *
+     * @param theDefault In case no value if found, use this value as default.
+     * @param key        Key value.
+     * @param moduleName The class name of the module's EOLifecycleObject for which the configuration item is referencing.
+     * @return Double value if the operation was successful, 0.0 otherwise.
+     */
+    override fun getNumberItemForKey(theDefault: Double, key: String, moduleName: String): Double {
+        var result = EOCore.getConfigItemDouble(key, EOCore.getLifecycleObject(moduleName))
+        if (result == -1.0) {
+            result = theDefault
+        }
+        return result
+    }
+
+    /**
+     * Logs a custom event with the specified name and values.
+     *
+     * @param eventName The name of the event to be logged this will appear in the posted json.
+     * @param values    A map of values associated with the event.
+     * @param level     Set a custom log level to the event. This will override the configured log level for that event.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logCustomEvent(
+        eventName: String,
+        values: Map<String, Variant_String_Double_Boolean>,
+        level: Double
+    ): Boolean {
+        val result = Connect.logCustomEvent(eventName, convertToMap(values), level.toInt())
+        return result
+    }
+
+    /**
+     * Logs a signal with the specified values.
+     *
+     * @param values A map of values associated with the signal.
+     * @param level  Set a custom log level to the event. This will override the configured log level for that event.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logSignal(
+        values: Map<String, Variant_String_Double_Boolean>,
+        level: Double
+    ): Boolean {
+        val result = Connect.logSignal(convertToMapAny(values), level.toInt())
+        return result
+    }
+
+    /**
+     * Logs an exception event with the specified message and stack information.
+     *
+     * @param message    The message associated with the exception.
+     * @param stackInfo  The stack information associated with the exception.
+     * @param unhandled  Indicates whether the exception is unhandled.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logExceptionEvent(message: String, stackInfo: String, unhandled: Boolean): Boolean {
+        val result = Connect.logExceptionEvent("React Plugin", message, stackInfo, unhandled)
+        return result
+    }
+
+    /**
+     * Logs the current location.
+     *
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logLocation(): Boolean {
+        val result = logGeolocation(EOMonitoringLevel.kEOMonitoringLevelInfo.value)
+        return result
+    }
+
+    /**
+     * Logs the current location with the specified latitude and longitude.
+     *
+     * @param latitude  The latitude of the location.
+     * @param longitude The longitude of the location.
+     * @param level     Set a custom log level to the event. This will override the configured log level for that event.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logLocationWithLatitudeLongitude(
+        latitude: Double,
+        longitude: Double,
+        level: Double
+    ): Boolean {
+        val result = logLocationUpdateEventWithLatitude(latitude, longitude, level.toInt())
+        return result
+    }
+
+    /**
+     * Log click events on react native control.
+     *
+     * @param target    Target id of the control.
+     * @param controlId Accessibility ID(virtual id).
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logClickEvent(target: Double, controlId: String): Boolean {
+        var result = false
+        try {
+            val context: ReactApplicationContext = reactContext
+            // Add UI-block so we can get a valid reference to the map-view
+            val uiManager = context.getNativeModule(UIManagerModule::class.java)
+
+            Objects.requireNonNull<UIManagerModule?>(uiManager)
+                .addUIBlock { nvhm: NativeViewHierarchyManager ->
+                    val view = nvhm.resolveView(target.toInt())
+                    if (view == null) {
+                        result = false
+                    } else {
+                        if (view is EditText) {
+                            addFocusAndRegister(view, null, getCurrentActivity()!!)
+                        } else {
+                            if (!TextUtils.isEmpty(controlId)) {
+                                logEvent(view, "click", controlId)
+                            } else {
+                                logEvent(view, "click")
+                            }
+                        }
+                        result = true
+                    }
+                }
+        } catch (e: java.lang.Exception) {
+            // Handle the exception
+            result = false
+        }
+        return result
+    }
+
+    /**
+     * Log click events on react native control.
+     *
+     * @param target    Target id of the control.
+     * @return True if the operation was successful, false otherwise.
+     */
+    fun logClickEvent(target: Double): Boolean {
+        var result = false
+        try {
+            val context: ReactApplicationContext = reactContext
+            // Add UI-block so we can get a valid reference to the map-view
+            val uiManager = context.getNativeModule(UIManagerModule::class.java)
+
+            Objects.requireNonNull<UIManagerModule?>(uiManager)
+                .addUIBlock { nvhm: NativeViewHierarchyManager ->
+                    val view = nvhm.resolveView(target.toInt())
+                    if (view == null) {
+                        result = false
+                    } else {
+                        if (view is EditText) {
+                            addFocusAndRegister(view as EditText, null, getCurrentActivity()!!)
+                        } else {
+                            logEvent(view, "click")
+                        }
+                        result = true
+                    }
+                }
+        } catch (e: java.lang.Exception) {
+            // Handle the exception
             result = false
-          } else {
-            if (view is EditText) {
-              addFocusAndRegister(view as EditText, null, getCurrentActivity()!!)
+        }
+        return result
+    }
+
+    /**
+     * Log EditText change event.
+     *
+     * @param target    A valid native View Id for lookup.
+     * @param controlId Accessibility ID(virtual id).
+     * @param text      The input string.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logTextChangeEvent(target: Double, controlId: String, text: String?): Boolean {
+        var result = false
+        try {
+            val context: ReactApplicationContext = reactContext
+            // Add UI-block so we can get a valid reference to the map-view
+            val uiManager = context.getNativeModule(UIManagerModule::class.java)
+
+            Objects.requireNonNull<UIManagerModule?>(uiManager)
+                .addUIBlock { nvhm: NativeViewHierarchyManager ->
+                    val view = nvhm.resolveView(target.toInt())
+                    if (view == null) {
+                        result = false
+                    } else {
+                        if (view is EditText && (view as EditText).onFocusChangeListener == null) {
+                            // First time, logEvent and subsequent calls will be handled in change listener
+                            logEvent(view, TLF_ON_FOCUS_CHANGE_IN, controlId)
+                            addFocusAndRegister(view as EditText, controlId, getCurrentActivity()!!)
+                        }
+                        result = true
+                    }
+                }
+        } catch (e: java.lang.Exception) {
+            // Handle the exception
+            result = false
+        }
+        return result
+    }
+
+    /**
+     * Requests that the framework save the current application page name.
+     *
+     * @param logicalPageName The logical page name to be set.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun setCurrentScreenName(logicalPageName: String): Boolean {
+        val result = resumeConnect(getCurrentActivity(), logicalPageName, false)
+        return result
+    }
+
+    /**
+     * Requests that the framework logs an screen load event.
+     *
+     * @param logicalPageName The logical page name to be set.
+     * @param referrer        The referrer for the screen view.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logScreenViewContextLoad(logicalPageName: String?, referrer: String?): Boolean {
+        val result = logScreenview(getCurrentActivity()!!, logicalPageName.toString(), ScreenviewType.LOAD, referrer);
+        return result
+    }
+
+    /**
+     * Requests that the framework logs an screen unload event.
+     *
+     * @param logicalPageName The logical page name to be set.
+     * @param referrer        The referrer for the screen view.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logScreenViewContextUnload(logicalPageName: String?, referrer: String?): Boolean {
+        val result = logScreenview(getCurrentActivity()!!, logicalPageName.toString(), ScreenviewType.UNLOAD, referrer);
+        return result
+    }
+
+    /**
+     * Log Current Screen Layout using native side background thread.
+     *
+     * @param name  Page name or title e.g. "Login View Controller"; Must not be empty.
+     * @param delay The delay in milliseconds before logging the event.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logScreenLayout(name: String, delay: Double): Boolean {
+        setCurrentScreenName(name)
+        logScreenview(getCurrentActivity(), name, ScreenviewType.LOAD)
+        var result = false
+        if (LayoutUtil.canCaptureUserEvents(null, name)) {
+            result = logScreenLayout(
+                Objects.requireNonNull<Activity?>(getCurrentActivity()),
+                name,
+                if (delay.toInt() < 0) 300 else delay.toInt(),
+                true
+            )
+        }
+        return result
+    }
+
+    /**
+     * Logs a dialog show event with the specified dialog information.
+     *
+     * @param dialogId    Unique identifier for the dialog.
+     * @param dialogTitle The title of the dialog.
+     * @param dialogType  The type of dialog (alert, custom, modal).
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logDialogShowEvent(dialogId: String, dialogTitle: String, dialogType: String): Boolean {
+        var result: Boolean
+
+        try {
+            // Your existing logging code...
+            val values = HashMap<String?, String?>()
+            values["dialogId"] = dialogId
+            values["dialogTitle"] = dialogTitle
+            values["dialogType"] = dialogType
+            values["eventType"] = "dialog_show"
+            values["timestamp"] = System.currentTimeMillis().toString()
+
+            // For Alert dialogs, use delayed capture to ensure dialog is rendered
+            if (dialogType == "alert") {
+                // Schedule delayed capture to allow dialog to render
+                Handler(Looper.getMainLooper()).postDelayed({
+                    try {
+                        val dialog = findMostRecentDialog()
+                        if (dialog != null) {
+                            val activity = getCurrentActivity()
+                            if (activity != null) {
+                                DialogUtil.logDialog(getCurrentActivity(), dialog)
+//                                Tealeaf.logScreenLayoutSetOnShowListener(activity, dialog, dialogId, true)
+                                Log.v(TAG, "Delayed screenshot capture successful for dialog: $dialogId")
+                            }
+                        } else {
+                            Log.v(TAG, "Warning: Could not find dialog object for $dialogId after delay")
+                            // Fallback to regular screen layout capture
+                            logScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 0, true)
+                        }
+                    } catch (e: Exception) {
+                        Log.v(TAG, "Error in delayed dialog capture: ${e.message}")
+                        // Fallback to regular screen layout capture
+                        logScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 0, true)
+                    }
+                }, DIALOG_CAPTURE_DELAY_MS) // Use configurable delay
+
+                // Return true immediately since we're handling capture asynchronously
+                result = true
             } else {
-              logEvent(view, "click")
+                // For non-alert dialogs, try immediate capture first
+                val dialog = findMostRecentDialog()
+                if (dialog != null) {
+                    val activity = getCurrentActivity()
+                    if (activity != null) {
+                        DialogUtil.logDialog(getCurrentActivity(), dialog)
+                        return true
+                    } else {
+                        result = false
+                    }
+                } else {
+                    // Default fallback
+                    result = logScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 300, true)
+                }
             }
-            result = true
-          }
-        }
-    } catch (e: java.lang.Exception) {
-      // Handle the exception
-      result = false
-    }
-    return result
-  }
-
-  /**
-   * Log EditText change event.
-   *
-   * @param target    A valid native View Id for lookup.
-   * @param controlId Accessibility ID(virtual id).
-   * @param text      The input string.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logTextChangeEvent(target: Double, controlId: String, text: String?): Boolean {
-    var result = false
-    try {
-      val context: ReactApplicationContext = reactContext
-      // Add UI-block so we can get a valid reference to the map-view
-      val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-      Objects.requireNonNull<UIManagerModule?>(uiManager)
-        .addUIBlock { nvhm: NativeViewHierarchyManager ->
-          val view = nvhm.resolveView(target.toInt())
-          if (view == null) {
+        } catch (e: Exception) {
+            Log.v(TAG, "Error logging dialog show event: ${e.message}")
             result = false
-          } else {
-            if (view is EditText && (view as EditText).onFocusChangeListener == null) {
-              // First time, logEvent and subsequent calls will be handled in change listener
-              logEvent(view, TLF_ON_FOCUS_CHANGE_IN, controlId)
-              addFocusAndRegister(view as EditText, controlId, getCurrentActivity()!!)
+        }
+        return result
+    }
+
+    private fun findMostRecentDialog(): Dialog? {
+        val activity = getCurrentActivity() ?: return null
+
+        // Check fragments first
+        val fragmentDialog = findDialogFromFragments(activity)
+        if (fragmentDialog != null) return fragmentDialog
+
+        // Check window manager for Alert dialogs with retry logic
+        return findLatestDialogFromWindowManager(activity)
+    }
+
+    private fun findDialogFromFragments(activity: Activity): Dialog? {
+        try {
+            // Check support fragments first (more common in modern apps)
+            if (activity is androidx.fragment.app.FragmentActivity) {
+                val supportFm = activity.supportFragmentManager
+                for (frag in supportFm.fragments) {
+                    if (frag is androidx.fragment.app.DialogFragment) {
+                        val dialog = frag.dialog
+                        if (dialog != null && dialog.isShowing) {
+                            return dialog
+                        }
+                    }
+                }
+            }
+
+            // Check legacy fragments
+            // Note: fm.fragments is only available in API 26+, so we'll skip this for older versions
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val fm = activity.fragmentManager
+                if (fm != null) {
+                    for (frag in fm.fragments) {
+                        if (frag is DialogFragment) {
+                            val dialog = frag.dialog
+                            if (dialog != null && dialog.isShowing) {
+                                return dialog
+                            }
+                        }
+                    }
+                }
             }
-            result = true
-          }
+        } catch (e: Exception) {
+            Log.v(TAG, "Error checking fragments: ${e.message}")
         }
-    } catch (e: java.lang.Exception) {
-      // Handle the exception
-      result = false
-    }
-    return result
-  }
-
-  /**
-   * Requests that the framework save the current application page name.
-   *
-   * @param logicalPageName The logical page name to be set.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun setCurrentScreenName(logicalPageName: String): Boolean {
-    val result = resumeConnect(getCurrentActivity(), logicalPageName, false)
-    return result
-  }
-
-  /**
-   * Requests that the framework logs an screen load event.
-   *
-   * @param logicalPageName The logical page name to be set.
-   * @param referrer        The referrer for the screen view.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logScreenViewContextLoad(logicalPageName: String?, referrer: String?): Boolean {
-    val result = logScreenview(getCurrentActivity()!!, logicalPageName.toString(), ScreenviewType.LOAD, referrer);
-    return result
-  }
-
-  /**
-   * Requests that the framework logs an screen unload event.
-   *
-   * @param logicalPageName The logical page name to be set.
-   * @param referrer        The referrer for the screen view.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logScreenViewContextUnload(logicalPageName: String?, referrer: String?): Boolean {
-    val result = logScreenview(getCurrentActivity()!!, logicalPageName.toString(), ScreenviewType.UNLOAD, referrer);
-    return result
-  }
-
-  /**
-   * Log Current Screen Layout using native side background thread.
-   *
-   * @param name  Page name or title e.g. "Login View Controller"; Must not be empty.
-   * @param delay The delay in milliseconds before logging the event.
-   * @return True if the operation was successful, false otherwise.
-   */
-  override fun logScreenLayout(name: String, delay: Double): Boolean {
-    setCurrentScreenName(name)
-    logScreenview(getCurrentActivity(), name, ScreenviewType.LOAD)
-    var result = false
-    if (LayoutUtil.canCaptureUserEvents(null, name)) {
-      result = logScreenLayout(
-        Objects.requireNonNull<Activity?>(getCurrentActivity()),
-        name,
-        if (delay.toInt() < 0) 300 else delay.toInt(),
-        true
-      )
-    }
-    return result
-  }
-
-  /**
-   * Converts a map of Variant_String_Double_Boolean to a HashMap<String?, String?>.
-   *
-   * @param values The map to be converted.
-   * @return A HashMap<String?, String?> representation of the input map which library can use.
-   */
-  private fun convertToMap(values: Map<String, Variant_String_Double_Boolean>): HashMap<String?, String?> {
-    val map = HashMap<String?, String?>()
-    for (key in values.keys) {
-      val value = values[key]
-      if (value != null) {
-        map[key] = value.toString()
-      }
-    }
-    return map
-  }
-
-  /**
-   * Converts a map of Variant_String_Double_Boolean to a HashMap<String?, String?>.
-   *
-   * @param values The map to be converted.
-   * @return A HashMap<String?, String?> representation of the input map which library can use.
-   */
-  private fun convertToMapAny(values: Map<String, Variant_String_Double_Boolean>): java.util.HashMap<String?, Any?>? {
-    val map = HashMap<String?, Any?>()
-    for (key in values.keys) {
-      val value = values[key]
-      if (value != null) {
-        map[key] = value
-      }
-    }
-    return map
-  }
-
-  /**
-   * Gets the current activity from the ReactApplicationContext.
-   *
-   * @return The current activity or null if not available.
-   */
-  private fun getCurrentActivity(): android.app.Activity? {
-    return reactContext.currentActivity
-  }
-
-  /**
-   * Add focus listener to handle EditText UI control.
-   *
-   * @param textView        Input TextView.
-   * @param accessibilityID Accessibility ID(virtual id).
-   * @param activity        Current activity.
-   */
-  fun addFocusAndRegister(textView: TextView, accessibilityID: String?, activity: Activity) {
-    textView.onFocusChangeListener = OnFocusChangeListener { v: View, hasFocus: Boolean ->
-      if (hasFocus) {
-        val imm = v.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-        imm.showSoftInput(v, InputMethodManager.SHOW_FORCED)
-        val keyboardView = KeyboardView(v.context.applicationContext, null)
-
-        if (TextUtils.isEmpty(accessibilityID)) {
-          logEvent(keyboardView, TLF_UI_KEYBOARD_DID_SHOW_NOTIFICATION)
-          logEvent(v, TLF_ON_FOCUS_CHANGE_IN)
-        } else {
-          logEvent(keyboardView, TLF_UI_KEYBOARD_DID_SHOW_NOTIFICATION, accessibilityID!!)
-          logEvent(v, TLF_ON_FOCUS_CHANGE_IN, accessibilityID!!)
+        return null
+    }
+
+    private fun findLatestDialogFromWindowManager(activity: Activity): Dialog? {
+        try {
+            val wmgClass = Class.forName("android.view.WindowManagerGlobal")
+            val wmgInstance = wmgClass.getMethod("getInstance").invoke(null)
+
+            val viewsField = wmgClass.getDeclaredField("mViews")
+            viewsField.isAccessible = true
+            val views = viewsField.get(wmgInstance) as ArrayList<View>
+
+            val paramsField = wmgClass.getDeclaredField("mParams")
+            paramsField.isAccessible = true
+            val params = paramsField.get(wmgInstance) as ArrayList<WindowManager.LayoutParams>
+
+            // Find the most recent dialog window (last in the list)
+            for (i in views.indices.reversed()) {
+                val view = views[i]
+                val param = params[i]
+
+                if (isDialogWindow(param)) {
+                    // Try to get dialog from view context
+                    var context = view.context
+                    while (context is ContextWrapper) {
+                        if (context is Dialog && context.isShowing) {
+                            Log.v(TAG, "Found dialog in WindowManager: ${context.javaClass.simpleName}")
+                            return context
+                        }
+                        context = context.baseContext
+                    }
+
+                    // Additional check: look for AlertDialog specifically
+                    if (view.javaClass.name.contains("AlertController")) {
+                        Log.v(TAG, "Found AlertController view, attempting to get dialog")
+                        // Try to find the dialog through the view's parent or other means
+                        val parent = view.parent
+                        if (parent is View) {
+                            var parentContext = parent.context
+                            while (parentContext is ContextWrapper) {
+                                if (parentContext is Dialog && parentContext.isShowing) {
+                                    Log.v(TAG, "Found AlertDialog through parent context")
+                                    return parentContext
+                                }
+                                parentContext = parentContext.baseContext
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.v(TAG, "Error accessing WindowManager: ${e.message}")
         }
-      } else {
-        logEvent(v, TLF_ON_FOCUS_CHANGE_OUT)
-        val imm = v.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
-        imm.hideSoftInputFromWindow(v.windowToken, 0)
+        return null
+    }
 
-        val keyboardView = KeyboardView(v.context.applicationContext, null)
+    private fun isDialogWindow(params: WindowManager.LayoutParams): Boolean {
+        return params.type == WindowManager.LayoutParams.TYPE_APPLICATION_PANEL ||
+                params.type == WindowManager.LayoutParams.TYPE_APPLICATION_SUB_PANEL ||
+                (params.flags and WindowManager.LayoutParams.FLAG_DIM_BEHIND) != 0
+    }
 
-        if (TextUtils.isEmpty(accessibilityID)) {
-          logEvent(keyboardView, TLF_UI_KEYBOARD_DID_HIDE_NOTIFICATION)
-        } else {
-          logEvent(keyboardView, TLF_UI_KEYBOARD_DID_HIDE_NOTIFICATION, accessibilityID!!)
+    /**
+     * Logs a dialog dismiss event with the specified dialog information.
+     *
+     * @param dialogId      Unique identifier for the dialog.
+     * @param dismissReason The reason for dismissing the dialog.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logDialogDismissEvent(dialogId: String, dismissReason: String): Boolean {
+        var result = false
+        try {
+            val values = HashMap<String?, String?>()
+            values["dialogId"] = dialogId
+            values["dismissReason"] = dismissReason
+            values["eventType"] = "dialog_dismiss"
+            values["timestamp"] = System.currentTimeMillis().toString()
+
+            result =
+                Connect.logCustomEvent("DialogDismissEvent", values, EOMonitoringLevel.kEOMonitoringLevelInfo.value)
+        } catch (e: Exception) {
+            Log.v(TAG, "Error logging dialog dismiss event: ${e.message}")
+            result = false
+        }
+        return result
+    }
+
+    /**
+     * Logs a dialog button click event with the specified button information.
+     *
+     * @param dialogId    Unique identifier for the dialog.
+     * @param buttonText  The text of the clicked button.
+     * @param buttonIndex The index of the clicked button.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logDialogButtonClickEvent(dialogId: String, buttonText: String, buttonIndex: Double): Boolean {
+        var result: Boolean
+
+        try {
+            val values = HashMap<String?, String?>()
+            values["dialogId"] = dialogId
+            values["buttonText"] = buttonText
+            values["buttonIndex"] = buttonIndex.toInt().toString()
+            values["eventType"] = "dialog_button_click"
+            values["timestamp"] = System.currentTimeMillis().toString()
+
+            result = Connect.logCustomEvent("DialogButtonClickEvent", values, EOMonitoringLevel.kEOMonitoringLevelInfo.value)
+
+            // TODO:  JS pass button id
+            // Simple approach: find the most recently shown dialog
+//            val dialog = findMostRecentDialog()
+//            if (dialog != null) {
+//                val activity = getCurrentActivity()
+//                if (activity != null) {
+//                    val view = when (dialog) {
+//                        is AlertDialog -> dialog.getButton(id)
+//                        is androidx.appcompat.app.AlertDialog -> dialog.getButton(id)
+//                        else -> null
+//                    }
+//
+//                    if (view == null) {
+//                        return false
+//                    }
+//
+//                    Connect.logDialogEvent(dialog, 1)
+//                }
+//            }
+        } catch (e: Exception) {
+            Log.v(TAG, "Error logging dialog button click event: ${e.message}")
+            result = false
+        }
+        return result
+    }
+
+    /**
+     * Logs a custom dialog event with the specified event information.
+     *
+     * @param dialogId   Unique identifier for the dialog.
+     * @param eventName  The name of the custom event.
+     * @param values     A map of values associated with the event.
+     * @return True if the operation was successful, false otherwise.
+     */
+    override fun logDialogCustomEvent(
+        dialogId: String,
+        eventName: String,
+        values: Map<String, Variant_String_Double_Boolean>
+    ): Boolean {
+        var result = false
+        try {
+            val eventValues = HashMap<String?, String?>()
+            eventValues["dialogId"] = dialogId
+            eventValues["customEventName"] = eventName
+            eventValues["eventType"] = "dialog_custom_event"
+            eventValues["timestamp"] = System.currentTimeMillis().toString()
+
+            // Add the custom values
+            for (key in values.keys) {
+                val value = values[key]
+                if (value != null) {
+                    eventValues[key] = value.toString()
+                }
+            }
+
+            result =
+                Connect.logCustomEvent("DialogCustomEvent", eventValues, EOMonitoringLevel.kEOMonitoringLevelInfo.value)
+        } catch (e: Exception) {
+            Log.v(TAG, "Error logging dialog custom event: ${e.message}")
+            result = false
+        }
+        return result
+    }
+
+    /**
+     * Converts a map of Variant_String_Double_Boolean to a HashMap<String?, String?>.
+     *
+     * @param values The map to be converted.
+     * @return A HashMap<String?, String?> representation of the input map which library can use.
+     */
+    private fun convertToMap(values: Map<String, Variant_String_Double_Boolean>): HashMap<String?, String?> {
+        val map = HashMap<String?, String?>()
+        for (key in values.keys) {
+            val value = values[key]
+            if (value != null) {
+                map[key] = value.toString()
+            }
         }
-      }
+        return map
     }
 
-    registerFormField(textView, activity)
-  }
+    /**
+     * Converts a map of Variant_String_Double_Boolean to a HashMap<String?, String?>.
+     *
+     * @param values The map to be converted.
+     * @return A HashMap<String?, String?> representation of the input map which library can use.
+     */
+    private fun convertToMapAny(values: Map<String, Variant_String_Double_Boolean>): java.util.HashMap<String?, Any?>? {
+        val map = HashMap<String?, Any?>()
+        for (key in values.keys) {
+            val value = values[key]
+            if (value != null) {
+                map[key] = value
+            }
+        }
+        return map
+    }
+
+    /**
+     * Gets the current activity from the ReactApplicationContext.
+     *
+     * @return The current activity or null if not available.
+     */
+    private fun getCurrentActivity(): android.app.Activity? {
+        return applicationContext?.currentActivity
+    }
+
+    /**
+     * Add focus listener to handle EditText UI control.
+     *
+     * @param textView        Input TextView.
+     * @param accessibilityID Accessibility ID(virtual id).
+     * @param activity        Current activity.
+     */
+    fun addFocusAndRegister(textView: TextView, accessibilityID: String?, activity: Activity) {
+        textView.onFocusChangeListener = OnFocusChangeListener { v: View, hasFocus: Boolean ->
+            if (hasFocus) {
+                val imm = v.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+                imm.showSoftInput(v, InputMethodManager.SHOW_FORCED)
+                val keyboardView = KeyboardView(v.context.applicationContext, null)
+
+                if (TextUtils.isEmpty(accessibilityID)) {
+                    logEvent(keyboardView, TLF_UI_KEYBOARD_DID_SHOW_NOTIFICATION)
+                    logEvent(v, TLF_ON_FOCUS_CHANGE_IN)
+                } else {
+                    logEvent(keyboardView, TLF_UI_KEYBOARD_DID_SHOW_NOTIFICATION, accessibilityID!!)
+                    logEvent(v, TLF_ON_FOCUS_CHANGE_IN, accessibilityID!!)
+                }
+            } else {
+                logEvent(v, TLF_ON_FOCUS_CHANGE_OUT)
+                val imm = v.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+                imm.hideSoftInputFromWindow(v.windowToken, 0)
+
+                val keyboardView = KeyboardView(v.context.applicationContext, null)
+
+                if (TextUtils.isEmpty(accessibilityID)) {
+                    logEvent(keyboardView, TLF_UI_KEYBOARD_DID_HIDE_NOTIFICATION)
+                } else {
+                    logEvent(keyboardView, TLF_UI_KEYBOARD_DID_HIDE_NOTIFICATION, accessibilityID!!)
+                }
+            }
+        }
+
+        registerFormField(textView, activity)
+    }
 
 //  override fun onWindowFocusChanged(hasFocus: Boolean) {
 //    if (!reactContext.hasActiveCatalystInstance()) {
@@ -534,74 +830,75 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
 //    }
 //  }
 
-   fun onWindowFocusChanged(hasFocus: Boolean) {
-    if (!reactContext.hasActiveCatalystInstance()) {
+    fun onWindowFocusChanged(hasFocus: Boolean) {
+        if (!reactContext.hasActiveCatalystInstance()) {
 //      logEvent("WindowFocus", "Context is not ready. Skipping onWindowFocusChanged.")
-      return
-    }
+            return
+        }
 
-    // Handle window focus change
-    if (hasFocus) {
+        // Handle window focus change
+        if (hasFocus) {
 //      logEvent("WindowFocus", "Window gained focus")
-    } else {
+        } else {
 //      logEvent("WindowFocus", "Window lost focus")
+        }
     }
-  }
 
-  /**
-   * Used when host resumes.
-   */
-  override fun onHostResume() {
-    // Initialize Connect library, and hook into activity lifecycle events to help detect if app is in background
-    if (!reactContext.hasActiveCatalystInstance()) {
+    /**
+     * Used when host resumes.
+     */
+    override fun onHostResume() {
+        // Initialize Connect library, and hook into activity lifecycle events to help detect if app is in background
+        if (!reactContext.hasActiveCatalystInstance()) {
 //      logEvent("Lifecycle", "onHostResume skipped: ReactContext is not ready")
-      return
-    }
+            return
+        }
 
-    val activity = getCurrentActivity()
-    if (activity == null) {
+        val activity = getCurrentActivity()
+        if (activity == null) {
 //      logEvent("Lifecycle", "onHostResume skipped: Activity is null")
-      return
-    }
+            return
+        }
 
-    if (!isEnabled()) {
-      if (getApplication() == null) {
-        init((reactContext.applicationContext as Application))
-      }
-      enable()
+        if (!isEnabled()) {
+            if (getApplication() == null) {
+                init((reactContext.applicationContext as Application))
+            }
+            enable()
+        }
+        onResume(activity, null)
     }
-    onResume(activity, null)
-  }
 
-  /**
-   * Used when host gets paused.
-   */
-  override fun onHostPause() {
-    val activity = getCurrentActivity()
-    if (activity == null) {
+    /**
+     * Used when host gets paused.
+     */
+    override fun onHostPause() {
+        val activity = getCurrentActivity()
+        if (activity == null) {
 //      logEvent("Lifecycle", "onHostPause skipped: Activity is null")
-      return
-    }
+            return
+        }
 
-    Connect.onPause(activity, null)
-  }
+        Connect.onPause(activity, null)
+    }
 
-  /**
-   * Used when host gets destroyed.
-   */
-  override fun onHostDestroy() {
-    val activity = getCurrentActivity()
-    if (activity == null) {
+    /**
+     * Used when host gets destroyed.
+     */
+    override fun onHostDestroy() {
+        val activity = getCurrentActivity()
+        if (activity == null) {
 //      logEvent("Lifecycle", "onHostDestroy skipped: Activity is null")
-      return
-    }
+            return
+        }
 
-    Tealeaf.onDestroy(activity, null)
-    // Uncomment if Connect.onDestroy is needed
-    // Connect.onDestroy(activity, null)
-  }
+        Tealeaf.onDestroy(activity, null)
+        // Uncomment if Connect.onDestroy is needed
+        // Connect.onDestroy(activity, null)
+    }
 
     companion object {
         const val TAG = "AcousticConnectRN"
+        const val DIALOG_CAPTURE_DELAY_MS = 500L // Configurable delay for dialog screenshot capture
     }
 }