react-native-acoustic-connect 19.0.11 → 19.0.34

package/android/build.gradle

@@ -129,9 +129,28 @@ android {
     }
   }
 
+  // Java 17 — matched to React Native 0.82's own baseline (its Gradle plugin
+  // targets JavaVersion.VERSION_17), so this imposes no requirement a consumer
+  // does not already meet building an RN app. This file is compiled inside the
+  // consumer's Gradle build, so anything raised here becomes their floor: 21
+  // would put us above RN's baseline for no benefit, since the bridge uses no
+  // Java 21 language features. Bytecode level only — deliberately NOT a
+  // toolchain, so a consumer on JDK 21+ is free to build with it.
+  //
+  // Note this is independent of the Connect Android SDK shipping Java 21
+  // bytecode: D8 dexes major-65 classes happily, and a JDK 17 assembleDebug
+  // against that AAR succeeds. Only JVM unit tests that load those classes need
+  // a 21 runtime, which is configured in the (unpublished) example build.
   compileOptions {
-    sourceCompatibility JavaVersion.VERSION_1_8
-    targetCompatibility JavaVersion.VERSION_1_8
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  // Kept in lockstep with compileOptions above — AGP fails the build with
+  // "Inconsistent JVM-target compatibility" if the Java and Kotlin targets
+  // diverge.
+  kotlinOptions {
+    jvmTarget = '17'
   }
 
   sourceSets {
@@ -154,6 +173,39 @@ repositories {
 allprojects {
     repositories {
         google()
+
+        // Beta Connect artifacts publish HERE, not to Maven Central. Central is
+        // still consulted below — it carries every version up to 11.0.31-beta —
+        // but newer betas land only in this GitHub-hosted Maven tree, so a build
+        // that does not know about it silently freezes `connect:+` at whatever
+        // Central happens to hold. That failure is invisible: resolution
+        // succeeds, just against a stale SDK, and the gap widens with each beta.
+        //
+        // Declaring it is what fixes that; the position is close to cosmetic.
+        // `connect` is resolved through a dynamic version, and for those Gradle
+        // queries every declared repository and takes the newest match across
+        // all of them rather than stopping at the first repository that answers.
+        // Verified: with this entry declared LAST, after mavenCentral(),
+        // `connect:+` still resolves to the newest beta here rather than to
+        // Central's older newest. Order only decides which repository serves a
+        // PINNED version that both carry, where the artifact is identical
+        // anyway — it is kept first so a pin on a beta is served by the tree
+        // that is authoritative for betas.
+        //
+        // The content filter is not cosmetic. Without it every dependency in
+        // the build (React Native, Kotlin, AndroidX, …) would hit
+        // raw.githubusercontent and 404 before falling through to a repository
+        // that has it. Inclusive `content`, not `exclusiveContent`, so Central
+        // still answers for versions this tree does not carry.
+        //
+        // Declared only here, not also in the top-level `repositories` block:
+        // `allprojects` covers this project too, so both would feed the same
+        // resolution and the pair could drift.
+        maven {
+            url = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
+            content { includeGroup "io.github.go-acoustic" }
+        }
+
         mavenCentral()
         maven { url="https://s01.oss.sonatype.org/content/groups/staging" }
 
@@ -179,6 +231,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 {
@@ -200,6 +280,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
@@ -211,7 +327,7 @@ dependencies {
   // builds pull zero Firebase. The host app still supplies its own
   // `google-services.json` and applies the `com.google.gms.google-services`
   // plugin (the bare-workflow demo does this conditionally). The BoM aligns
-  // messaging + its installations/datatransport transitives. See CA-144314.
+  // messaging + its installations/datatransport transitives.
   if (acousticPushEnabled) {
     implementation platform('com.google.firebase:firebase-bom:33.7.0')
     implementation 'com.google.firebase:firebase-messaging'

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:")

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

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

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

@@ -6,7 +6,7 @@
     "CompressPostMessage": true,
     "DefaultOrientation": 0,
     "DisableCookieManager": false,
-    "LibraryVersion": "2.1.16",
+    "LibraryVersion": "2.1.24-beta",
     "MNCMCC": {
         "00": "N/A",
         "20201": "Cosmote",

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

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