react-native-acoustic-connect-beta 18.0.29 → 18.0.30

package/AcousticConnectRN.podspec

@@ -2,8 +2,25 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
-# package = JSON.parse(File.read('package.json'))
-connectConfig = JSON.parse(File.read('../../ConnectConfig.json'))
+# Resolve the consumer's ConnectConfig.json from the Podfile's project root.
+#
+# Using CocoaPods' install root (the directory containing the Podfile) rather
+# than a path relative to this podspec makes config resolution correct in every
+# layout, so SDK integration is seamless for clients:
+#   - Standalone consumer: the pod lives under <app>/node_modules, the install
+#     root is <app>/ios, so <install_root>/../ConnectConfig.json resolves to
+#     <app>/ConnectConfig.json.
+#   - In-repo example apps (this monorepo's Examples/*): the install root is the
+#     example's own ios/ dir, so it resolves to that example's ConnectConfig.json
+#     instead of escaping above the repo (which a podspec-relative climb did).
+# Falls back to the legacy podspec-relative path when the install root isn't
+# available (e.g. `pod spec lint`), preserving prior behaviour.
+installRoot = (defined?(Pod::Config) && Pod::Config.instance.installation_root) || nil
+consumerConfigPath = File.join(installRoot.to_s, '..', 'ConnectConfig.json') if installRoot
+connectConfigPath =
+  (consumerConfigPath && File.exist?(consumerConfigPath)) ? consumerConfigPath
+                                                          : File.join(__dir__, '..', '..', 'ConnectConfig.json')
+connectConfig = JSON.parse(File.read(connectConfigPath))
 repository = package["repository"]["url"]
 useRelease = connectConfig["Connect"]["useRelease"]
 dependencyName = useRelease ? 'AcousticConnect' : 'AcousticConnectDebug'

package/android/build.gradle

@@ -188,6 +188,23 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "io.github.go-acoustic:$acousticArtifact:$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
+  // published POM does NOT declare firebase-messaging, so the transitive
+  // never arrives. Without it the push classes fail to link at runtime and
+  // push silently stays inactive — the bridge logs
+  // `connect-push-fcm on classpath: false` and no FCM token is ever
+  // requested. Gated by the same `PushEnabled` flag so analytics-only
+  // 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.
+  if (acousticPushEnabled) {
+    implementation platform('com.google.firebase:firebase-bom:33.7.0')
+    implementation 'com.google.firebase:firebase-messaging'
+  }
+
   // Version range enforced by the RN bridge. Lower bound prevents downgrades
   // to releases that lack APIs this bridge calls; upper bound prevents a
   // future 12.x major (with potentially breaking changes) from being picked

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

@@ -1,4 +1,4 @@
-#Fri Jun 05 02:59:23 PDT 2026
+#Thu Jun 11 03:38:51 PDT 2026
 UseWhiteList=true
 PrintScreen=3
 UseRandomSample=false

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

@@ -49,6 +49,7 @@ import com.acoustic.connect.android.connectmod.Connect.onResume
 import com.acoustic.connect.android.connectmod.Connect.registerFormField
 import com.acoustic.connect.android.connectmod.Connect.resumeConnect
 import com.acoustic.connect.android.connectmod.push.PushPermissionState
+import com.acoustic.connect.android.connectmod.push.core.MobileServiceType
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.UIManagerHelper
@@ -156,9 +157,59 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             Connect.init(app)
         }
         Connect.enable()
+        maybeEnablePushOnMain(app)
         Log.i(TAG, "[bridge] SDK auto-initialised at bridge construction")
     }
 
