react-native-acoustic-connect-beta 19.1.3 → 19.1.5

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 19.1.5 (2026-10-01)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
+## 19.1.4 (2026-09-30)
+
+### Reverts
+
+* Revert "Beta ReactNativeConnect build: 18.0.36" ([609ad7d](https://github.com/aipoweredmarketer/react-native-acoustic-connect-beta/commit/609ad7d3244ec06f27dced5864d40585c5b3c9cf))
 ## 19.1.3 (2026-09-30)
 
 ### Reverts

package/README.md

@@ -106,7 +106,7 @@ Field summary (see [API reference](#api-reference) for full semantics):
 | `AppKey` | _(required)_ | Your Connect application key. |
 | `PostMessageUrl` | _(required)_ | Collector endpoint URL. |
 | `KillSwitchUrl` | _(optional)_ | Kill-switch endpoint URL. |
-| `useRelease` | `false` | `true` selects the release AcousticConnect iOS pod over the debug variant. |
+| `useRelease` | `false` | Release vs. beta native SDKs. iOS: `true` selects the release AcousticConnect pod over the debug variant. Android: `false` resolves Connect from the GitHub-hosted beta Maven repository (betas are not published to Maven Central); `true` resolves from Maven Central only and rejects beta versions. If your `settings.gradle` sets `repositoriesMode` to `PREFER_SETTINGS`, project repositories are ignored, so add the beta repository there yourself — the build prints the exact entry. |
 | `iOSVersion` | `""` | Pin a specific iOS pod version; empty = newest in the supported range. |
 | `AndroidVersion` | `""` | Pin a specific Android Connect SDK version; empty = newest in the supported range. |
 | `PushEnabled` | `false` | Master switch. On Android, also gates the `connect-push-fcm` artifact inclusion. |

package/android/build.gradle

@@ -165,6 +165,46 @@ android {
   }
 }
 
+// Read consumer config at script-evaluation time so the right Connect Android
+// artifact is selected without depending on config.gradle's text-rewriting
+// pass (which only matches the analytics artifact name). Read first, because
+// the repositories below depend on it:
+//   - `PushEnabled` picks between the analytics-only and push-fcm artifacts.
+//   - `AndroidVersion` (when set) pins the version against the active artifact.
+//   - `useRelease` picks where Connect comes from (see `allprojects` below).
+import groovy.json.JsonSlurper
+def acousticConfigFile = new File("$rootDir/../ConnectConfig.json")
+def acousticConfig = acousticConfigFile.exists()
+  ? new JsonSlurper().parse(acousticConfigFile)
+  : [Connect: [:]]
+def acousticPushEnabled = (acousticConfig.Connect?.PushEnabled ?: false).toString().toBoolean()
+def acousticUseRelease = (acousticConfig.Connect?.useRelease ?: false).toString().toBoolean()
+def acousticVersionPin = (acousticConfig.Connect?.AndroidVersion ?: '').trim()
+def acousticVersion = acousticVersionPin.isEmpty() ? '+' : acousticVersionPin
+def acousticArtifact = acousticPushEnabled ? 'connect-push-fcm' : 'connect'
+
+println "AcousticConnectRN: PushEnabled=$acousticPushEnabled, useRelease=$acousticUseRelease, artifact=io.github.go-acoustic:$acousticArtifact:$acousticVersion"
+
+// The supported Connect Android range — the same bounds as the `strictly`
+// constraints below. Checked up front because the constraint cannot reject a
+// pin on its own: a strict range is itself a request for the newest version in
+// range, so an out-of-range pin was silently replaced by that version.
+def acousticMinVersion = [11, 0, 11]
+def acousticMaxVersionExclusive = [12, 0, 0]
+def acousticSupportedRange = "[${acousticMinVersion.join('.')}, ${acousticMaxVersionExclusive.join('.')})"
+if (!acousticVersionPin.isEmpty()) {
+  def m = acousticVersionPin =~ /^(\d+)\.(\d+)\.(\d+)/
+  def compare = { a, b -> [a, b].transpose().collect { x, y -> x <=> y }.find { it != 0 } ?: 0 }
+  def parts = m.find() ? [m.group(1), m.group(2), m.group(3)].collect { it as int } : null
+  if (parts == null || compare(parts, acousticMinVersion) < 0 || compare(parts, acousticMaxVersionExclusive) >= 0) {
+    throw new GradleException(
+      "AcousticConnectRN: ConnectConfig.json Connect.AndroidVersion '$acousticVersionPin' is outside the " +
+      "supported Connect Android range $acousticSupportedRange. " +
+      "Set a version in that range, or leave it empty to use the newest."
+    )
+  }
+}
+
 repositories {
   mavenCentral()
   google()
@@ -174,36 +214,33 @@ 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.
+        // `useRelease` decides where Connect comes from, for this module AND —
+        // via config.gradle, which declares the same switch in the consuming
+        // app — for the APK. The two must agree: this module compiles against
+        // whatever it resolves here, while the app packages what the app
+        // resolves, and a bridge compiled against a newer Connect than the APK
+        // carries fails at runtime with NoSuchMethodError, not at build time.
         //
-        // 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.
+        //   useRelease: false (default) — the GitHub-hosted Maven tree, where
+        //     Connect betas publish (they do not reach Maven Central). Central
+        //     is still consulted for versions this tree does not carry.
+        //   useRelease: true — Maven Central only, betas rejected below.
         //
-        // 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.
+        // `connect` resolves through a dynamic version, so Gradle queries
+        // every declared repository and takes the newest match across all of
+        // them; position only matters for a pinned version both carry, where
+        // the artifact is identical. The content filter is not cosmetic:
+        // without it every dependency in the build would hit
+        // raw.githubusercontent and 404 before falling through.
         //
         // 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" }
+        if (!acousticUseRelease) {
+            maven {
+                url = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
+                content { includeGroup "io.github.go-acoustic" }
+            }
         }
 
         mavenCentral()
@@ -216,23 +253,22 @@ allprojects {
     }
 }
 
-// Read consumer config at script-evaluation time so the right Connect Android
-// artifact is selected without depending on config.gradle's text-rewriting
-// pass (which only matches the analytics artifact name). Both `PushEnabled`
-// and `AndroidVersion` are read directly here:
-//   - `PushEnabled` picks between the analytics-only and push-fcm artifacts.
-//   - `AndroidVersion` (when set) pins the version against the active artifact.
-import groovy.json.JsonSlurper
-def acousticConfigFile = new File("$rootDir/../ConnectConfig.json")
-def acousticConfig = acousticConfigFile.exists()
-  ? new JsonSlurper().parse(acousticConfigFile)
-  : [Connect: [:]]
-def acousticPushEnabled = (acousticConfig.Connect?.PushEnabled ?: false).toString().toBoolean()
-def acousticVersionPin = (acousticConfig.Connect?.AndroidVersion ?: '').trim()
-def acousticVersion = acousticVersionPin.isEmpty() ? '+' : acousticVersionPin
-def acousticArtifact = acousticPushEnabled ? 'connect-push-fcm' : 'connect'
-
-println "AcousticConnectRN: PushEnabled=$acousticPushEnabled, artifact=io.github.go-acoustic:$acousticArtifact:$acousticVersion"
+// Same beta rejection config.gradle applies to the app, so with
+// `useRelease: true` this module cannot compile against a beta either — a
+// beta reached through the Sonatype staging repo or an `AndroidVersion` pin
+// fails resolution here instead of diverging from the APK. eocore is exempt:
+// its release line carries a `-beta` suffix (see config.gradle).
+if (acousticUseRelease) {
+  configurations.all {
+    resolutionStrategy.componentSelection.all { selection ->
+      if (selection.candidate.group == 'io.github.go-acoustic' &&
+          selection.candidate.module != 'eocore' &&
+          selection.candidate.version.endsWith('-beta')) {
+        selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
+      }
+    }
+  }
+}
 
 dependencies {
   // Provided by the host app at runtime — compileOnly avoids version conflicts
@@ -284,18 +320,33 @@ dependencies {
   // to releases that lack APIs this bridge calls; upper bound prevents a
   // future 12.x major (with potentially breaking changes) from being picked
   // up automatically by Gradle's `+` resolver. Both halves are `strictly` so
-  // an attempted override via `Connect.AndroidVersion` fails loudly at
-  // resolution time rather than surfacing as a runtime `ClassNotFoundException`
-  // or method-missing error. Constraints are declared for both artifact
+  // nothing else in the build can move Connect outside them. A
+  // `Connect.AndroidVersion` outside the range fails at configuration time
+  // (the check after the config read above), not here. Constraints are declared for both artifact
   // names — Gradle only enforces the one that resolves into the graph, so
   // the unused entry is inert.
+  //
+  // An `AndroidVersion` pin is applied to BOTH constraints as `prefer`. With
+  // push enabled the only direct dependency is `connect-push-fcm`, so the pin
+  // used to reach `connect` only through that artifact's POM — and a strict
+  // range is itself a request that resolves to the newest version in range,
+  // so it outranked the transitive pin and floated `connect` past it
+  // (`connect-push-fcm:11.1.5-beta` shipped with `connect:11.1.6-beta`).
+  // `prefer` inside the strict range keeps the range as the hard bound and
+  // makes the pin the version chosen within it.
   constraints {
     implementation('io.github.go-acoustic:connect') {
-      version { strictly '[11.0.11, 12.0.0)' }
+      version {
+        strictly acousticSupportedRange
+        if (!acousticVersionPin.isEmpty()) { prefer acousticVersionPin }
+      }
       because 'AcousticConnectRN requires Connect Android SDK in [11.0.11, 12.0.0). Bump the upper bound after validating compatibility with a new major.'
     }
     implementation('io.github.go-acoustic:connect-push-fcm') {
-      version { strictly '[11.0.11, 12.0.0)' }
+      version {
+        strictly acousticSupportedRange
+        if (!acousticVersionPin.isEmpty()) { prefer acousticVersionPin }
+      }
       because 'connect-push-fcm tracks the same release line as the core connect artifact.'
     }
   }

package/android/config.gradle

@@ -425,13 +425,100 @@ def updateEOCoreAdvConfig(mp, json) {
     println("Updating:$eocoreAdvConfigPath")
 }
 
+// With `useRelease: false`, the app has to resolve Connect from the beta tree
+// too. The SDK module's android/build.gradle declares it for the module's own
+// classpath, but the APK packages what *this* project — the app — resolves,
+// and an app that cannot see the tree silently gets Central's newest release
+// instead: a different Connect from the one the bridge was compiled against,
+// which fails at runtime with NoSuchMethodError. This script is applied from
+// the app's build.gradle, so the repository declared here is the app's.
+//
+// Apps that centralise repositories in settings.gradle cannot take a project
+// repository: FAIL_ON_PROJECT_REPOS fails the build on one, PREFER_SETTINGS
+// ignores it — for every project, the SDK module included, so the two still
+// agree (on Central). For those, say what to add rather than fail or stay silent.
+def addBetaRepository(proj) {
+    // The GitHub-hosted Maven tree Connect betas publish to. They do not reach
+    // Maven Central, which carries release versions only. Local to the method:
+    // a script-level `def` is not visible inside script methods.
+    def ACOUSTIC_BETA_REPO_URL = "https://raw.githubusercontent.com/go-acoustic/Android_Maven/master"
+    def mode = null
+    def inSettings = false
+    try {
+        def drm = proj.gradle.settings.dependencyResolutionManagement
+        mode = drm.repositoriesMode.get().toString()
+        inSettings = drm.repositories.any { repo ->
+            repo.hasProperty('url') && repo.url.toString().startsWith(ACOUSTIC_BETA_REPO_URL)
+        }
+    } catch (Throwable ignored) {
+        // Older Gradle, or no settings-level repository management: nothing to respect.
+    }
+    if (inSettings) {
+        println("AcousticConnect: useRelease is false — Connect beta repository already declared in settings.gradle")
+        return
+    }
+    if (mode == "FAIL_ON_PROJECT_REPOS" || mode == "PREFER_SETTINGS") {
+        println("WARNING: AcousticConnect: useRelease is false, but settings.gradle sets repositoriesMode " +
+            "$mode, so the Connect beta repository cannot be added to the app. Add it to " +
+            "dependencyResolutionManagement.repositories in settings.gradle:\n" +
+            "    maven {\n" +
+            "        url = \"$ACOUSTIC_BETA_REPO_URL\"\n" +
+            "        content { includeGroup \"io.github.go-acoustic\" }\n" +
+            "    }\n" +
+            "Without it Connect resolves from Maven Central only — for the app and this SDK alike, since " +
+            "settings repositories replace project ones — so betas are not used. Or set useRelease to " +
+            "true to make that explicit.")
+        return
+    }
+    proj.repositories {
+        maven {
+            url = ACOUSTIC_BETA_REPO_URL
+            content { includeGroup "io.github.go-acoustic" }
+        }
+    }
+    println("AcousticConnect: useRelease is false — resolving Connect from $ACOUSTIC_BETA_REPO_URL")
+}
+
+// With `useRelease: true`, reject every go-acoustic beta in the app's resolution.
+// android/build.gradle applies the same rule to the SDK module.
+def rejectBetaVersions(proj) {
+    proj.configurations.all {
+        resolutionStrategy {
+            componentSelection {
+                all { selection ->
+                    // Exempt the eocore artifact from beta rejection.
+                    // Full Maven coordinate: io.github.go-acoustic:eocore
+                    // (verified on Maven Central — the POM declares
+                    // <groupId>io.github.go-acoustic</groupId> +
+                    // <artifactId>eocore</artifactId>, so candidate.module is
+                    // literally 'eocore').
+                    // Unlike the other go-acoustic artifacts, eocore's RELEASE
+                    // line carries a `-beta` suffix — Maven Central lists
+                    // 2.1.24-beta as <release>/<latest>, and the release
+                    // connect:11.0.13 → tealeaf:10.4.28 chain pins eocore
+                    // transitively to that version. Without this carve-out the
+                    // blanket `-beta` reject would drop a legitimate release
+                    // artifact and break every useRelease=true build.
+                    if (selection.candidate.group == 'io.github.go-acoustic' &&
+                        selection.candidate.module != 'eocore' &&
+                        selection.candidate.version.endsWith('-beta')) {
+                        selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
+                    }
+                }
+            }
+        }
+    }
+}
+
 def updateGradle(mp, json){
     def buildGradlePath = "$mp/build.gradle"
     def buildGradleFile = new File(buildGradlePath)
     def updatedBuildGradle = buildGradleFile.text
 
     if (json != null && json.Connect) {
-        def useRelease = json.Connect.useRelease ?: false
+        // Parsed as android/build.gradle parses it, so the module and the app agree on
+        // the value even when it is written as a string ("false" is truthy in Groovy).
+        def useRelease = (json.Connect.useRelease ?: false).toString().toBoolean()
 
         if(json.Connect.AndroidVersion != null) {
             def connectSDK = "io.github.go-acoustic:connect:"
@@ -443,33 +530,11 @@ def updateGradle(mp, json){
             updatedBuildGradle = updatedBuildGradle.replaceAll(~/io.github.go-acoustic:connect:(\+|\d+\.\d+\.\d+(-beta)?)/, connectSDK)
         }
 
+        // Exactly one of the two per build: release-only resolution, or the beta tree.
         if (useRelease) {
-            project.configurations.all {
-                resolutionStrategy {
-                    componentSelection {
-                        all { selection ->
-                            // Exempt the eocore artifact from beta rejection.
-                            // Full Maven coordinate: io.github.go-acoustic:eocore
-                            // (verified on Maven Central — the POM declares
-                            // <groupId>io.github.go-acoustic</groupId> +
-                            // <artifactId>eocore</artifactId>, so candidate.module is
-                            // literally 'eocore').
-                            // Unlike the other go-acoustic artifacts, eocore's RELEASE
-                            // line carries a `-beta` suffix — Maven Central lists
-                            // 2.1.24-beta as <release>/<latest>, and the release
-                            // connect:11.0.13 → tealeaf:10.4.28 chain pins eocore
-                            // transitively to that version. Without this carve-out the
-                            // blanket `-beta` reject would drop a legitimate release
-                            // artifact and break every useRelease=true build.
-                            if (selection.candidate.group == 'io.github.go-acoustic' &&
-                                selection.candidate.module != 'eocore' &&
-                                selection.candidate.version.endsWith('-beta')) {
-                                selection.reject("useRelease is true — rejecting beta version ${selection.candidate.version}")
-                            }
-                        }
-                    }
-                }
-            }
+            rejectBetaVersions(project)
+        } else {
+            addBetaRepository(project)
         }
     }
 

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

@@ -1,4 +1,4 @@
-#Wed Sep 30 09:13:37 GMT 2026
+#Thu Oct 01 14:25:53 GMT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

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

@@ -819,32 +819,23 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
     /**
      * Log click events on react native control.
      *
+     * The view lookup and the SDK call both run on the main looper — see
+     * [withResolvedView].
+     *
      * @param target    Target id of the control.
      * @param controlId Accessibility ID(virtual id).
-     * @return True if the operation was successful, false otherwise.
+     * @return True if the event was handed to the main looper, false without a
+     *   React context. It cannot report whether the view resolved.
      */
     override fun logClickEvent(target: Double, controlId: String): Boolean {
-        val viewTag = target.toInt()
-        return try {
-            val ctx = applicationContext ?: return false
-            val uiManager = UIManagerHelper.getUIManagerForReactTag(ctx, viewTag)
-                ?: return false
-            val view = uiManager.resolveView(viewTag) ?: return false
-
-            Handler(Looper.getMainLooper()).post {
-                val activity = getCurrentActivity() ?: return@post
-                if (view is EditText) {
-                    addFocusAndRegister(view, null, activity)
-                } else if (TextUtils.isEmpty(controlId)) {
-                    logEvent(view, "click")
-                } else {
-                    logEvent(view, "click", controlId)
-                }
+        return withResolvedView(target.toInt(), "logClickEvent") { view, activity ->
+            if (view is EditText) {
+                addFocusAndRegister(view, null, activity)
+            } else if (TextUtils.isEmpty(controlId)) {
+                logEvent(view, "click")
+            } else {
+                logEvent(view, "click", controlId)
             }
-            true
-        } catch (e: Exception) {
-            Log.v(TAG, "logClickEvent error: ${e.message}", e)
-            false
         }
     }
 
@@ -852,28 +843,16 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * Log click events on react native control.
      *
      * @param target    Target id of the control.
-     * @return True if the operation was successful, false otherwise.
+     * @return True if the event was handed to the main looper, false without a
+     *   React context. It cannot report whether the view resolved.
      */
     fun logClickEvent(target: Double): Boolean {
-        val viewTag = target.toInt()
-        return try {
-            val ctx = applicationContext ?: return false
-            val uiManager = UIManagerHelper.getUIManagerForReactTag(ctx, viewTag)
-                ?: return false
-            val view = uiManager.resolveView(viewTag) ?: return false
-
-            Handler(Looper.getMainLooper()).post {
-                val activity = getCurrentActivity() ?: return@post
-                if (view is EditText) {
-                    addFocusAndRegister(view, null, activity)
-                } else {
-                    logEvent(view, "click")
-                }
+        return withResolvedView(target.toInt(), "logClickEvent") { view, activity ->
+            if (view is EditText) {
+                addFocusAndRegister(view, null, activity)
+            } else {
+                logEvent(view, "click")
             }
-            true
-        } catch (e: Exception) {
-            Log.v(TAG, "logClickEvent error: ${e.message}")
-            false
         }
     }
 
@@ -883,30 +862,59 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
      * @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.
+     * @return True if the event was handed to the main looper, false without a
+     *   React context. It cannot report whether the view resolved.
      */
     override fun logTextChangeEvent(target: Double, controlId: String, text: Variant_NullType_String?): Boolean {
-        val viewTag = target.toInt()
-        return try {
-            val ctx = applicationContext ?: return false
-            val uiManager = UIManagerHelper.getUIManagerForReactTag(ctx, viewTag)
-                ?: return false
-            val view = uiManager.resolveView(viewTag) ?: return false
-
-            Handler(Looper.getMainLooper()).post {
-                val activity = getCurrentActivity() ?: return@post
-                if (view is EditText && view.onFocusChangeListener == null) {
-                    logEvent(view, TLF_ON_FOCUS_CHANGE_IN, controlId)
-                    addFocusAndRegister(view, controlId, activity)
-                }
+        return withResolvedView(target.toInt(), "logTextChangeEvent") { view, activity ->
+            if (view is EditText && view.onFocusChangeListener == null) {
+                logEvent(view, TLF_ON_FOCUS_CHANGE_IN, controlId)
+                addFocusAndRegister(view, controlId, activity)
             }
-            true
-        } catch (e: Exception) {
-            Log.v(TAG, "logTextChangeEvent error: ${e.message}")
-            false
         }
     }
 
+    /**
+     * Resolves the native view behind a React tag and hands it to [block], with
+     * the lookup and the block both running on the main looper.
+     *
+     * Nitro calls arrive on the JS thread, and Fabric's `resolveView` must run
+     * on the UI thread. The bridge used to resolve first and post second, so
+     * every tap logged `AssertionException: Expected to run on UI thread!` in
+     * debug builds. That assertion is soft — the view still came back — but
+     * the lookup was reading the mounting layer's view map while the UI thread
+     * mutates it.
+     *
+     * The whole block is guarded, not just the lookup. `getView` throws when
+     * the view was unmounted between the tap and this post running, and an
+     * exception escaping a posted block is uncaught on the main thread — a
+     * crash, where the old off-thread lookup only returned false.
+     *
+     * @param viewTag React tag of the touched view.
+     * @param api     Name of the bridge method, for the log line.
+     * @param block   Work to do with the resolved view and current activity;
+     *   skipped when either is unavailable.
+     * @return False without a React context, true once the work is posted.
+     */
+    private fun withResolvedView(
+        viewTag: Int,
+        api: String,
+        block: (View, Activity) -> Unit
+    ): Boolean {
+        val ctx = applicationContext ?: return false
+        runOnMain {
+            try {
+                val view = UIManagerHelper.getUIManagerForReactTag(ctx, viewTag)
+                    ?.resolveView(viewTag) ?: return@runOnMain
+                val activity = getCurrentActivity() ?: return@runOnMain
+                block(view, activity)
+            } catch (e: Exception) {
+                Log.v(TAG, "$api error: ${e.message}", e)
+            }
+        }
+        return true
+    }
+
     /**
      * Whether the bridge may touch capture at all.
      *

package/package.json

@@ -228,7 +228,7 @@
     "source": "src/index",
     "summary": "react-native ios android tealeaf connect cxa wxca er enhanced-replay",
     "types": "./lib/typescript/src/index.d.ts",
-    "version": "19.1.3",
+    "version": "19.1.5",
     "workspaces": [
         "example",
         "Examples/bare-workflow"