react-native-acoustic-connect 19.0.11 → 19.0.34

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

@@ -62,6 +62,7 @@ import com.margelo.nitro.acousticconnectrn.PushPermissionResult
 import com.margelo.nitro.acousticconnectrn.Variant_Boolean_String_Double
 import com.margelo.nitro.acousticconnectrn.Variant_NullType_Boolean
 import com.margelo.nitro.acousticconnectrn.Variant_NullType_String
+import com.margelo.nitro.core.AnyMap
 import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.NullType
 import com.margelo.nitro.core.Promise
@@ -70,6 +71,9 @@ 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 org.json.JSONArray
+import org.json.JSONException
+import org.json.JSONObject
 import java.util.Objects
 
 
@@ -575,7 +579,12 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         value: Double,
         moduleName: String
     ): Boolean {
-        val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
+        // Rendered through formatJsNumber, not Double.toString: EOCore stores
+        // config items as strings, and a JS 0 spelled "0.0" is not the same
+        // token as the "0" the JSON config files carry, so a consumer setting
+        // a whole-number item at runtime wrote a value that no longer matched
+        // what the same key looks like on iOS (a native number) or on disk.
+        val result = EOCore.updateConfig(key, formatJsNumber(value), EOCore.getLifecycleObject(moduleName))
         return result
     }
 
@@ -592,7 +601,8 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         value: Variant_Boolean_String_Double,
         moduleName: String
     ): Boolean {
-        val result = EOCore.updateConfig(key, value.toString(), EOCore.getLifecycleObject(moduleName))
+        val result =
+            EOCore.updateConfig(key, variantToString(value), EOCore.getLifecycleObject(moduleName))
         return result
     }
 
@@ -662,21 +672,59 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         level: Double
     ): Boolean {
         val result = Connect.logCustomEvent(eventName, convertToMap(values), level.toInt())
-        return result
+        return warnIfRejected(result, "logCustomEvent", eventName)
     }
 
     /**
      * Logs a signal with the specified values.
      *
-     * @param values A map of values associated with the signal.
+     * Takes an [AnyMap] rather than a map of Nitro variants so JS callers can
+     * send arbitrary JSON — nested objects and arrays included. See
+     * [toSignalPayload] for why the nesting has to be rebuilt as
+     * [JSONObject]/[JSONArray] rather than handed over as plain Kotlin
+     * collections.
+     *
+     * @param values The signal payload; objects, arrays and scalars are all carried through.
      * @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_Boolean_String_Double>,
+        values: AnyMap,
         level: Double
     ): Boolean {
-        val result = Connect.logSignal(convertToMapAny(values), level.toInt())
+        val result = Connect.logSignal(toSignalPayload(values.toHashMap()), level.toInt())
+        return warnIfRejected(result, "logSignal")
+    }
+
+    /**
+     * Surfaces a `false` returned by a native logging call, and passes it
+     * through unchanged.
+     *
+     * The bridge's boolean means "the SDK accepted this for delivery", never
+     * "the collector received it" — nothing on the device knows the latter. But
+     * the *accepted* half was itself invisible: a `false` propagated to JS as a
+     * bare return value that the wrapper's callers almost never inspect, with
+     * nothing in logcat. Callers reporting "the event never arrived" had no way
+     * to tell a rejected call from a delivery problem. One line at warn level
+     * distinguishes them.
+     *
+     * Deliberately does not change the return value or throw: an analytics
+     * bridge must not turn a rejected event into an app-visible failure.
+     *
+     * @param result The value the native call returned.
+     * @param api    Name of the bridge method, for the log line.
+     * @param detail Optional extra identifier, e.g. an event name.
+     * @return [result], unchanged.
+     */
+    private fun warnIfRejected(result: Boolean, api: String, detail: String? = null): Boolean {
+        if (!result) {
+            val suffix = if (detail != null) " ($detail)" else ""
+            Log.w(
+                TAG,
+                "[bridge] $api$suffix: the Connect SDK did not accept the event; nothing was queued " +
+                    "for delivery. Check that the SDK is enabled and the payload is valid."
+            )
+        }
         return result
     }
 
@@ -697,8 +745,11 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @param identifierValue Identifier value, e.g. "user@example.com".
      * @param signalType Optional signal type; defaults to "loggedIn" when omitted.
      * @param additionalParameters Optional extra key/value pairs merged into the