+    /**
+     * Bootstraps the native Connect push transport when the push variant is
+     * present. This is REQUIRED — it is not automatic. The `connect` /
+     * `connect-push-fcm` AARs declare no ContentProvider or `Startup`
+     * initializer, so nothing self-bootstraps `ConnectPush`. Its
+     * `enable(...)` is the sole entry point that creates the FCM
+     * [com.acoustic.connect.android.connectmod.push.PushService] transport,
+     * sets `isInitialized = true`, registers the activity-lifecycle
+     * callbacks, and constructs the `TokenUpdaterReceiver` that turns the
+     * FCM `onNewToken` broadcast into a Connect PushRegistration. Without
+     * this call the token broadcast is dropped and `sendToken()` no-ops on
+     * `isInitialized == false`, so no registration ever reaches Connect.
+     *
+     * Gated by [isConnectPushFcmAvailable] so analytics-only
+     * (`PushEnabled=false`) builds — which bundle no Firebase — never touch
+     * the FCM transport classes. Idempotent: short-circuits once
+     * `Connect.push.isInitialized()` is true, so it is safe to call from
+     * every init path (construction auto-init, JS `enable()`, lifecycle
+     * resume). `MobileServiceType.FCM` is hard-coded: FCM is the only push
+     * provider on the JS surface (HMS was dropped — see deviation 4).
+     *
+     * MUST be called on the main looper, after `Connect.enable()`.
+     */
+    private fun maybeEnablePushOnMain(application: Application) {
+        if (!isConnectPushFcmAvailable()) return
+        if (Connect.push.isInitialized()) return
+        val smallIconRes = resolvePushSmallIconRes(application)
+        Connect.push.enable(application, true, smallIconRes, MobileServiceType.FCM) { e ->
+            Log.w(TAG, "[bridge] push enable failed — ${e.message}")
+        }
+        Log.i(TAG, "[bridge] Connect push transport enabled (FCM)")
+    }
+
+    /**
+     * Resolves the status-bar notification small-icon drawable for push.
+     * Looks up `ic_stat_push` (the demo's committed monochrome icon, also
+     * the `AndroidNotificationIconResName` convention) and falls back to the
+     * app's launcher icon when absent, so consumers that didn't add a
+     * dedicated push icon still get a valid resource rather than `0`.
+     */
+    private fun resolvePushSmallIconRes(application: Application): Int {
+        val byName = application.resources.getIdentifier(
+            "ic_stat_push",
+            "drawable",
+            application.packageName,
+        )
+        return if (byName != 0) byName else application.applicationInfo.icon
+    }
+
     /**
      * Resolves the host app's `Application` from
      * `NitroModules.applicationContext`. Returns `null` (with a logged
@@ -214,6 +265,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             }
             Connect.init(application)
             Connect.enable()
+            maybeEnablePushOnMain(application)
             Log.i(TAG, "[bridge] SDK initialised")
         }
         return true
@@ -235,31 +287,40 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
 
     // region Push (Android)
     //
-    // The shared Nitro spec declares these push methods on both platforms. On
-    // Android the native SDK owns the ENTIRE push lifecycle — Connect's own
-    // FirebaseMessagingService (shipped in connect-push-fcm) handles inbound
-    // delivery, PushReceived / PushAction logging, and token registration
-    // automatically. Unlike iOS, Android has no manual JS-forwarding API, so
-    // every JS→native forwarder is a no-op that reports "handled", kept only
-    // for cross-platform API symmetry:
+    // The shared Nitro spec declares these push methods on both platforms.
+    // Once the bridge bootstraps the native push transport via
+    // [maybeEnablePushOnMain] (`Connect.push.enable(..., MobileServiceType.FCM)`
+    // at SDK init), the native SDK owns the rest of the push lifecycle:
+    // Connect's own FirebaseMessagingService (shipped in connect-push-fcm)
+    // handles inbound delivery and PushReceived / PushAction logging, and the
+    // `TokenUpdaterReceiver` registered by `enable(...)` turns the FCM
+    // `onNewToken` broadcast into a Connect PushRegistration. That bootstrap
+    // is NOT automatic — the AARs declare no ContentProvider / Startup
+    // initializer, so without the `enable(...)` call no token ever registers.
+    //
+    // After bootstrap there is no manual JS-forwarding API on Android (unlike
+    // iOS), so every JS→native forwarder below is a no-op that reports
+    // "handled", kept only for cross-platform API symmetry:
     //   - pushDidReceiveNotification, pushDidReceiveResponse,
     //     pushDidRegisterWithToken, pushDidFailToRegister,
     //     pushDidReceiveAuthorization
     //
-    // The only Android-relevant behaviour is permission wiring:
+    // The only Android-relevant runtime interaction is permission wiring:
     //   - pushRequestPermission / pushGetPermissionState — POST_NOTIFICATIONS
     //
     // pushGetToken / pushGetTokenAsync are intentionally NOT on the surface —
-    // parked (the native SDK registers the token with Connect automatically;
-    // no JS accessor is needed). None of these methods reject.
+    // parked (the native transport registers the token with Connect once
+    // enabled; no JS accessor is needed). None of these methods reject.
 
     /**
-     * iOS-primary forwarder. On Android the FCM token is captured and registered
-     * with Connect automatically by the native messaging service, so this is a
-     * no-op that reports "handled". Never rejects.
+     * iOS-primary forwarder. On Android the FCM token is captured and
+     * registered with Connect by the native transport once it is bootstrapped
+     * via [maybeEnablePushOnMain] (the `TokenUpdaterReceiver` set up by
+     * `Connect.push.enable(...)` consumes the `onNewToken` broadcast), so this
+     * JS forwarder is a no-op that reports "handled". Never rejects.
      */
     override fun pushDidRegisterWithToken(deviceToken: ArrayBuffer): Promise<Boolean> {
-        Log.d(TAG, "[bridge] pushDidRegisterWithToken: no-op on Android (native SDK owns token registration)")
+        Log.d(TAG, "[bridge] pushDidRegisterWithToken: no-op on Android (native transport owns token registration once enabled)")
         return Promise.resolved(true)
     }
 
@@ -1283,6 +1344,7 @@ class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
             // call the native SDK's `Connect.enable()` directly so the
             // log line "called from JS" doesn't fire on lifecycle wake-ups.
             Connect.enable()
+            resolveApplication()?.let { maybeEnablePushOnMain(it) }
         }
         onResume(activity, null)
     }

package/ios/AcousticConnectRNConfig.json

@@ -1,10 +1,14 @@
 {
   "Connect": {
-    "AndroidVersion": "11.0.12-beta",
     "AppKey": "b6c3709b7a4c479bb4b5a9fb8fec324c",
     "KillSwitchUrl": "https://lib-us-2.brilliantcollector.com/collector/switch/b6c3709b7a4c479bb4b5a9fb8fec324c",
     "PostMessageUrl": "https://lib-us-2.brilliantcollector.com/collector/collectorPost",
+    "AndroidVersion": "",
     "iOSVersion": "",
+    "PushEnabled": false,
+    "iOSPushMode": "automatic",
+    "iOSAppGroupIdentifier": null,
+    "AndroidNotificationIconResName": null,
     "layoutConfigAndroid": {
       "AppendMapIds": {
         "[w,9290],[v,0]": {

package/package.json

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