react-native-acoustic-connect-beta 18.0.22 → 18.0.24

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

@@ -49,8 +49,7 @@ import com.acoustic.connect.android.connectmod.Connect.registerFormField
 import com.acoustic.connect.android.connectmod.Connect.resumeConnect
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.NativeViewHierarchyManager
-import com.facebook.react.uimanager.UIManagerModule
+import com.facebook.react.uimanager.UIManagerHelper
 import com.ibm.eo.EOCore
 import com.ibm.eo.model.EOMonitoringLevel
 import com.margelo.nitro.NitroModules.Companion.applicationContext
@@ -65,22 +64,201 @@ import com.tl.uic.util.keyboardview.KeyboardView
 import java.util.Objects
 
 
-class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext) : HybridAcousticConnectRNSpec(),
+class HybridAcousticConnectRN : HybridAcousticConnectRNSpec(),
     LifecycleEventListener {
 
+    // The Nitro C++ factory (`AcousticConnectRNOnLoad.cpp`) instantiates this
+    // class with `getConstructor<()>()` — i.e. it expects a zero-arg
+    // constructor. The React context can therefore not be passed in at
+    // construction time; we resolve it lazily via `NitroModules.applicationContext`
+    // (which is nullable until the React context attaches), guard every
+    // access, and retry the lifecycle-listener registration on each
+    // `enable()` call until it succeeds.
+
+    // Touched only on the main looper. All read/write goes through
+    // `runOnMain { ... }` (called from `init`, `enable()`, etc.), so the
+    // unsynchronised access pattern is safe — the field's mutating thread
+    // and reading thread are the same.
+    private var lifecycleListenerRegistered = false
+
     init {
-        // Add your listener logic here
-        Log.v(TAG, "HybridAcousticConnectRNSpec has been initialized")
+        Log.v(TAG, "[bridge] HybridAcousticConnectRN constructed")
+        runOnMain {
+            tryRegisterLifecycleListenerOnMain()
+            // Cold-start auto-init: mirrors the iOS bridge's behaviour, where
+            // `load()` runs inside the constructor's `Task { @MainActor in … }`
+            // and initialises the SDK without waiting for an explicit JS
+            // call. Without this, an Android cold start where the first
+            // activity `onResume` fires before the lifecycle listener was
+            // registered (slow JS bundle, RAM-bundle apps, dev hot reload)
+            // would leave the SDK uninitialised until the next resume.
+            maybeAutoInitOnMain()
+        }
+    }
 
-        Handler(Looper.getMainLooper()).post {
-            if (reactContext.hasActiveCatalystInstance()) {
-                reactContext.addLifecycleEventListener(this)
-            } else {
-                Log.v(TAG, "ReactContext is not ready. LifecycleEventListener not registered.")
+    /**
+     * Posts to the main looper. Used by every operation that touches
+     * `lifecycleListenerRegistered`, registers a `LifecycleEventListener`,
+     * or calls into `Connect.init`/`Connect.enable`/`Connect.disable` — so
+     * all of those operations execute single-threaded on main, eliminating
+     * read-then-write races on the registration flag.
+     */
+    private fun runOnMain(block: () -> Unit) {
+        Handler(Looper.getMainLooper()).post(block)
+    }
+
+    /**
+     * Idempotent: registers this hybrid as a React lifecycle listener the
+     * first time `NitroModules.applicationContext` is non-null, then no-ops.
+     *
+     * MUST be called on the main looper. Callers funnel through
+     * [runOnMain]; the read-then-write of `lifecycleListenerRegistered` is
+     * therefore single-threaded by construction.
+     */
+    private fun tryRegisterLifecycleListenerOnMain() {
+        if (lifecycleListenerRegistered) return
+        val ctx = applicationContext
+        if (ctx == null) {
+            Log.v(TAG, "[bridge] React context not ready; lifecycle listener registration deferred")
+            return
+        }
+        ctx.addLifecycleEventListener(this)
+        lifecycleListenerRegistered = true
+        Log.v(TAG, "[bridge] Lifecycle listener registered")
+    }
+
+    /**
+     * Cold-start auto-init helper. Calls `Connect.init` + `Connect.enable`
+     * if the SDK isn't already running and the React context is attached.
+     * MUST be called on the main looper.
+     *
+     * Idempotent at every level:
+     * - If the SDK is already enabled, returns immediately.
+     * - If the context isn't ready, returns without acting (the subsequent
+     *   `onHostResume` lifecycle callback or an explicit `enable()` from JS
+     *   will retry).
+     * - `Connect.init` and `Connect.enable` are themselves idempotent in
+     *   the native SDK, so this co-existing with a later JS-driven
+     *   `enable()` is safe.
+     */
+    private fun maybeAutoInitOnMain() {
+        if (Connect.isEnabled()) return
+        val app = resolveApplication() ?: return
+        if (Connect.getApplication() == null) {
+            Connect.init(app)
+        }
+        Connect.enable()
+        Log.i(TAG, "[bridge] SDK auto-initialised at bridge construction")
+    }
+
+    /**
+     * Resolves the host app's `Application` from
+     * `NitroModules.applicationContext`. Returns `null` (with a logged
+     * warning) when the React context isn't attached yet — callers must
+     * bail rather than NPE. Replaces the previous direct deref through a
+     * constructor-injected `ReactApplicationContext` field, which was unsafe
+     * because Nitro's factory passes a null JNI handle through Kotlin's
+     * non-null platform type.
+     */
+    private fun resolveApplication(): Application? {
+        val app = applicationContext?.applicationContext as? Application
+        if (app == null) {
+            Log.w(TAG, "[bridge] Application not yet available (NitroModules.applicationContext is null or its applicationContext is not an Application)")
+        }
+        return app
+    }
+
+    // region Gate-keeper API (CA-137696)
+
+    /**
+     * Re-enables the Connect SDK after a prior `disable()`. All configuration
+     * comes from `ConnectConfig.json` at the consumer's project root, which
+     * `config.gradle` bakes into `ConnectBasicConfig.properties` /
+     * `TealeafBasicConfig.properties` at build time.
+     *
+     * Idempotency is owned by the native SDK. `Connect.init` is safe to call
+     * multiple times, and `Connect.enable` short-circuits once the SDK is
+     * running. The bridge does not track its own enable signature — subsequent
+     * JS calls just post another runnable that the native side will treat as
+     * a no-op.
+     *
+     * Push wiring on Android is gated at build time by `Connect.PushEnabled`
+     * in `ConnectConfig.json`, which `android/build.gradle` consults to
+     * include the `connect-push-fcm` artifact. Token forwarding to Connect
+     * lives in CA-137698 and runs through the host app's
+     * `FirebaseMessagingService`.
+     *
+     * @return true on accepted dispatch, false if no application context.
+     */
+    override fun enable(): Boolean {
+        Log.i(TAG, "[bridge] enable() called from JS")
+        logResolvedPushAvailability()
+
+        // All work happens on the main looper so the lifecycle-listener
+        // registration flag is touched single-threaded and we don't race
+        // with the `init { runOnMain { … } }` registration path. Returning
+        // `true` reflects "accepted dispatch", not "succeeded"; the actual
+        // work logs its own success or failure on main.
+        runOnMain {
+            tryRegisterLifecycleListenerOnMain()
+            val application = resolveApplication() ?: run {
+                Log.w(TAG, "[bridge] enable() bailed — Application still null on main thread")
+                return@runOnMain
             }
+            Connect.init(application)
+            Connect.enable()
+            Log.i(TAG, "[bridge] SDK initialised")
+        }
+        return true
+    }
+
+    /**
+     * Disables the Connect SDK. Idempotent — the underlying `Connect.disable()`
+     * is safe to call repeatedly on the native side; this override always
+     * returns `true` for an accepted dispatch.
+     */
+    override fun disable(): Boolean {
+        Log.i(TAG, "[bridge] disable() called from JS")
+        runOnMain {
+            Connect.disable()
+            Log.i(TAG, "[bridge] SDK disabled")
         }
+        return true
     }
 
+    /**
+     * Checks whether the `connect-push-fcm` artifact is on the classpath and
+     * logs the result. The artifact is gated by `Connect.PushEnabled` in
+     * `ConnectConfig.json` via `android/build.gradle`'s conditional
+     * `implementation` clause. A missing artifact when `PushEnabled` was set
+     * to true points at a build-pipeline issue (didn't run `config.gradle`
+     * or the conditional didn't fire). Once CA-137698 lands the actual
+     * Connect push API on Android, this method also gates the wire-up.
+     */
+    private fun logResolvedPushAvailability() {
+        val pushAvailable = isConnectPushFcmAvailable()
+        Log.i(TAG, "[config] connect-push-fcm on classpath: $pushAvailable")
+        if (!pushAvailable) {
+            Log.i(TAG, "[config] Push is not active on Android in this build. To enable, set Connect.PushEnabled=true in ConnectConfig.json and re-sync Gradle to include connect-push-fcm. Token forwarding wires in CA-137698.")
+        }
+    }
+
+    private fun isConnectPushFcmAvailable(): Boolean {
+        // Probe a known class shipped by the connect-push-fcm artifact. The
+        // exact class lives in the Connect Android SDK's push module and is
+        // finalised under CA-137698; this Class.forName probe is robust to
+        // package-name changes because it falls through silently when the
+        // class is missing (which is the default in a no-push build).
+        return try {
+            Class.forName(CONNECT_PUSH_FCM_PROBE_CLASS)
+            true
+        } catch (e: ClassNotFoundException) {
+            false
+        }
+    }
+
+    // endregion
+
     /**
      * Sets the module's boolean configuration item from AdvancedConfig.json or BasicConfig.properties that matches the specified key.
      *
@@ -282,35 +460,28 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
      * @return True if the operation was successful, false otherwise.
      */
     override fun logClickEvent(target: Double, controlId: String): Boolean {
-        var result = false
-        try {
-            val context: ReactApplicationContext = reactContext
-            // Add UI-block so we can get a valid reference to the map-view
-            val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-            Objects.requireNonNull<UIManagerModule?>(uiManager)
-                .addUIBlock { nvhm: NativeViewHierarchyManager ->
-                    val view = nvhm.resolveView(target.toInt())
-                    if (view == null) {
-                        result = false
-                    } else {
-                        if (view is EditText) {
-                            addFocusAndRegister(view, null, getCurrentActivity()!!)
-                        } else {
-                            if (!TextUtils.isEmpty(controlId)) {
-                                logEvent(view, "click", controlId)
-                            } else {
-                                logEvent(view, "click")
-                            }
-                        }
-                        result = true
-                    }
+        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)
                 }
-        } catch (e: java.lang.Exception) {
-            // Handle the exception
-            result = false
+            }
+            true
+        } catch (e: Exception) {
+            Log.v(TAG, "logClickEvent error: ${e.message}", e)
+            false
         }
-        return result
     }
 
     /**
@@ -320,31 +491,26 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
      * @return True if the operation was successful, false otherwise.
      */
     fun logClickEvent(target: Double): Boolean {
-        var result = false
-        try {
-            val context: ReactApplicationContext = reactContext
-            // Add UI-block so we can get a valid reference to the map-view
-            val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-            Objects.requireNonNull<UIManagerModule?>(uiManager)
-                .addUIBlock { nvhm: NativeViewHierarchyManager ->
-                    val view = nvhm.resolveView(target.toInt())
-                    if (view == null) {
-                        result = false
-                    } else {
-                        if (view is EditText) {
-                            addFocusAndRegister(view as EditText, null, getCurrentActivity()!!)
-                        } else {
-                            logEvent(view, "click")
-                        }
-                        result = true
-                    }
+        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")
                 }
-        } catch (e: java.lang.Exception) {
-            // Handle the exception
-            result = false
+            }
+            true
+        } catch (e: Exception) {
+            Log.v(TAG, "logClickEvent error: ${e.message}")
+            false
         }
-        return result
     }
 
     /**
@@ -356,31 +522,25 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
      * @return True if the operation was successful, false otherwise.
      */
     override fun logTextChangeEvent(target: Double, controlId: String, text: Variant_NullType_String?): Boolean {
-        var result = false
-        try {
-            val context: ReactApplicationContext = reactContext
-            // Add UI-block so we can get a valid reference to the map-view
-            val uiManager = context.getNativeModule(UIManagerModule::class.java)
-
-            Objects.requireNonNull<UIManagerModule?>(uiManager)
-                .addUIBlock { nvhm: NativeViewHierarchyManager ->
-                    val view = nvhm.resolveView(target.toInt())
-                    if (view == null) {
-                        result = false
-                    } else {
-                        if (view is EditText && (view as EditText).onFocusChangeListener == null) {
-                            // First time, logEvent and subsequent calls will be handled in change listener
-                            logEvent(view, TLF_ON_FOCUS_CHANGE_IN, controlId)
-                            addFocusAndRegister(view as EditText, controlId, getCurrentActivity()!!)
-                        }
-                        result = true
-                    }
+        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)
                 }
-        } catch (e: java.lang.Exception) {
-            // Handle the exception
-            result = false
+            }
+            true
+        } catch (e: Exception) {
+            Log.v(TAG, "logTextChangeEvent error: ${e.message}")
+            false
         }
