react-native-acoustic-connect-beta 19.0.14 → 19.0.16

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 19.0.16 (2026-08-31)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
+## [19.0.15](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/compare/19.0.14...19.0.15) (2026-08-24)
 ## 19.0.14 (2026-07-31)
 
 ### Reverts

package/ConnectConfig.example.json

@@ -1,7 +1,7 @@
 {
     "Connect": {
         "AndroidNotificationIconResName": "ic_notification",
-        "AndroidVersion": "11.0.16-beta",
+        "AndroidVersion": "11.0.21-beta",
         "AppKey": "YOUR_CONNECT_APP_KEY_HERE",
         "KillSwitchUrl": "YOUR_KILL_SWITCH_URL_HERE",
         "PostMessageUrl": "YOUR_POST_MESSAGE_URL_HERE",

package/Examples/SampleUI/ConnectConfig.json

@@ -56,7 +56,7 @@
                     "ScreenShot": false
                 },
                 "GlobalScreenSettings": {
-                    "CaptureLayoutDelay": 1,
+                    "CaptureLayoutDelay": 500,
                     "CaptureLayoutOn": 2,
                     "CaptureScreenVisits": false,
                     "CaptureScreenshotOn": 2,
@@ -141,7 +141,7 @@
                     "ScreenShot": false
                 },
                 "GlobalScreenSettings": {
-                    "CaptureLayoutDelay": 1,
+                    "CaptureLayoutDelay": 500,
                     "CaptureLayoutOn": 2,
                     "CaptureScreenVisits": false,
                     "CaptureScreenshotOn": 2,

package/README.md

@@ -365,9 +365,18 @@ screen / touch / keyboard tracking) can skip it entirely.
 ```ts
 import AcousticConnectRN from 'react-native-acoustic-connect-beta'
 
-// Custom application event
+// Custom application event (flat key/value pairs)
 AcousticConnectRN.logCustomEvent('checkout_started', { cartId: 'abc' }, 1)
 
+// Signal — accepts arbitrary JSON, including nested objects and arrays
+AcousticConnectRN.logSignal(
+  {
+    signalContent: { signalType: 'pageview', pageCategory: 'checkout' },
+    audience: [{ name: 'Account ID', value: '4815162342' }],
+  },
+  1
+)
+
 // Force a logical screen name (e.g. for non-NavigationContainer screens)
 AcousticConnectRN.setCurrentScreenName('CheckoutScreen')
 
@@ -403,6 +412,66 @@ already running.
 
 Stops data capture, flushes pending messages, releases push state. Idempotent.
 
+### `AcousticConnectRN.logSignal(values, level): boolean`
+
+Logs a signal. `values` accepts **arbitrary JSON** — nested objects and arrays,
+not just scalars — and the payload is carried through without flattening or
+reshaping:
+
+```ts
+AcousticConnectRN.logSignal(
+  {
+    signalContent: {
+      signalType: 'pageview',
+      url: 'https://app.example.com/dashboard',
+      pageCategory: 'dashboard',
+    },
+    audience: [
+      { name: 'Account Name', value: 'Acme Corp' },
+      { name: 'Account ID', value: '4815162342' },
+    ],
+  },
+  1
+)
+```
+
+Flat scalar payloads keep working unchanged — the type is a superset of
+`Record<string, string | number | boolean>`.
+
+An object literal needs no type import. If you want to *name* a payload — a
+shared constant, a helper parameter — the package exports `SignalValues` for it:
+
+```ts
+import AcousticConnectRN, {
+  type SignalValues,
+} from 'react-native-acoustic-connect-beta'
+
+const pageView: SignalValues = {
+  signalContent: { signalType: 'pageview', pageCategory: 'checkout' },
+}
+
+AcousticConnectRN.logSignal(pageView, 1)
+```
+
+> **Android: send numbers nested, not at the top level.** The Android SDK's
+> signal serializer carries strings, booleans, objects and arrays at the top
+> level of the payload but drops a top-level numeric value. Numbers nested
+> inside an object or array are unaffected. iOS carries top-level numbers
+> normally, so put numbers one level down when you need both platforms to agree:
+>
+> ```ts
+> AcousticConnectRN.logSignal({ cart: { items: 3 } }, 1) // both platforms
+> AcousticConnectRN.logSignal({ items: 3 }, 1)           // iOS only
+> ```
+
+### `AcousticConnectRN.logCustomEvent(eventName, values, level): boolean`
+
+Logs a named custom event. Unlike `logSignal`, `values` is **flat** — strings,
+numbers and booleans only. The Android SDK's custom-event path is typed for
+string values end to end, so there is no native route for nested JSON; widening
+it would preserve the nesting on iOS and silently drop it on Android. Use
+`logSignal` when the payload needs structure.
+
 ### Push configuration (`ConnectConfig.json`)
 
 | Field | Type | Default | Semantics |
@@ -438,6 +507,100 @@ The Android push-forwarding API itself is wired under follow-up work — until
 that lands, `PushEnabled: true` on Android only changes which artifact is on
 the classpath; the host-side token forwarding API is not yet exposed.
 
+### Screen-capture configuration (`ConnectConfig.json`)
+
+Screen layout and screenshot capture are configured per platform, because the
+two native SDKs read their defaults from different places.
+
+| Field | Type | Default | Semantics |
+| --- | --- | --- | --- |
+| `layoutConfig` | object \| absent | absent | Shared baseline for both platforms. Supports `AutoLayout` (screen capture rules) and `AppendMapIds`. |
+| `layoutConfigIos` | object \| absent | absent | iOS-specific overrides, deep-merged over `layoutConfig`. |
+| `layoutConfigAndroid` | object \| absent | absent | Android-specific overrides, deep-merged over `layoutConfig`. |
+| `GetImageDataOnScreenLayout` | boolean | SDK default | Cross-platform. When `false`, layout messages carry no screenshot image data. |
+
+`AutoLayout` holds a `GlobalScreenSettings` object plus optional per-screen
+overrides keyed by screen name, where a per-screen value wins over the global
+one. To turn screenshot capture off on both platforms:
+
+```json
+{
+  "Connect": {
+    "layoutConfig": {
+      "AutoLayout": {
+        "GlobalScreenSettings": { "ScreenShot": false, "CaptureScreenshotOn": 0 }
+      }
+    }
+  }
+}
+```
+
+Put anything common in `layoutConfig` and use `layoutConfigIos` /
+`layoutConfigAndroid` only for what differs. The platform block is **deep-merged**
+over the shared one, so it refines the baseline rather than replacing it: an
+iOS block setting just `ScreenShot` keeps the shared `Masking`, per-screen
+rules, and every other shared value. Arrays are replaced outright rather than
+concatenated, so a platform block can shorten or clear a shared list such as
+`MaskIdList`.
+
+When no block applies, each native SDK keeps the defaults from its own bundled
+layout config:
+
+- **iOS** — the defaults ship inside the Connect pod's `ConnectResources.bundle`
+  and are copied into your `.app`, so `pod install` replaces them on every run.
+  There is no app-level override file, which is why `ConnectConfig.json` is the
+  only supported route — do not edit anything under `Pods/`.
+- **Android** — the plugin writes your merged block to its own
+  `ConnectLayoutConfig.json` asset. If your app ships
+  `android/app/src/main/assets/ConnectLayoutConfig.json`, Android asset merging
+  gives **your** copy priority and the `ConnectConfig.json` block is ignored;
+  the build prints a warning when both exist. Keep one or the other.
+
+> Turning screenshots off does not disable behavioural capture: screen views,
+> clicks, and custom events still flow. It only drops the image data, which is
+> what a subscription without session replay has no consumer for.
+
+#### Capture timing (`CaptureLayoutDelay`)
+
+`AutoLayout.GlobalScreenSettings.CaptureLayoutDelay` is how long, in
+milliseconds, the SDK waits before capturing the layout. It matters more in
+React Native than in a native app: the wrapper triggers capture from React
+Navigation's state change, which fires at the *start* of a screen transition,
+whereas a native app captures from the view-controller lifecycle, after it. Too
+short a delay and the capture catches a half-drawn screen.
+
+The templates ship `500`, which clears a typical transition animation on both
+platforms. Tune it globally, or per screen for one that is slower than the
+rest:
+
+```json
+{
+  "Connect": {
+    "layoutConfig": {
+      "AutoLayout": {
+        "GlobalScreenSettings": { "CaptureLayoutDelay": 500 },
+        "Checkout": { "CaptureLayoutDelay": 900 }
+      }
+    }
+  }
+}
+```
+
+`TLTRN.logScreenLayout(name)` uses the configured value. Pass a second argument
+to override it for one call — `TLTRN.logScreenLayout(name, 0)` captures
+immediately, `TLTRN.logScreenLayout(name, 900)` waits 900 ms.
+
+A fixed delay cannot cover a screen whose content arrives asynchronously: if
+data lands after the delay elapses, the capture shows the screen without it.
+Raising the global delay to cover the slowest fetch delays every other screen
+too. Call `TLTRN.logScreenLayout(name)` again when the content is on screen
+instead — each call captures the layout as it stands at that moment.
+
+Leaving the block out entirely gives you 500 ms as well. That is the wrapper's
+default, chosen so both platforms behave the same; the native SDKs' own bundled
+defaults differ from each other and are tuned for the lifecycle trigger rather
+than the React Navigation one.
+
 ### `<Connect>` props
 
 | Prop | Type | Required | Description |

package/android/build.gradle

@@ -198,6 +198,34 @@ def acousticPushEnabled = (acousticConfig.Connect?.PushEnabled ?: false).toStrin
 def acousticVersionPin = (acousticConfig.Connect?.AndroidVersion ?: '').trim()
 def acousticVersion = acousticVersionPin.isEmpty() ? '+' : acousticVersionPin
 def acousticArtifact = acousticPushEnabled ? 'connect-push-fcm' : 'connect'
+
+// Connect co-versions `eocore` + `tealeaf` with itself only from 11.0.18-beta
+// onward — and from that release their POM scope is `runtime`, which drops them
+// off the compile classpath (see the companion declarations below).
+//
+// Earlier releases in the supported range ship `tealeaf` on its own 10.4.x line
+// (with eocore arriving transitively through it) at COMPILE scope, so there the
+// companions are both unnecessary AND unresolvable: eocore/tealeaf 11.0.16-beta
+// simply do not exist on Maven Central. Guard on the explicit pin so a consumer
+// who pinned an older Connect keeps building. An empty pin means `+`, which
+// always resolves to the newest (co-versioned) release.
+def acousticCompanionsRequired = true
+if (!acousticVersionPin.isEmpty()) {
+  // Compare only the numeric core, ignoring any -beta/+build qualifier: a
+  // 11.0.18-beta pin must count as >= the 11.0.18 floor. Encoded as one integer
+  // because Groovy's <=> does not compare two ArrayLists.
+  def core = acousticVersionPin.replaceAll(/[-+].*$/, '').tokenize('.')
+  def nums = (0..2).collect { i -> (i < core.size() && core[i].isInteger()) ? core[i].toInteger() : 0 }
+  // Upper bound as well as lower, so that a pin outside the supported range
+  // fails on the `strictly '[11.0.11, 12.0.0)'` constraint in the
+  // `constraints { }` block at the bottom of `dependencies` — which names both
+  // the range and the reason — rather than on an unresolvable companion
+  // coordinate. Verified: without this bound a 12.0.0 pin reported
+  // "Could not find io.github.go-acoustic:eocore:12.0.0", burying the real cause.
+  def pinCode = nums[0] * 1000000 + nums[1] * 1000 + nums[2]
+  acousticCompanionsRequired = pinCode >= 11_000_018 && pinCode < 12_000_000
+}
+println "AcousticConnectRN: companionCompileDeps=$acousticCompanionsRequired (pin='$acousticVersionPin')"
 println "AcousticConnectRN: PushEnabled=$acousticPushEnabled, artifact=io.github.go-acoustic:$acousticArtifact:$acousticVersion"
 
 dependencies {
@@ -219,6 +247,42 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "io.github.go-acoustic:$acousticArtifact:$acousticVersion"
 
+  // Restore the compile classpath for Connect's internal modules. This bridge
+  // calls into both directly — `com.ibm.eo.EOCore`,
+  // `com.ibm.eo.model.EOMonitoringLevel`, `com.tl.uic.Tealeaf`,
+  // `com.tl.uic.model.ScreenviewType`,
+  // `com.tl.uic.util.{DialogUtil,LayoutUtil,keyboardview.KeyboardView}` — so
+  // with them at `runtime` scope `compileDebugKotlin` fails with ~34
+  // "Unresolved reference 'ibm' / 'tl' / 'EOCore'" errors.
+  //
+  // compileOnly, not implementation: the artifacts still reach the runtime graph
+  // through Connect's own transitive, so declaring them there too would risk a
+  // second, independently-resolved copy.
+  //
+  // Both scopes are required — compileOnly does NOT propagate to the unit-test
+  // compile classpath, and android/src/test imports com.ibm.eo.* as well, so
+  // compileDebugUnitTestKotlin fails without the testCompileOnly pair.
+  //
+  // Correct for BOTH artifact variants. `connect-push-fcm` does not declare
+  // eocore/tealeaf itself — its POM depends on `connect` at compile scope, and
+  // eocore/tealeaf reach the graph through that at `runtime` scope, so the
+  // compile classpath is short of them exactly as in the analytics-only case.
+  // The variants are co-versioned (connect-push-fcm 11.0.18-beta -> connect
+  // 11.0.18-beta -> eocore/tealeaf 11.0.18-beta), so `$acousticVersion` is the
+  // right coordinate either way. Confirmed on debugCompileClasspath with
+  // PushEnabled=true; gating these on `!acousticPushEnabled` would break the
+  // push variant rather than protect it.
+  if (acousticCompanionsRequired) {
+    //noinspection GradleDynamicVersion
+    compileOnly     "io.github.go-acoustic:eocore:$acousticVersion"
+    //noinspection GradleDynamicVersion
+    compileOnly     "io.github.go-acoustic:tealeaf:$acousticVersion"
+    //noinspection GradleDynamicVersion
+    testCompileOnly "io.github.go-acoustic:eocore:$acousticVersion"
+    //noinspection GradleDynamicVersion
+    testCompileOnly "io.github.go-acoustic:tealeaf:$acousticVersion"
+  }
+
   // Firebase Cloud Messaging — required by the push variant. The
   // `connect-push-fcm` AAR calls `com.google.firebase.messaging.*`
   // (its `FCMPushService` extends `FirebaseMessagingService`) but its

package/android/config.gradle

@@ -150,7 +150,33 @@ def updateConnectBasicConfig(mp, json) {
     println("Updating:$propertiesFile")
 }
 
-def updateLayoutConfig(mp, json){
+/**
+ * Recursively merges `override` onto `base`. Nested objects merge key by key;
+ * every other value, arrays included, is replaced outright. Mirrors
+ * ConnectRNParsing.deepMerging on iOS so both platforms layer a shared config
+ * block and a platform-specific one the same way.
+ */
+def deepMergeConfig(base, override) {
+    if (!(base instanceof Map) || !(override instanceof Map)) {
+        return override
+    }
+    def merged = [:]
+    merged.putAll(base)
+    override.each { key, value ->
+        if (merged[key] instanceof Map && value instanceof Map) {
+            merged[key] = deepMergeConfig(merged[key], value)
+        } else {
+            merged[key] = value
+        }
+    }
+    return merged
+}
+
+def updateLayoutConfig(mp, json, appAssetsDir){
+    // ── Legacy file, behaviour unchanged ────────────────────────────────────
+    // TealeafLayoutConfig.json is what this script has always written. The
+    // Connect SDK does not read it (see below), but it is left exactly as it
+    // was so nothing that does read it regresses.
     def layoutConfigPath = "$mp/src/main/assets/TealeafLayoutConfig.json"
     def layoutConfigDefaultPath = "$mp/src/main/assets/TealeafLayoutConfigDefault.json"
     def override = json.Connect.layoutConfig;
@@ -165,13 +191,71 @@ def updateLayoutConfig(mp, json){
         layoutConfigFile.text = layoutConfigDefaultFile.text
     }
     println("Updating:$layoutConfigPath")
+
+    // ── The file the Connect SDK actually reads ─────────────────────────────
+    // EOCore's ConfigService.getConfig composes "<moduleName>LayoutConfig.json"
+    // and sets moduleName to "Connect" whenever the Connect class is on the
+    // classpath — which it always is here. So the SDK reads
+    // ConnectLayoutConfig.json, never the Tealeaf-branded name above.
+    //
+    // Compose it the same way iOS does: the shared `layoutConfig` block is the
+    // base and `layoutConfigAndroid` is deep-merged over it, so a platform
+    // value wins key by key while the shared baseline survives.
+    def connectLayoutConfigFile = new File("$mp/src/main/assets/ConnectLayoutConfig.json")
+    def shared = json.Connect.layoutConfig
+    def androidSpecific = json.Connect.layoutConfigAndroid
+    def merged = shared
+    if (androidSpecific != null) {
+        merged = (merged == null) ? androidSpecific : deepMergeConfig(merged, androidSpecific)
+    }
+
+    if (merged != null) {
+        connectLayoutConfigFile.text = JsonOutput.prettyPrint(JsonOutput.toJson(merged))
+        println("Updating:${connectLayoutConfigFile.path}")
+
+        // Android asset merging gives the app's own sourceSet priority over a
+        // library's, so an app-level copy silently wins over what we just
+        // wrote. That is deliberate — integrations that already ship their own
+        // file keep working untouched — but it is worth saying out loud,
+        // because otherwise the ConnectConfig.json block looks ignored.
+        if (appAssetsDir != null) {
+            def appAsset = new File(appAssetsDir, "ConnectLayoutConfig.json")
+            if (appAsset.exists()) {
+                println("**Acoustic WARNING: ${appAsset.path} exists. Android asset merging gives your app's copy priority over the plugin's, so the layout block in ConnectConfig.json will NOT take effect. Keep one or the other, not both.")
+            }
+        }
+    } else if (connectLayoutConfigFile.exists()) {
+        // Nothing configured. Remove a file an earlier build wrote so the
+        // default inside the Connect artifact applies again. Writing a default
+        // copy here instead would shadow the artifact for every consumer and
+        // change behaviour for integrations that never asked for an override.
+        connectLayoutConfigFile.delete()
+        println("Removed:${connectLayoutConfigFile.path} (no layout config in ConnectConfig.json; using the Connect artifact default)")
+    }
 }
 
-def updateTealeafAdvConfig(mp, json) {
-    def tealeafAdvConfigPath = "$mp/src/main/assets/TealeafAdvancedConfig.json"
-    println("Reading file $tealeafAdvConfigPath")
-    def jsonSlurper = new JsonSlurper()
-    def tealeafAdvConfigData = jsonSlurper.parse(new File(tealeafAdvConfigPath))
+def updateAdvConfig(mp, json) {
+    // The overrides are collected once and then written to both advanced-config files.
+    //
+    // TealeafAdvancedConfig.json is what this script has always written. The Connect SDK
+    // does not read it: EOCore's ConfigService.getConfig composes
+    // "<moduleName>AdvancedConfig.json" and sets moduleName to "Connect" whenever the
+    // Connect class is on the classpath — which it always is here. So every override
+    // written only to the Tealeaf-branded name was silently discarded, including
+    // GoogleWebViewEnabled and ExtendsGoogleWebViewClient, which are the documented way to
+    // opt a WebView out of auto instrumentation. The legacy file is still written so
+    // nothing that does read it regresses.
+    //
+    // Neither file is required. This script runs inside the consumer's build, so a missing
+    // asset must not fail it — advanced config is optional by nature, and if the package has
+    // been pruned or repackaged without ConnectAdvancedConfig.json the app still runs on the
+    // defaults bundled in the SDK's own AAR. Losing the overrides is worth saying out loud,
+    // though, which is the difference between the two branches below.
+    def advConfigTargets = [
+        [path: "$mp/src/main/assets/TealeafAdvancedConfig.json", readBySdk: false],
+        [path: "$mp/src/main/assets/ConnectAdvancedConfig.json", readBySdk: true],
+    ]
+    def overrides = [:]
 
     json.each { key, value ->
         if(key != "Connect"){ return }
@@ -223,14 +307,39 @@ def updateTealeafAdvConfig(mp, json) {
                 config_key == "WebViewDelay" ||
                 config_key == "WebViewSetTagForId" ) {
                 println(config_key + "=" + config_value)
-                tealeafAdvConfigData[config_key] = config_value
+                overrides[config_key] = config_value
             }
         }
     }
 
-    def tealeafAdvConfigFile = new File(tealeafAdvConfigPath)
-    tealeafAdvConfigFile.text = JsonOutput.toJson(tealeafAdvConfigData)
-    println("Updating:$tealeafAdvConfigPath")
+    // Merge into each file rather than replacing it: both carry values this script never
+    // sets, most importantly LibraryVersion, which the SDK reports in its X-Tealeaf header.
+    def jsonSlurper = new JsonSlurper()
+    advConfigTargets.each { target ->
+        def advConfigFile = new File(target.path)
+
+        if (!advConfigFile.exists()) {
+            if (target.readBySdk) {
+                println("WARNING: Acoustic Connect: ${advConfigFile.name} is not present in " +
+                    "the SDK package (looked in ${advConfigFile.parent}). That is the file the " +
+                    "Connect SDK reads its advanced configuration from, so the advanced " +
+                    "settings in ConnectConfig.json's Connect block will NOT be applied. The " +
+                    "SDK still runs, on the defaults bundled in its own AAR.")
+            } else {
+                println("Skipping missing legacy file:${target.path}")
+            }
+
+            return
+        }
+
+        println("Reading file ${target.path}")
+        def advConfigData = jsonSlurper.parse(advConfigFile)
+        advConfigData.putAll(overrides)
+        // Pretty-printed to match how updateLayoutConfig writes its file, and so an SDK
+        // upgrade that ships a reformatted asset does not produce a whole-file diff.
+        advConfigFile.text = JsonOutput.prettyPrint(JsonOutput.toJson(advConfigData))
+        println("Updating:${target.path}")
+    }
 }
 
 def updateEOCoreBasicConfig(mp, json) {
@@ -390,9 +499,11 @@ try {
     println("Step 3:")
     updateConnectBasicConfig(module_path, configJSONData)
     println("Step 4:")
-    updateLayoutConfig(module_path, configJSONData)
+    // The app's own assets dir, used only to warn when it shadows what we write.
+    def appAssetsDir = new File(project.rootDir, "app/src/main/assets")
+    updateLayoutConfig(module_path, configJSONData, appAssetsDir.exists() ? appAssetsDir : null)
     println("Step 5:")
-    updateTealeafAdvConfig(module_path, configJSONData)
+    updateAdvConfig(module_path, configJSONData)
     println("Step 6:")
     updateEOCoreBasicConfig(module_path, configJSONData)
     println("Step 7:")

package/android/src/main/assets/ConnectAdvancedConfig.json

@@ -24,7 +24,7 @@
     "IpPlaceholder": "N/A",
     "KillSwitchAsync": true,
     "KillSwitchDelay": 300,
-    "LibraryVersion": "11.0.16-beta",
+    "LibraryVersion": "11.0.21-beta",
     "LogFullRequestResponsePayloads": true,
     "MessageTypeHeader": "WorklightHit",
     "MessageTypes": "4,5",

package/android/src/main/assets/ConnectBasicConfig.properties

@@ -1,4 +1,4 @@
-#Fri Jul 31 01:33:07 PDT 2026
+#Mon Aug 31 14:13:24 GMT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false