react-native-acoustic-connect 19.0.11 → 19.0.28

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) {
@@ -376,7 +485,6 @@ try {
     // "Project with path ... could not be found" during sync. Resolving the
     // package via Node (the same mechanism the injected `apply from:` entry
     // point uses) works regardless of how/whether the library was autolinked.
-    // See CA-144314.
     def sdkPackageJson = ["node", "--print", "require.resolve('react-native-acoustic-connect/package.json')"]
         .execute(null, project.rootDir).text.trim()
     def module_path = new File(sdkPackageJson).getParentFile().getAbsolutePath() + "/android"
@@ -390,9 +498,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:")