-        return result
     }
 
     /**
@@ -832,7 +992,7 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
 //  }
 
     fun onWindowFocusChanged(hasFocus: Boolean) {
-        if (!reactContext.hasActiveCatalystInstance()) {
+        if (applicationContext == null) {
 //      logEvent("WindowFocus", "Context is not ready. Skipping onWindowFocusChanged.")
             return
         }
@@ -850,7 +1010,7 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
      */
     override fun onHostResume() {
         // Initialize Connect library, and hook into activity lifecycle events to help detect if app is in background
-        if (!reactContext.hasActiveCatalystInstance()) {
+        if (applicationContext == null) {
 //      logEvent("Lifecycle", "onHostResume skipped: ReactContext is not ready")
             return
         }
@@ -863,9 +1023,13 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
 
         if (!isEnabled()) {
             if (getApplication() == null) {
-                init((reactContext.applicationContext as Application))
+                val app = resolveApplication() ?: return
+                init(app)
             }
-            enable()
+            // Qualified to bypass the `enable()` override on this class —
+            // call the native SDK's `Connect.enable()` directly so the
+            // log line "called from JS" doesn't fire on lifecycle wake-ups.
+            Connect.enable()
         }
         onResume(activity, null)
     }
@@ -901,5 +1065,12 @@ class HybridAcousticConnectRN(private val reactContext: ReactApplicationContext)
     companion object {
         const val TAG = "AcousticConnectRN"
         const val DIALOG_CAPTURE_DELAY_MS = 500L // Configurable delay for dialog screenshot capture
+
+        // Class probed at runtime to detect whether the connect-push-fcm
+        // artifact was included in the build. Conservative placeholder — the
+        // actual class name is finalised under CA-137698; if that ticket lands
+        // a different fully-qualified name, update this constant.
+        private const val CONNECT_PUSH_FCM_PROBE_CLASS =
+            "com.acoustic.connect.android.push.fcm.ConnectPushFcm"
     }
 }