-     *   signal. Defaults to `{ "registrationMethod": "email" }` only when null
-     *   (omitted); an explicit map — including an empty one — is used as-is.
+     *   signal. Defaults, only when null (omitted), to the method attribute the
+     *   resolved signal type requires — `{ "loginMethod": "email" }` for
+     *   `loggedIn`, `{ "registrationMethod": "email" }` otherwise (see
+     *   [defaultIdentityParameters]). An explicit map — including an empty one
+     *   — is used as-is.
      * @return A promise resolving to true if the signal was queued, false otherwise.
      */
     override fun logIdentity(
@@ -707,8 +758,8 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         signalType: String?,
         additionalParameters: Map<String, String>?
     ): Promise<Boolean> {
-        val params = additionalParameters ?: mapOf("registrationMethod" to "email")
         val resolvedSignalType = signalType ?: "loggedIn"
+        val params = additionalParameters ?: defaultIdentityParameters(resolvedSignalType)
         val result = params["url"]?.let { url ->
             Connect.logIdentificationEvent(
                 identifierName,
@@ -723,7 +774,11 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             signalType = resolvedSignalType,
             additionalParameters = params
         )
-        return Promise.resolved(result)
+        // An identity signal that the SDK accepts can still be rejected
+        // downstream by schema validation — a mismatched method attribute has
+        // cost a customer 22 signals while every call reported success. The
+        // bridge cannot see that; it can at least report the half it does see.
+        return Promise.resolved(warnIfRejected(result, "logIdentity", resolvedSignalType))
     }
 
     /**
@@ -857,15 +912,78 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         }
     }
 
+    /**
+     * Whether the bridge may touch capture at all.
+     *
+     * `disable()` reaches `Tealeaf.disable()`, which unregisters the activity
+     * lifecycle callbacks and clears the enabled flag — enough on iOS, where
+     * `<Connect>` only advances the current screen name. On Android the same
+     * component also drives capture explicitly on every navigation
+     * (`logScreenViewPageName` + `logScreenLayout`), and those paths used to run
+     * regardless of the flag: `setCurrentScreenName` called through to
+     * `Tealeaf.resumeTealeaf`, which resumes logging, and `logScreenLayout`
+     * captured a full layout. The net effect was that `disable()` silenced
+     * capture on iOS but not on Android, for an app doing nothing unusual.
+     *
+     * Checked here rather than in JS so every caller is covered, including apps
+     * that call the bridge methods directly.
+     */
+    private fun isCaptureAllowed(): Boolean = Connect.isEnabled()
+
     /**
      * Requests that the framework save the current application page name.
      *
+     * Sets the name and nothing else, which is what the name promises and what
+     * iOS has always done — `TLFApplicationHelper.setCurrentScreenName:` just
+     * assigns `TLFScreenViewManager`'s current screen view name.
+     *
+     * `<Connect>` calls this on every touch: `onStartShouldSetResponderCapture`
+     * needs the name current so the click that follows is attributed to the
+     * right screen. It therefore has to be cheap, and on Android it was not. It
+     * used to be `Connect.resumeConnect` → `Tealeaf.resumeTealeaf`, which does
+     * four things at once: sets the name, emits a screenview LOAD, re-arms
+     * capture, and **captures a full screen layout**. Only the first is wanted
+     * here. The layout put a message of tens to hundreds of KB on the wire per
+     * tap on Android, where the same call on iOS sends nothing.
+     *
+     * That volume is not merely wasteful. EOCore's disk cache holds at most
+     * `MaxNumberOfFilesToCache` (5) chunks between post cycles and silently
+     * discards the rest while posting is healthy, so a tap-heavy screen loses
+     * whole batches: in a customer session, a `DeliveryOptionsScreen` LOAD and
+     * the first 8 s of capture on it went missing that way.
+     *
+     * Dropping the re-arm with it is safe, and was verified on-device rather
+     * than assumed: `logScreenLayout` below still calls `resumeConnect` on
+     * every navigation and on first paint, which arms capture before any touch
+     * can reach this method. Measured on the bare-workflow sample, twelve taps
+     * on one screen went from 21 layout messages (586 KB) to 4 (67 KB) with all
+     * twelve clicks still captured.
+     *
+     * Screenview and layout belong to the navigation path, which goes through
+     * `logScreenLayout` below and is unchanged.
+     *
      * @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
+        // Nothing should advance capture state while disabled. Cheaper than it
+        // was — this no longer captures a layout — but still the wrong thing to
+        // do behind a `disable()`.
+        if (!isCaptureAllowed()) return false
+        // Guarded because of where this runs, not because the call is expected to
+        // fail: `<Connect>` invokes it from `onStartShouldSetResponderCapture`, so
+        // this is the one bridge method on the per-touch path. An exception out of
+        // the SDK here would surface inside React's responder negotiation on every
+        // tap, taking touch handling down with it. Report the failure instead — the
+        // click that follows is then attributed to the previous screen, which is
+        // wrong but survivable.
+        return try {
+            Connect.setCurrentLogicalPageName(logicalPageName)
+            true
+        } catch (e: Exception) {
+            Log.v(TAG, "setCurrentScreenName error: ${e.message}")
+            false
+        }
     }
 
     /**
@@ -876,8 +994,14 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @return True if the operation was successful, false otherwise.
      */
     override fun logScreenViewContextLoad(logicalPageName: Variant_NullType_String?, referrer: Variant_NullType_String?): Boolean {
-        val result = logScreenview(getCurrentActivity()!!, logicalPageName?.asSecondOrNull().toString(), ScreenviewType.LOAD, referrer?.asSecondOrNull());
-        return result
+        // Emits a screenview message; nothing should reach the queue while disabled.
+        if (!isCaptureAllowed()) return false
+        // No activity means nothing to log a screenview against. This used to be
+        // a force-unwrap, which turned a backgrounded or not-yet-attached activity
+        // into a crash; the sample now calls this method directly, so the path is
+        // easy to reach from JS.
+        val activity = getCurrentActivity() ?: return false
+        return logScreenview(activity, logicalPageName?.asSecondOrNull().toString(), ScreenviewType.LOAD, referrer?.asSecondOrNull())
     }
 
     /**
@@ -888,32 +1012,138 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @return True if the operation was successful, false otherwise.
      */
     override fun logScreenViewContextUnload(logicalPageName: Variant_NullType_String?, referrer: Variant_NullType_String?): Boolean {
-        val result = logScreenview(getCurrentActivity()!!, logicalPageName?.asSecondOrNull().toString(), ScreenviewType.UNLOAD, referrer?.asSecondOrNull());
-        return result
+        // Emits a screenview message; nothing should reach the queue while disabled.
+        if (!isCaptureAllowed()) return false
+        // No activity means nothing to log a screenview against. This used to be
+        // a force-unwrap, which turned a backgrounded or not-yet-attached activity
+        // into a crash; the sample now calls this method directly, so the path is
+        // easy to reach from JS.
+        val activity = getCurrentActivity() ?: return false
+        return logScreenview(activity, logicalPageName?.asSecondOrNull().toString(), ScreenviewType.UNLOAD, referrer?.asSecondOrNull())
     }
 
     /**
      * 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.
+     * @param delay The delay in milliseconds before logging the event. A negative
+     *              value means "use the `CaptureLayoutDelay` configured for this
+     *              screen", which is what the JS wrapper sends when the caller
+     *              names no delay.
      * @return True if the operation was successful, false otherwise.
      */
     override fun logScreenLayout(name: String, delay: Double): Boolean {
-        setCurrentScreenName(name)
+        // The wrapper calls this on every Android navigation.
+        if (!isCaptureAllowed()) return false
+        // Resume explicitly rather than via `setCurrentScreenName`, which now only
+        // sets the name. Navigation is where resuming belongs: `resumeTealeaf`
+        // re-enables capture for the screen being entered (`_isCaptureScreenContentsEnabled`)
+        // after a `pauseTealeaf`, honouring the screen's layout config. Calling it
+        // here keeps this path byte-identical to what it did before that split.
+        //
+        // The result is advisory on purpose: a false means the resume did not take,
+        // which is not a reason to skip the screenview and layout that follow — they
+        // are what the caller asked for. Treating it as fatal would suppress capture
+        // in cases that capture fine today.
+        resumeConnect(getCurrentActivity(), name, false)
+        // The 3-arg overload takes a nullable Activity, so this one is safe to pass
+        // through — unlike the 4-arg overload the context methods use.
         logScreenview(getCurrentActivity(), name, ScreenviewType.LOAD)
         var result = false
-        if (LayoutUtil.canCaptureUserEvents(null, name)) {
-            result = logScreenLayout(
-                Objects.requireNonNull<Activity?>(getCurrentActivity()),
+        // The layout capture below needs a real activity: it used to go through
+        // Objects.requireNonNull, which threw when the activity had gone away
+        // between the check above and here. Skip the capture instead and report
+        // false — this runs on every Android navigation, so a throw here is a
+        // crash on an ordinary screen change.
+        val activity = getCurrentActivity()
+        if (activity != null && LayoutUtil.canCaptureUserEvents(null, name)) {
+            result = logAutomaticScreenLayout(
+                activity,
                 name,
-                if (delay.toInt() < 0) 300 else delay.toInt(),
-                true
+                resolveCaptureLayoutDelayMs(name, delay)
             )
         }
         return result
     }
 
+    /**
+     * Captures the layout of [activity] as an *automatic* capture — the kind
+     * the wrapper triggers itself, on navigation or behind a dialog — rather
+     * than a manual `logScreenLayout` API call from the host app.
+     *
+     * Every wrapper-initiated capture must go through here, because the
+     * distinction is what makes the configured `ScreenShot` value reach the
+     * native screenshot gate at all:
+     *
+     * - `Connect`'s four-argument overload hardcodes `manualLog = true`, and
+     *   the native gate reads the configured `ScreenShot` only on the
+     *   `manualLog = false` branch. Passing a literal `true` for the screenshot
+     *   flag — which every wrapper call site used to do — therefore took the
+     *   manual branch unconditionally, so `ScreenShot: false` could not be
+     *   honoured from config and a full-page image shipped in every layout
+     *   message regardless. Hence the five-argument overload, with
+     *   `manualLog = false`.
+     * - [LayoutUtil.canTakeScreenShot] resolves the same merged layout rule the
+     *   native automatic path uses (global settings as a baseline, any
+     *   per-screen rule applied over them). It is preferred over reading
+     *   `ScreenShot` directly because it is `has()`-guarded: a per-screen rule
+     *   that omits the key defaults to capturing rather than throwing a
+     *   `JSONException`, which higher up is swallowed and costs the whole
+     *   layout message. Its first argument may be null while the page name is
+     *   non-empty, the same pattern as `canCaptureUserEvents(null, name)`.
+     *
+     * Note `CaptureScreenshotOn` is not consulted anywhere on Android: its only
+     * native reader has no callers, so `ScreenShot` is the one wired-up switch.
+     *
+     * [activity] is nullable to match the five-argument overload; callers that
+     * need a non-null one check or assert before calling.
+     */
+    private fun logAutomaticScreenLayout(
+        activity: Activity?,
+        name: String,
+        delayMs: Int
+    ): Boolean {
+        return logScreenLayout(
+            activity,
+            name,
+            delayMs,
+            false,
+            LayoutUtil.canTakeScreenShot(null, name)
+        )
+    }
+
+    /**
+     * Resolves the capture delay, in milliseconds, to apply for [name].
+     *
+     * A non-negative [delay] is the caller's explicit choice and passes
+     * straight through. A negative one defers to `CaptureLayoutDelay` in the
+     * layout config, which is what makes that setting reach the React Native
+     * wrapper at all — the wrapper used to hardcode 0 here, so the capture
+     * fired at the start of the screen transition and the configured value
+     * was inert.
+     *
+     * [LayoutUtil.getLayoutInfo] returns the merged rule for the screen: the
+     * global settings as a baseline with any per-screen rule applied over
+     * them, so this picks up either without re-implementing the precedence.
+     * It reads the config off disk, so a malformed or absent block falls back
+     * to [DEFAULT_CAPTURE_LAYOUT_DELAY_MS] rather than propagating a throw
+     * into a logging call.
+     */
+    internal fun resolveCaptureLayoutDelayMs(name: String, delay: Double): Int {
+        if (delay >= 0) {
+            return delay.toInt()
+        }
+        return try {
+            LayoutUtil.getLayoutInfo(name)
+                ?.optInt(CAPTURE_LAYOUT_DELAY_KEY, DEFAULT_CAPTURE_LAYOUT_DELAY_MS)
+                ?.coerceAtLeast(0)
+                ?: DEFAULT_CAPTURE_LAYOUT_DELAY_MS
+        } catch (e: Exception) {
+            Log.w(TAG, "Could not read $CAPTURE_LAYOUT_DELAY_KEY for \"$name\"; using ${DEFAULT_CAPTURE_LAYOUT_DELAY_MS}ms.", e)
+            DEFAULT_CAPTURE_LAYOUT_DELAY_MS
+        }
+    }
+
     /**
      * Logs a dialog show event with the specified dialog information.
      *
@@ -950,12 +1180,12 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
                         } 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)
+                            logAutomaticScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 0)
                         }
                     } 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)
+                        logAutomaticScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 0)
                     }
                 }, DIALOG_CAPTURE_DELAY_MS) // Use configurable delay
 
@@ -974,7 +1204,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
                     }
                 } else {
                     // Default fallback
-                    result = logScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 300, true)
+                    result = logAutomaticScreenLayout(Objects.requireNonNull<Activity?>(getCurrentActivity()), dialogTitle, 300)
                 }
             }
         } catch (e: Exception) {
@@ -1187,7 +1417,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             for (key in values.keys) {
                 val value = values[key]
                 if (value != null) {
-                    eventValues[key] = value.toString()
+                    eventValues[key] = variantToString(value)
                 }
             }
 
@@ -1200,9 +1430,83 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         return result
     }
 
+    /**
+     * Unwraps a Nitro variant to the underlying JS value it carries — a
+     * [Boolean], [String], or [Double].
+     *
+     * The generated `Variant_*` type is a sealed **data** class, so calling
+     * `toString()` on the variant itself yields the case wrapper
+     * (`"Second(value=pro)"`) instead of the value (`"pro"`). Every conversion
+     * that reads a variant must unwrap it first. Mirrors the iOS bridge's
+     * `ConnectRNParsing.convertVariantToAny`, keeping emitted payloads
+     * identical across platforms.
+     *
+     * @param value The variant to unwrap.
+     * @return The wrapped Boolean, String, or Double.
+     */
+    private fun unwrapVariant(value: Variant_Boolean_String_Double): Any =
+        value.match(first = { it }, second = { it }, third = { it })
+
+    /**
+     * Unwraps a Nitro variant (see [unwrapVariant]) and renders it as a string,
+     * for the SDK entry points that take `HashMap<String, String>` payloads.
+     *
+     * Booleans render as `"true"`/`"false"`, strings pass through unchanged,
+     * and numbers go through [formatJsNumber] so they read the way the same
+     * JS value reads on iOS.
+     *
+     * @param value The variant to stringify.
+     * @return The wrapped value's string form.
+     */
+    private fun variantToString(value: Variant_Boolean_String_Double): String =
+        when (val unwrapped = unwrapVariant(value)) {
+            is Double -> formatJsNumber(unwrapped)
+            else -> unwrapped.toString()
+        }
+
+    /**
+     * Renders a JS number the way JS itself — and therefore the iOS bridge —
+     * renders it: `2` stays `"2"`, `2.5` stays `"2.5"`.
+     *
+     * Every JS number crosses Nitro as a [Double], so a JS `2` arrives as
+     * `2.0`, and Kotlin's [Double.toString] spells that `"2.0"`. iOS hands the
+     * same value to the SDK as a native number, which `NSJSONSerialization`
+     * writes as `2`. The result was a cross-platform payload split on any
+     * whole number — `"seats": "2.0"` on Android against `"seats": 2` on iOS —
+     * which breaks dashboards and Composer rules that compare the two.
+     * Dropping the trailing `.0` closes the *textual* half of that gap.
+     *
+     * It does not close the *type* half on the custom-event path: the SDK's
+     * `logCustomEvent` chain is typed `HashMap<String, String>` end to end, so
+     * an Android custom-event number is a JSON string (`"2"`) where iOS sends a
+     * JSON number (`2`). Only `logSignal` carries native types on Android, and
+     * that path deliberately does not come through here — see [toSignalPayload].
+     *
+     * Integral values are rendered through [Long] only below 2^53, which spans
+     * every integer JS itself represents exactly; beyond that the [Double] form
+     * is kept rather than inventing digits a `Long` round-trip would imply.
+     * Non-finite values keep Kotlin's spelling (`"NaN"`, `"Infinity"`) — there
+     * is no JSON representation to match, and stringifying is strictly safer
+     * than throwing out of an analytics call.
+     *
+     * @param value The number to render.
+     * @return Its string form, without a trailing `.0` for whole numbers.
+     */
+    internal fun formatJsNumber(value: Double): String {
+        if (!value.isFinite()) {
+            return value.toString()
+        }
+        if (value == Math.floor(value) && Math.abs(value) < 9007199254740992.0) {
+            return value.toLong().toString()
+        }
+        return value.toString()
+    }
+
     /**
      * Converts a map of Variant_Boolean_String_Double to a HashMap<String?, String?>.
      *
+     * Values are unwrapped before stringifying (see [variantToString]).
+     *
      * @param values The map to be converted.
      * @return A HashMap<String?, String?> representation of the input map which library can use.
      */
@@ -1212,30 +1516,114 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         for (key in values.keys) {
             val value = values[key]
             if (value != null) {
-                map[key] = value.toString()
+                map[key] = variantToString(value)
             }
         }
         return map
     }
 
     /**
-     * Converts a map of Variant_Boolean_String_Double to a HashMap<String?, String?>.
+     * Converts an [AnyMap]-derived map into the payload `Connect.logSignal`
+     * expects, rebuilding nested structures as [JSONObject] / [JSONArray].
      *
-     * @param values The map to be converted.
-     * @return A HashMap<String?, String?> representation of the input map which library can use.
+     * The rebuild is mandatory, not cosmetic. The SDK serializes the signal
+     * through EOCore's `JsonUtil.getHashValues`, which walks the top-level
+     * entries and accumulates only `String`, `Boolean`, `Number` (from Connect
+     * Android 11.0.24-beta), `JSONObject`, `JSONArray` and `ByteArray` —
+     * anything else is **silently dropped**. So a nested `Map`/`List` handed
+     * over as-is would vanish from the emitted signal without any error.
+     * Converting here is what makes nested payloads survive the wire.
+     *
+     * `null` becomes [JSONObject.NULL] rather than a Kotlin `null`, which
+     * `org.json` requires for an explicit JSON `null`.
+     *
+     * Version boundary — **top-level** numbers. `getHashValues` gained a
+     * `Number` branch in Connect Android 11.0.24-beta and accumulates the boxed
+     * value as-is, so a top-level number now reaches the wire. On earlier builds
+     * its `instanceof` ladder had no such branch, the entry was skipped with no
+     * error, and nothing here could rescue it. Numbers nested inside an object
+     * or array were never affected — the enclosing [JSONObject]/[JSONArray] is
+     * built here, so `org.json` serializes them normally — and iOS has always
+     * carried top-level numbers. Both sides of the boundary sit inside the
+     * `[11.0.11, 12.0.0)` range this bridge accepts, so an integration pinning
+     * an older Connect version still sees the old behaviour; nesting a number
+     * is portable across the whole range.
+     *
+     * A [JSONException] aborts the whole payload rather than escaping to the
+     * caller. Non-finite numbers are the case that raises it: `org.json`
+     * rejects them, and [toJsonValue] raises them explicitly so a top-level one
+     * behaves like a nested one. Either way a JS `Infinity` or `NaN` would
+     * otherwise throw straight out of `logSignal` and take the host app's call
+     * site down — unacceptable for an analytics SDK, and a behaviour change
+     * from the scalar-only bridge, which could not throw. Dropping the whole
+     * payload also matches iOS, where a single non-finite value fails
+     * `isValidJSONObject:` and the `signal` key is omitted entirely.
+     *
+     * @param values The map from [AnyMap.toHashMap].
+     * @return A HashMap the SDK's signal serializer can consume, or an empty
+     *   map if the payload could not be represented as JSON.
      */
     // internal (not private) so the unit tests in src/test can exercise it.
-    internal fun convertToMapAny(values: Map<String, Variant_Boolean_String_Double>): 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
+    internal fun toSignalPayload(values: Map<String, Any?>): java.util.HashMap<String?, Any?> {
+        val map = HashMap<String?, Any?>(values.size)
+        try {
+            for ((key, value) in values) {
+                map[key] = toJsonValue(value)
             }
+        } catch (e: JSONException) {
+            Log.w(TAG, "[bridge] logSignal payload is not representable as JSON — dropping it: ${e.message}")
+            return HashMap()
         }
         return map
     }
 
+    /**
+     * Recursive helper for [toSignalPayload]. Maps Kotlin containers onto their
+     * `org.json` equivalents and leaves scalars alone.
+     *
+     * Nitro's JNI layer converts the whole tree to plain Java types before it
+     * reaches Kotlin — a JS object becomes a `HashMap`, a JS array an
+     * `ArrayList`, and scalars become `Double` / `Boolean` / `Long` / `String`
+     * — so there are no `AnyValue` wrappers left to unwrap here. [List] is
+     * therefore the branch a JS array actually takes; [Array] is handled too,
+     * to guard against a future Nitro representation change.
+     *
+     * @param value A value from an [AnyMap]-derived container.
+     * @return The `org.json`-compatible equivalent.
+     */
+    private fun toJsonValue(value: Any?): Any =
+        when (value) {
+            null -> JSONObject.NULL
+            is Map<*, *> -> JSONObject().apply {
+                for ((nestedKey, nestedValue) in value) {
+                    put(nestedKey.toString(), toJsonValue(nestedValue))
+                }
+            }
+            is Array<*> -> JSONArray().apply {
+                for (element in value) put(toJsonValue(element))
+            }
+            is List<*> -> JSONArray().apply {
+                for (element in value) put(toJsonValue(element))
+            }
+            // Checked here rather than left to `org.json`. A non-finite number
+            // nested in an object or array is rejected by that container's
+            // `put`, but a TOP-LEVEL one is only ever handed to `HashMap.put`,
+            // which accepts anything — so without this the payload would reach
+            // the SDK, and what happened there would depend on the resolved
+            // Connect version: before 11.0.24-beta it lost just that one key
+            // while the nested case lost everything; from 11.0.24-beta the
+            // SDK's own `Number` branch rejects it and drops the whole payload.
+            // Raising it here keeps the two cases consistent across the
+            // supported range and matches iOS, where one non-finite value fails
+            // `isValidJSONObject:` for the entire signal.
+            is Double -> if (value.isFinite()) {
+                value
+            } else {
+                throw JSONException("non-finite number: $value")
+            }
+            else -> value
+        }
+
     /**
      * Gets the current activity from the ReactApplicationContext.
      *
@@ -1383,6 +1771,15 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         const val TAG = "AcousticConnectRN"
         const val DIALOG_CAPTURE_DELAY_MS = 500L // Configurable delay for dialog screenshot capture
 
+        /** Key holding the per-screen capture delay, in milliseconds, inside a layout-config rule. */
+        const val CAPTURE_LAYOUT_DELAY_KEY = "CaptureLayoutDelay"
+
+        /**
+         * Delay applied when the layout config names none. Matches the value the
+         * Connect SDK ships in its own `TealeafLayoutConfig.json`.
+         */
+        const val DEFAULT_CAPTURE_LAYOUT_DELAY_MS = 500
+
         // Class probed at runtime to detect whether the connect-push-fcm
         // transport artifact was included in the build (i.e. automatic mode,
         // where Connect's own FirebaseMessagingService is the PushReceived
@@ -1390,5 +1787,28 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
         // by the connect-push-fcm artifact.
         private const val CONNECT_PUSH_FCM_PROBE_CLASS =
             "com.acoustic.connect.android.connectmod.push.services.fcm.FCMPushService"
+
+        /**
+         * Default `additionalParameters` for an identity signal, matched to the
+         * signal type the bridge will actually send.
+         *
+         * Connect's signal schema requires a *method* attribute on identity
+         * signals, and the required key differs per type: `loggedIn` requires
+         * `loginMethod`, `accountRegistered` requires `registrationMethod`.
+         * Supplying the wrong one fails schema validation and the signal is
+         * discarded, while [Connect.logIdentificationEvent] still reports
+         * success — so the caller sees nothing wrong. Before this mapping
+         * existed the bridge paired its `loggedIn` default with
+         * `registrationMethod`, which meant every defaulted identity call was
+         * silently dropped.
+         *
+         * Only consulted when the caller omits `additionalParameters`
+         * entirely; an explicitly-provided map is passed through untouched.
+         */
+        internal fun defaultIdentityParameters(signalType: String): Map<String, String> =
+            when (signalType) {
+                "loggedIn" -> mapOf("loginMethod" to "email")
+                else -> mapOf("registrationMethod" to "email")
+            }
     }
 }