@scalebun/react-native 1.0.2 → 1.0.3

package/android/src/main/java/com/scalebun/rn/engage/ScaleBunEngageModule.kt

@@ -1,579 +1,579 @@
-package com.scalebun.rn.engage
-
-import android.app.Activity
-import android.app.NotificationManager
-import android.content.Context
-import android.content.Intent
-import android.hardware.Sensor
-import android.hardware.SensorEvent
-import android.hardware.SensorEventListener
-import android.hardware.SensorManager
-import android.os.Build
-import android.view.View
-import android.view.WindowInsets
-import com.facebook.react.bridge.ActivityEventListener
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import org.json.JSONObject
-import kotlin.math.max
-import kotlin.math.sqrt
-
-/**
- * React Native bridge for Engage push-token acquisition (Android / FCM).
- *
- * The genuinely-native piece of the Engage foundation (D4): obtains the FCM
- * registration token and surfaces token rotations to JS, which uploads them via
- * the JS transport layer (`registerDeviceToken`) — the SDK does NOT open a second
- * native HTTP stack.
- *
- * Methods:
- *   getPushToken()  — resolves { token, platform:'android' } or null (fail-soft)
- *
- * Events (DeviceEventManagerModule → JS NativeEventEmitter):
- *   ScaleBunEngageTokenRefresh  — { token, platform:'android' } on FCM rotation
- *
- * Firebase is accessed REFLECTIVELY so this module COMPILES and runs even when the
- * host app has no Firebase dependency: every Firebase call is guarded and degrades
- * to a logged skip (never crashes). When `firebase-messaging` IS present, the token
- * + rotation listener resolve for real.
- *
- * `platform` is always reported as 'android' (routing source of truth, D5).
- */
-class ScaleBunEngageModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
-
-    init {
-        // Surface notification taps that relaunch the host activity (foreground/warm).
-        reactContext.addActivityEventListener(this)
-    }
-
-    override fun getName(): String = "ScaleBunEngage"
-
-    /**
-     * Resolve the host window's current safe-area insets in React Native layout units.
-     *
-     * Uses platform APIs only: typed system-bar/cutout insets on API 30+, and the
-     * stable/current system insets plus display cutout on API 24-29. A missing or
-     * detached Activity resolves null so JS can keep its older-binary fallback.
-     */
-    @ReactMethod
-    fun getWindowInsets(promise: Promise) {
-        resolveWindowInsets(false, promise)
-    }
-
-    /** Insets still unconsumed by the Activity content view (for root JS overlays). */
-    @ReactMethod
-    fun getWindowInsetsRelativeToContent(promise: Promise) {
-        resolveWindowInsets(true, promise)
-    }
-
-    private fun resolveWindowInsets(relativeToContent: Boolean, promise: Promise) {
-        val activity = reactApplicationContext.currentActivity
-        if (activity == null) {
-            promise.resolve(null)
-            return
-        }
-
-        try {
-            activity.runOnUiThread {
-                val decorView = activity.window?.decorView
-                if (decorView == null) {
-                    promise.resolve(null)
-                    return@runOnUiThread
-                }
-
-                val posted = decorView.post {
-                    try {
-                        val rootInsets = decorView.rootWindowInsets
-                        if (rootInsets == null) {
-                            promise.resolve(null)
-                            return@post
-                        }
-                        val rawEdges = resolveWindowInsetEdges(rootInsets)
-                        val edges = if (relativeToContent) {
-                            resolveRemainingContentInsets(activity, decorView, rawEdges)
-                        } else {
-                            rawEdges
-                        }
-                        val density = decorView.resources.displayMetrics.density
-                            .takeIf { it > 0f } ?: 1f
-                        promise.resolve(Arguments.createMap().apply {
-                            putDouble("top", edges.top / density.toDouble())
-                            putDouble("right", edges.right / density.toDouble())
-                            putDouble("bottom", edges.bottom / density.toDouble())
-                            putDouble("left", edges.left / density.toDouble())
-                        })
-                    } catch (_: Throwable) {
-                        promise.resolve(null)
-                    }
-                }
-                if (!posted) promise.resolve(null)
-            }
-        } catch (_: Throwable) {
-            promise.resolve(null)
-        }
-    }
-
-    private fun resolveRemainingContentInsets(
-        activity: Activity,
-        decorView: View,
-        raw: WindowInsetEdges,
-    ): WindowInsetEdges {
-        val content = activity.findViewById<View>(android.R.id.content) ?: return raw
-        if (decorView.width <= 0 || decorView.height <= 0 || content.width <= 0 || content.height <= 0) {
-            return raw
-        }
-
-        val decorLocation = IntArray(2)
-        val contentLocation = IntArray(2)
-        decorView.getLocationInWindow(decorLocation)
-        content.getLocationInWindow(contentLocation)
-        val safeLeft = decorLocation[0] + raw.left
-        val safeTop = decorLocation[1] + raw.top
-        val safeRight = decorLocation[0] + decorView.width - raw.right
-        val safeBottom = decorLocation[1] + decorView.height - raw.bottom
-        val contentRight = contentLocation[0] + content.width
-        val contentBottom = contentLocation[1] + content.height
-        return WindowInsetEdges(
-            top = max(0, safeTop - contentLocation[1]),
-            right = max(0, contentRight - safeRight),
-            bottom = max(0, contentBottom - safeBottom),
-            left = max(0, safeLeft - contentLocation[0]),
-        )
-    }
-
-    private data class WindowInsetEdges(
-        val top: Int,
-        val right: Int,
-        val bottom: Int,
-        val left: Int,
-    )
-
-    @Suppress("DEPRECATION")
-    private fun resolveWindowInsetEdges(insets: WindowInsets): WindowInsetEdges {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-            val edges = insets.getInsets(
-                WindowInsets.Type.systemBars() or WindowInsets.Type.displayCutout(),
-            )
-            return WindowInsetEdges(edges.top, edges.right, edges.bottom, edges.left)
-        }
-
-        var top = max(insets.systemWindowInsetTop, insets.stableInsetTop)
-        var right = max(insets.systemWindowInsetRight, insets.stableInsetRight)
-        var bottom = max(insets.systemWindowInsetBottom, insets.stableInsetBottom)
-        var left = max(insets.systemWindowInsetLeft, insets.stableInsetLeft)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-            insets.displayCutout?.let { cutout ->
-                top = max(top, cutout.safeInsetTop)
-                right = max(right, cutout.safeInsetRight)
-                bottom = max(bottom, cutout.safeInsetBottom)
-                left = max(left, cutout.safeInsetLeft)
-            }
-        }
-        return WindowInsetEdges(top, right, bottom, left)
-    }
-
-    /** RCTEventEmitter plumbing required by NativeEventEmitter on the JS side. */
-    @ReactMethod
-    fun addListener(eventName: String) {
-        // Keep: required so RN's NativeEventEmitter does not warn. No-op.
-    }
-
-    @ReactMethod
-    fun removeListeners(count: Int) {
-        // Keep: required so RN's NativeEventEmitter does not warn. No-op.
-    }
-
-    // ─── Shake detection (Engage `shake_device` trigger) ────────────────────
-    // SensorManager accelerometer; emits `ScaleBunEngageShake` when total acceleration
-    // magnitude (gravity-removed, in g) crosses the threshold, with a cooldown.
-    // Fail-soft: no-op when no accelerometer is present.
-    private var sensorManager: SensorManager? = null
-    private var accelerometer: Sensor? = null
-    private var lastShakeTs: Long = 0
-
-    private val shakeListener = object : SensorEventListener {
-        override fun onSensorChanged(event: SensorEvent) {
-            if (event.sensor.type != Sensor.TYPE_ACCELEROMETER) return
-            val gx = event.values[0] / SensorManager.GRAVITY_EARTH
-            val gy = event.values[1] / SensorManager.GRAVITY_EARTH
-            val gz = event.values[2] / SensorManager.GRAVITY_EARTH
-            val magnitude = sqrt(gx * gx + gy * gy + gz * gz)
-            if (magnitude >= SHAKE_THRESHOLD_G) {
-                val now = System.currentTimeMillis()
-                if (now - lastShakeTs < SHAKE_COOLDOWN_MS) return
-                lastShakeTs = now
-                emitShake()
-            }
-        }
-
-        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) { /* no-op */ }
-    }
-
-    @ReactMethod
-    fun startShakeDetection(promise: Promise) {
-        try {
-            if (sensorManager == null) {
-                sensorManager = reactApplicationContext
-                    .getSystemService(Context.SENSOR_SERVICE) as? SensorManager
-                accelerometer = sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-            }
-            val sm = sensorManager
-            val sensor = accelerometer
-            if (sm == null || sensor == null) {
-                promise.resolve(false) // fail-soft: no accelerometer
-                return
-            }
-            sm.registerListener(shakeListener, sensor, SensorManager.SENSOR_DELAY_GAME)
-            promise.resolve(true)
-        } catch (e: Throwable) {
-            promise.resolve(false)
-        }
-    }
-
-    @ReactMethod
-    fun stopShakeDetection(promise: Promise) {
-        try {
-            sensorManager?.unregisterListener(shakeListener)
-            promise.resolve(true)
-        } catch (e: Throwable) {
-            promise.resolve(false)
-        }
-    }
-
-    private fun emitShake() {
-        val map = Arguments.createMap()
-        map.putString("platform", "android")
-        reactApplicationContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit("ScaleBunEngageShake", map)
-    }
-
-    // ─── In-app review (rating funnel D5) ───────────────────────────────────
-    // Play In-App Review via Play Core `ReviewManager`, accessed REFLECTIVELY so this
-    // module compiles/runs even when the host app lacks the `play:review` dependency.
-    // Resolves true once the review flow launches/resolves; false when unavailable
-    // (no activity, Play Core absent, simulator/quota). The OS may silently no-op the
-    // sheet — Play's flow still "resolves", so a true result means "flow ran", which
-    // is exactly the funnel's `store_redirect_clicked` semantics (CONTRACT §1.1).
-    @ReactMethod
-    fun requestReview(promise: Promise) {
-        val resolved = java.util.concurrent.atomic.AtomicBoolean(false)
-        fun resolveOnce(value: Boolean) {
-            if (resolved.compareAndSet(false, true)) promise.resolve(value)
-        }
-        try {
-            val activity = reactApplicationContext.currentActivity
-            if (activity == null) {
-                resolveOnce(false)
-                return
-            }
-            val factoryClass = Class.forName("com.google.android.play.core.review.ReviewManagerFactory")
-            val manager = factoryClass
-                .getMethod("create", Context::class.java)
-                .invoke(null, reactApplicationContext)
-            if (manager == null) {
-                resolveOnce(false)
-                return
-            }
-            val requestFlowTask = manager.javaClass.getMethod("requestReviewFlow").invoke(manager)
-            if (requestFlowTask == null) {
-                resolveOnce(false)
-                return
-            }
-            attachTaskResult(requestFlowTask) { successful, reviewInfo ->
-                if (!successful || reviewInfo == null) {
-                    resolveOnce(false)
-                    return@attachTaskResult
-                }
-                try {
-                    val reviewInfoClass = Class.forName("com.google.android.play.core.review.ReviewInfo")
-                    val launchTask = manager.javaClass
-                        .getMethod("launchReviewFlow", android.app.Activity::class.java, reviewInfoClass)
-                        .invoke(manager, activity, reviewInfo)
-                    if (launchTask == null) {
-                        resolveOnce(false)
-                        return@attachTaskResult
-                    }
-                    attachTaskResult(launchTask) { launchOk, _ -> resolveOnce(launchOk) }
-                } catch (e: Throwable) {
-                    resolveOnce(false)
-                }
-            }
-        } catch (e: Throwable) {
-            // Play Core review dependency absent or any reflection failure → fail-soft.
-            resolveOnce(false)
-        }
-    }
-
-    /**
-     * Attach a completion callback to a Play Services `Task` via a dynamic proxy
-     * (`OnCompleteListener`), surfacing (isSuccessful, getResult) without a
-     * compile-time dependency. Generic over the result type (vs `attachTaskCompletion`,
-     * which is String-specific for the FCM token).
-     */
-    private fun attachTaskResult(task: Any, onDone: (Boolean, Any?) -> Unit) {
-        try {
-            val listenerClass = Class.forName("com.google.android.gms.tasks.OnCompleteListener")
-            val proxy = java.lang.reflect.Proxy.newProxyInstance(
-                listenerClass.classLoader,
-                arrayOf(listenerClass)
-            ) { _, method, args ->
-                if (method.name == "onComplete" && args != null && args.isNotEmpty()) {
-                    val completedTask = args[0]
-                    val successful = runCatching {
-                        completedTask.javaClass.getMethod("isSuccessful").invoke(completedTask) as? Boolean ?: false
-                    }.getOrNull() ?: false
-                    val result = runCatching {
-                        if (successful) completedTask.javaClass.getMethod("getResult").invoke(completedTask) else null
-                    }.getOrNull()
-                    onDone(successful, result)
-                }
-                null
-            }
-            task.javaClass
-                .getMethod("addOnCompleteListener", listenerClass)
-                .invoke(task, proxy)
-        } catch (e: Throwable) {
-            onDone(false, null)
-        }
-    }
-
-    @ReactMethod
-    fun getPushToken(promise: Promise) {
-        try {
-            val instance = firebaseMessagingInstance()
-            if (instance == null) {
-                // Fail-soft: host app has no Firebase / FCM dependency.
-                promise.resolve(null)
-                return
-            }
-
-            // FirebaseMessaging.getToken() returns a Task<String>; resolve via
-            // reflection-friendly listeners so we never compile against the type.
-            val tokenTask = instance.javaClass.getMethod("getToken").invoke(instance)
-            if (tokenTask == null) {
-                promise.resolve(null)
-                return
-            }
-
-            // Task#addOnCompleteListener(OnCompleteListener) — wire a dynamic proxy.
-            attachTaskCompletion(tokenTask) { token ->
-                if (token.isNullOrEmpty()) {
-                    promise.resolve(null)
-                } else {
-                    promise.resolve(tokenMap(token))
-                }
-            }
-            // Begin listening for rotations once we have an initial token request.
-            attachTokenRefreshListener()
-        } catch (e: Throwable) {
-            // Any reflection / runtime failure → fail-soft skip, never crash.
-            promise.resolve(null)
-        }
-    }
-
-    // ─── Internal: Firebase reflection (fail-soft) ──────────────────────────
-
-    private fun firebaseMessagingInstance(): Any? {
-        return try {
-            val clazz = Class.forName("com.google.firebase.messaging.FirebaseMessaging")
-            clazz.getMethod("getInstance").invoke(null)
-        } catch (e: Throwable) {
-            null
-        }
-    }
-
-    /**
-     * Attach a completion callback to a Google Play Services `Task` via a dynamic
-     * proxy implementing `OnCompleteListener`, avoiding a compile-time dependency.
-     */
-    private fun attachTaskCompletion(task: Any, onToken: (String?) -> Unit) {
-        try {
-            val listenerClass = Class.forName("com.google.android.gms.tasks.OnCompleteListener")
-            val proxy = java.lang.reflect.Proxy.newProxyInstance(
-                listenerClass.classLoader,
-                arrayOf(listenerClass)
-            ) { _, method, args ->
-                if (method.name == "onComplete" && args != null && args.isNotEmpty()) {
-                    val completedTask = args[0]
-                    val token = runCatching {
-                        val successful = completedTask.javaClass.getMethod("isSuccessful")
-                            .invoke(completedTask) as? Boolean ?: false
-                        if (successful) {
-                            completedTask.javaClass.getMethod("getResult").invoke(completedTask) as? String
-                        } else {
-                            null
-                        }
-                    }.getOrNull()
-                    onToken(token)
-                }
-                null
-            }
-            task.javaClass
-                .getMethod("addOnCompleteListener", listenerClass)
-                .invoke(task, proxy)
-        } catch (e: Throwable) {
-            onToken(null)
-        }
-    }
-
-    /**
-     * Token-refresh path: FCM delivers rotations via a service callback
-     * (`FirebaseMessagingService.onNewToken`). The host app forwards those to JS by
-     * emitting `ScaleBunEngageTokenRefresh`. This method exposes the emit hook so a
-     * host-app service (or a future bundled service) can push the new token here;
-     * absent that, the next `getPushToken()` call re-fetches the live token.
-     */
-    private fun attachTokenRefreshListener() {
-        // No standing listener registered here to avoid leaking across reloads;
-        // rotations are surfaced via emitTokenRefresh() below (host-app callback).
-    }
-
-    /** Emit a rotated token to JS (called by the host FCM service callback). */
-    fun emitTokenRefresh(token: String) {
-        if (token.isEmpty()) return
-        reactApplicationContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit("ScaleBunEngageTokenRefresh", tokenMap(token))
-    }
-
-    private fun tokenMap(token: String): WritableMap {
-        val map = Arguments.createMap()
-        map.putString("token", token)
-        map.putString("platform", "android")
-        return map
-    }
-
-    // ─── Native notification display (native-first, NO Notifee) ─────────────
-    // Channel creation + foreground display via framework APIs only
-    // (ScaleBunNotificationPresenter). The JS adapter drives these through the bridge.
-
-    /** Create the notification channel natively (API 26+). Idempotent, fail-soft. */
-    @ReactMethod
-    fun ensureNotificationChannel(
-        channelId: String,
-        channelName: String,
-        importance: Int,
-        description: String?,
-        promise: Promise,
-    ) {
-        try {
-            val imp = if (importance in 0..5) importance else NotificationManager.IMPORTANCE_HIGH
-            ScaleBunNotificationPresenter.ensureChannel(
-                reactApplicationContext, channelId, channelName, imp, description,
-            )
-            promise.resolve(true)
-        } catch (e: Throwable) {
-            promise.resolve(false)
-        }
-    }
-
-    /**
-     * Show a notification natively (used for foreground display, where the OS
-     * suppresses the FCM tray notification). `data` is serialized to JSON and rides
-     * on the tap intent for deep-link routing. Fail-soft.
-     */
-    @ReactMethod
-    fun showForegroundNotification(params: ReadableMap, promise: Promise) {
-        try {
-            val title = if (params.hasKey("title")) params.getString("title") else null
-            val body = if (params.hasKey("body")) params.getString("body") else null
-            val channelId = if (params.hasKey("channelId")) params.getString("channelId") else null
-            val dataJson = if (params.hasKey("data")) readableMapToJson(params.getMap("data")) else null
-            val notificationId = if (params.hasKey("notificationId")) {
-                params.getInt("notificationId")
-            } else {
-                (System.currentTimeMillis() and 0x7fffffff).toInt()
-            }
-            ScaleBunNotificationPresenter.show(
-                reactApplicationContext,
-                channelId ?: "scalebun_default",
-                title,
-                body,
-                dataJson,
-                notificationId,
-            )
-            promise.resolve(true)
-        } catch (e: Throwable) {
-            promise.resolve(false)
-        }
-    }
-
-    /**
-     * Read (once) any ScaleBunB notification extras on the current activity's launch intent
-     * — the cold-start "app opened from a tapped notification" path. Returns
-     * { data } or null. Consuming clears the flag so it does not re-fire on reload.
-     */
-    @ReactMethod
-    fun consumeInitialNotification(promise: Promise) {
-        try {
-            val activity = reactApplicationContext.currentActivity
-            val intent = activity?.intent
-            if (intent == null || !intent.getBooleanExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG, false)) {
-                promise.resolve(null)
-                return
-            }
-            val dataJson = intent.getStringExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
-            // Clear so a JS reload / re-query does not replay the same open.
-            intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG)
-            intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
-            promise.resolve(openedPayload(dataJson))
-        } catch (e: Throwable) {
-            promise.resolve(null)
-        }
-    }
-
-    // ─── ActivityEventListener: warm/foreground notification taps ───────────
-
-    override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
-        // no-op
-    }
-
-    override fun onNewIntent(intent: Intent) {
-        if (!intent.getBooleanExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG, false)) return
-        val dataJson = intent.getStringExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
-        intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG)
-        intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
-        reactApplicationContext
-            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-            .emit("ScaleBunEngageNotificationOpened", openedPayload(dataJson))
-    }
-
-    private fun openedPayload(dataJson: String?): WritableMap {
-        val map = Arguments.createMap()
-        val data = Arguments.createMap()
-        if (!dataJson.isNullOrEmpty()) {
-            runCatching {
-                val obj = JSONObject(dataJson)
-                obj.keys().forEach { key -> data.putString(key, obj.optString(key)) }
-            }
-        }
-        map.putMap("data", data)
-        return map
-    }
-
-    private fun readableMapToJson(map: ReadableMap?): String? {
-        if (map == null) return null
-        return runCatching {
-            val obj = JSONObject()
-            val it = map.keySetIterator()
-            while (it.hasNextKey()) {
-                val key = it.nextKey()
-                obj.put(key, map.getString(key) ?: "")
-            }
-            obj.toString()
-        }.getOrNull()
-    }
-
-    companion object {
-        private const val SHAKE_THRESHOLD_G = 2.3f   // total |a| in g (gravity-removed)
-        private const val SHAKE_COOLDOWN_MS = 1500L
-    }
-}
+package com.scalebun.rn.engage
+
+import android.app.Activity
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Build
+import android.view.View
+import android.view.WindowInsets
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import org.json.JSONObject
+import kotlin.math.max
+import kotlin.math.sqrt
+
+/**
+ * React Native bridge for Engage push-token acquisition (Android / FCM).
+ *
+ * The genuinely-native piece of the Engage foundation (D4): obtains the FCM
+ * registration token and surfaces token rotations to JS, which uploads them via
+ * the JS transport layer (`registerDeviceToken`) — the SDK does NOT open a second
+ * native HTTP stack.
+ *
+ * Methods:
+ *   getPushToken()  — resolves { token, platform:'android' } or null (fail-soft)
+ *
+ * Events (DeviceEventManagerModule → JS NativeEventEmitter):
+ *   ScaleBunEngageTokenRefresh  — { token, platform:'android' } on FCM rotation
+ *
+ * Firebase is accessed REFLECTIVELY so this module COMPILES and runs even when the
+ * host app has no Firebase dependency: every Firebase call is guarded and degrades
+ * to a logged skip (never crashes). When `firebase-messaging` IS present, the token
+ * + rotation listener resolve for real.
+ *
+ * `platform` is always reported as 'android' (routing source of truth, D5).
+ */
+class ScaleBunEngageModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+    init {
+        // Surface notification taps that relaunch the host activity (foreground/warm).
+        reactContext.addActivityEventListener(this)
+    }
+
+    override fun getName(): String = "ScaleBunEngage"
+
+    /**
+     * Resolve the host window's current safe-area insets in React Native layout units.
+     *
+     * Uses platform APIs only: typed system-bar/cutout insets on API 30+, and the
+     * stable/current system insets plus display cutout on API 24-29. A missing or
+     * detached Activity resolves null so JS can keep its older-binary fallback.
+     */
+    @ReactMethod
+    fun getWindowInsets(promise: Promise) {
+        resolveWindowInsets(false, promise)
+    }
+
+    /** Insets still unconsumed by the Activity content view (for root JS overlays). */
+    @ReactMethod
+    fun getWindowInsetsRelativeToContent(promise: Promise) {
+        resolveWindowInsets(true, promise)
+    }
+
+    private fun resolveWindowInsets(relativeToContent: Boolean, promise: Promise) {
+        val activity = reactApplicationContext.currentActivity
+        if (activity == null) {
+            promise.resolve(null)
+            return
+        }
+
+        try {
+            activity.runOnUiThread {
+                val decorView = activity.window?.decorView
+                if (decorView == null) {
+                    promise.resolve(null)
+                    return@runOnUiThread
+                }
+
+                val posted = decorView.post {
+                    try {
+                        val rootInsets = decorView.rootWindowInsets
+                        if (rootInsets == null) {
+                            promise.resolve(null)
+                            return@post
+                        }
+                        val rawEdges = resolveWindowInsetEdges(rootInsets)
+                        val edges = if (relativeToContent) {
+                            resolveRemainingContentInsets(activity, decorView, rawEdges)
+                        } else {
+                            rawEdges
+                        }
+                        val density = decorView.resources.displayMetrics.density
+                            .takeIf { it > 0f } ?: 1f
+                        promise.resolve(Arguments.createMap().apply {
+                            putDouble("top", edges.top / density.toDouble())
+                            putDouble("right", edges.right / density.toDouble())
+                            putDouble("bottom", edges.bottom / density.toDouble())
+                            putDouble("left", edges.left / density.toDouble())
+                        })
+                    } catch (_: Throwable) {
+                        promise.resolve(null)
+                    }
+                }
+                if (!posted) promise.resolve(null)
+            }
+        } catch (_: Throwable) {
+            promise.resolve(null)
+        }
+    }
+
+    private fun resolveRemainingContentInsets(
+        activity: Activity,
+        decorView: View,
+        raw: WindowInsetEdges,
+    ): WindowInsetEdges {
+        val content = activity.findViewById<View>(android.R.id.content) ?: return raw
+        if (decorView.width <= 0 || decorView.height <= 0 || content.width <= 0 || content.height <= 0) {
+            return raw
+        }
+
+        val decorLocation = IntArray(2)
+        val contentLocation = IntArray(2)
+        decorView.getLocationInWindow(decorLocation)
+        content.getLocationInWindow(contentLocation)
+        val safeLeft = decorLocation[0] + raw.left
+        val safeTop = decorLocation[1] + raw.top
+        val safeRight = decorLocation[0] + decorView.width - raw.right
+        val safeBottom = decorLocation[1] + decorView.height - raw.bottom
+        val contentRight = contentLocation[0] + content.width
+        val contentBottom = contentLocation[1] + content.height
+        return WindowInsetEdges(
+            top = max(0, safeTop - contentLocation[1]),
+            right = max(0, contentRight - safeRight),
+            bottom = max(0, contentBottom - safeBottom),
+            left = max(0, safeLeft - contentLocation[0]),
+        )
+    }
+
+    private data class WindowInsetEdges(
+        val top: Int,
+        val right: Int,
+        val bottom: Int,
+        val left: Int,
+    )
+
+    @Suppress("DEPRECATION")
+    private fun resolveWindowInsetEdges(insets: WindowInsets): WindowInsetEdges {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            val edges = insets.getInsets(
+                WindowInsets.Type.systemBars() or WindowInsets.Type.displayCutout(),
+            )
+            return WindowInsetEdges(edges.top, edges.right, edges.bottom, edges.left)
+        }
+
+        var top = max(insets.systemWindowInsetTop, insets.stableInsetTop)
+        var right = max(insets.systemWindowInsetRight, insets.stableInsetRight)
+        var bottom = max(insets.systemWindowInsetBottom, insets.stableInsetBottom)
+        var left = max(insets.systemWindowInsetLeft, insets.stableInsetLeft)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            insets.displayCutout?.let { cutout ->
+                top = max(top, cutout.safeInsetTop)
+                right = max(right, cutout.safeInsetRight)
+                bottom = max(bottom, cutout.safeInsetBottom)
+                left = max(left, cutout.safeInsetLeft)
+            }
+        }
+        return WindowInsetEdges(top, right, bottom, left)
+    }
+
+    /** RCTEventEmitter plumbing required by NativeEventEmitter on the JS side. */
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Keep: required so RN's NativeEventEmitter does not warn. No-op.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Keep: required so RN's NativeEventEmitter does not warn. No-op.
+    }
+
+    // ─── Shake detection (Engage `shake_device` trigger) ────────────────────
+    // SensorManager accelerometer; emits `ScaleBunEngageShake` when total acceleration
+    // magnitude (gravity-removed, in g) crosses the threshold, with a cooldown.
+    // Fail-soft: no-op when no accelerometer is present.
+    private var sensorManager: SensorManager? = null
+    private var accelerometer: Sensor? = null
+    private var lastShakeTs: Long = 0
+
+    private val shakeListener = object : SensorEventListener {
+        override fun onSensorChanged(event: SensorEvent) {
+            if (event.sensor.type != Sensor.TYPE_ACCELEROMETER) return
+            val gx = event.values[0] / SensorManager.GRAVITY_EARTH
+            val gy = event.values[1] / SensorManager.GRAVITY_EARTH
+            val gz = event.values[2] / SensorManager.GRAVITY_EARTH
+            val magnitude = sqrt(gx * gx + gy * gy + gz * gz)
+            if (magnitude >= SHAKE_THRESHOLD_G) {
+                val now = System.currentTimeMillis()
+                if (now - lastShakeTs < SHAKE_COOLDOWN_MS) return
+                lastShakeTs = now
+                emitShake()
+            }
+        }
+
+        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) { /* no-op */ }
+    }
+
+    @ReactMethod
+    fun startShakeDetection(promise: Promise) {
+        try {
+            if (sensorManager == null) {
+                sensorManager = reactApplicationContext
+                    .getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+                accelerometer = sensorManager?.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
+            }
+            val sm = sensorManager
+            val sensor = accelerometer
+            if (sm == null || sensor == null) {
+                promise.resolve(false) // fail-soft: no accelerometer
+                return
+            }
+            sm.registerListener(shakeListener, sensor, SensorManager.SENSOR_DELAY_GAME)
+            promise.resolve(true)
+        } catch (e: Throwable) {
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun stopShakeDetection(promise: Promise) {
+        try {
+            sensorManager?.unregisterListener(shakeListener)
+            promise.resolve(true)
+        } catch (e: Throwable) {
+            promise.resolve(false)
+        }
+    }
+
+    private fun emitShake() {
+        val map = Arguments.createMap()
+        map.putString("platform", "android")
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("ScaleBunEngageShake", map)
+    }
+
+    // ─── In-app review (rating funnel D5) ───────────────────────────────────
+    // Play In-App Review via Play Core `ReviewManager`, accessed REFLECTIVELY so this
+    // module compiles/runs even when the host app lacks the `play:review` dependency.
+    // Resolves true once the review flow launches/resolves; false when unavailable
+    // (no activity, Play Core absent, simulator/quota). The OS may silently no-op the
+    // sheet — Play's flow still "resolves", so a true result means "flow ran", which
+    // is exactly the funnel's `store_redirect_clicked` semantics (CONTRACT §1.1).
+    @ReactMethod
+    fun requestReview(promise: Promise) {
+        val resolved = java.util.concurrent.atomic.AtomicBoolean(false)
+        fun resolveOnce(value: Boolean) {
+            if (resolved.compareAndSet(false, true)) promise.resolve(value)
+        }
+        try {
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                resolveOnce(false)
+                return
+            }
+            val factoryClass = Class.forName("com.google.android.play.core.review.ReviewManagerFactory")
+            val manager = factoryClass
+                .getMethod("create", Context::class.java)
+                .invoke(null, reactApplicationContext)
+            if (manager == null) {
+                resolveOnce(false)
+                return
+            }
+            val requestFlowTask = manager.javaClass.getMethod("requestReviewFlow").invoke(manager)
+            if (requestFlowTask == null) {
+                resolveOnce(false)
+                return
+            }
+            attachTaskResult(requestFlowTask) { successful, reviewInfo ->
+                if (!successful || reviewInfo == null) {
+                    resolveOnce(false)
+                    return@attachTaskResult
+                }
+                try {
+                    val reviewInfoClass = Class.forName("com.google.android.play.core.review.ReviewInfo")
+                    val launchTask = manager.javaClass
+                        .getMethod("launchReviewFlow", android.app.Activity::class.java, reviewInfoClass)
+                        .invoke(manager, activity, reviewInfo)
+                    if (launchTask == null) {
+                        resolveOnce(false)
+                        return@attachTaskResult
+                    }
+                    attachTaskResult(launchTask) { launchOk, _ -> resolveOnce(launchOk) }
+                } catch (e: Throwable) {
+                    resolveOnce(false)
+                }
+            }
+        } catch (e: Throwable) {
+            // Play Core review dependency absent or any reflection failure → fail-soft.
+            resolveOnce(false)
+        }
+    }
+
+    /**
+     * Attach a completion callback to a Play Services `Task` via a dynamic proxy
+     * (`OnCompleteListener`), surfacing (isSuccessful, getResult) without a
+     * compile-time dependency. Generic over the result type (vs `attachTaskCompletion`,
+     * which is String-specific for the FCM token).
+     */
+    private fun attachTaskResult(task: Any, onDone: (Boolean, Any?) -> Unit) {
+        try {
+            val listenerClass = Class.forName("com.google.android.gms.tasks.OnCompleteListener")
+            val proxy = java.lang.reflect.Proxy.newProxyInstance(
+                listenerClass.classLoader,
+                arrayOf(listenerClass)
+            ) { _, method, args ->
+                if (method.name == "onComplete" && args != null && args.isNotEmpty()) {
+                    val completedTask = args[0]
+                    val successful = runCatching {
+                        completedTask.javaClass.getMethod("isSuccessful").invoke(completedTask) as? Boolean ?: false
+                    }.getOrNull() ?: false
+                    val result = runCatching {
+                        if (successful) completedTask.javaClass.getMethod("getResult").invoke(completedTask) else null
+                    }.getOrNull()
+                    onDone(successful, result)
+                }
+                null
+            }
+            task.javaClass
+                .getMethod("addOnCompleteListener", listenerClass)
+                .invoke(task, proxy)
+        } catch (e: Throwable) {
+            onDone(false, null)
+        }
+    }
+
+    @ReactMethod
+    fun getPushToken(promise: Promise) {
+        try {
+            val instance = firebaseMessagingInstance()
+            if (instance == null) {
+                // Fail-soft: host app has no Firebase / FCM dependency.
+                promise.resolve(null)
+                return
+            }
+
+            // FirebaseMessaging.getToken() returns a Task<String>; resolve via
+            // reflection-friendly listeners so we never compile against the type.
+            val tokenTask = instance.javaClass.getMethod("getToken").invoke(instance)
+            if (tokenTask == null) {
+                promise.resolve(null)
+                return
+            }
+
+            // Task#addOnCompleteListener(OnCompleteListener) — wire a dynamic proxy.
+            attachTaskCompletion(tokenTask) { token ->
+                if (token.isNullOrEmpty()) {
+                    promise.resolve(null)
+                } else {
+                    promise.resolve(tokenMap(token))
+                }
+            }
+            // Begin listening for rotations once we have an initial token request.
+            attachTokenRefreshListener()
+        } catch (e: Throwable) {
+            // Any reflection / runtime failure → fail-soft skip, never crash.
+            promise.resolve(null)
+        }
+    }
+
+    // ─── Internal: Firebase reflection (fail-soft) ──────────────────────────
+
+    private fun firebaseMessagingInstance(): Any? {
+        return try {
+            val clazz = Class.forName("com.google.firebase.messaging.FirebaseMessaging")
+            clazz.getMethod("getInstance").invoke(null)
+        } catch (e: Throwable) {
+            null
+        }
+    }
+
+    /**
+     * Attach a completion callback to a Google Play Services `Task` via a dynamic
+     * proxy implementing `OnCompleteListener`, avoiding a compile-time dependency.
+     */
+    private fun attachTaskCompletion(task: Any, onToken: (String?) -> Unit) {
+        try {
+            val listenerClass = Class.forName("com.google.android.gms.tasks.OnCompleteListener")
+            val proxy = java.lang.reflect.Proxy.newProxyInstance(
+                listenerClass.classLoader,
+                arrayOf(listenerClass)
+            ) { _, method, args ->
+                if (method.name == "onComplete" && args != null && args.isNotEmpty()) {
+                    val completedTask = args[0]
+                    val token = runCatching {
+                        val successful = completedTask.javaClass.getMethod("isSuccessful")
+                            .invoke(completedTask) as? Boolean ?: false
+                        if (successful) {
+                            completedTask.javaClass.getMethod("getResult").invoke(completedTask) as? String
+                        } else {
+                            null
+                        }
+                    }.getOrNull()
+                    onToken(token)
+                }
+                null
+            }
+            task.javaClass
+                .getMethod("addOnCompleteListener", listenerClass)
+                .invoke(task, proxy)
+        } catch (e: Throwable) {
+            onToken(null)
+        }
+    }
+
+    /**
+     * Token-refresh path: FCM delivers rotations via a service callback
+     * (`FirebaseMessagingService.onNewToken`). The host app forwards those to JS by
+     * emitting `ScaleBunEngageTokenRefresh`. This method exposes the emit hook so a
+     * host-app service (or a future bundled service) can push the new token here;
+     * absent that, the next `getPushToken()` call re-fetches the live token.
+     */
+    private fun attachTokenRefreshListener() {
+        // No standing listener registered here to avoid leaking across reloads;
+        // rotations are surfaced via emitTokenRefresh() below (host-app callback).
+    }
+
+    /** Emit a rotated token to JS (called by the host FCM service callback). */
+    fun emitTokenRefresh(token: String) {
+        if (token.isEmpty()) return
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("ScaleBunEngageTokenRefresh", tokenMap(token))
+    }
+
+    private fun tokenMap(token: String): WritableMap {
+        val map = Arguments.createMap()
+        map.putString("token", token)
+        map.putString("platform", "android")
+        return map
+    }
+
+    // ─── Native notification display (native-first, NO Notifee) ─────────────
+    // Channel creation + foreground display via framework APIs only
+    // (ScaleBunNotificationPresenter). The JS adapter drives these through the bridge.
+
+    /** Create the notification channel natively (API 26+). Idempotent, fail-soft. */
+    @ReactMethod
+    fun ensureNotificationChannel(
+        channelId: String,
+        channelName: String,
+        importance: Int,
+        description: String?,
+        promise: Promise,
+    ) {
+        try {
+            val imp = if (importance in 0..5) importance else NotificationManager.IMPORTANCE_HIGH
+            ScaleBunNotificationPresenter.ensureChannel(
+                reactApplicationContext, channelId, channelName, imp, description,
+            )
+            promise.resolve(true)
+        } catch (e: Throwable) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Show a notification natively (used for foreground display, where the OS
+     * suppresses the FCM tray notification). `data` is serialized to JSON and rides
+     * on the tap intent for deep-link routing. Fail-soft.
+     */
+    @ReactMethod
+    fun showForegroundNotification(params: ReadableMap, promise: Promise) {
+        try {
+            val title = if (params.hasKey("title")) params.getString("title") else null
+            val body = if (params.hasKey("body")) params.getString("body") else null
+            val channelId = if (params.hasKey("channelId")) params.getString("channelId") else null
+            val dataJson = if (params.hasKey("data")) readableMapToJson(params.getMap("data")) else null
+            val notificationId = if (params.hasKey("notificationId")) {
+                params.getInt("notificationId")
+            } else {
+                (System.currentTimeMillis() and 0x7fffffff).toInt()
+            }
+            ScaleBunNotificationPresenter.show(
+                reactApplicationContext,
+                channelId ?: "scalebun_default",
+                title,
+                body,
+                dataJson,
+                notificationId,
+            )
+            promise.resolve(true)
+        } catch (e: Throwable) {
+            promise.resolve(false)
+        }
+    }
+
+    /**
+     * Read (once) any ScaleBunB notification extras on the current activity's launch intent
+     * — the cold-start "app opened from a tapped notification" path. Returns
+     * { data } or null. Consuming clears the flag so it does not re-fire on reload.
+     */
+    @ReactMethod
+    fun consumeInitialNotification(promise: Promise) {
+        try {
+            val activity = reactApplicationContext.currentActivity
+            val intent = activity?.intent
+            if (intent == null || !intent.getBooleanExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG, false)) {
+                promise.resolve(null)
+                return
+            }
+            val dataJson = intent.getStringExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
+            // Clear so a JS reload / re-query does not replay the same open.
+            intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG)
+            intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
+            promise.resolve(openedPayload(dataJson))
+        } catch (e: Throwable) {
+            promise.resolve(null)
+        }
+    }
+
+    // ─── ActivityEventListener: warm/foreground notification taps ───────────
+
+    override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+        // no-op
+    }
+
+    override fun onNewIntent(intent: Intent) {
+        if (!intent.getBooleanExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG, false)) return
+        val dataJson = intent.getStringExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
+        intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_FLAG)
+        intent.removeExtra(ScaleBunNotificationPresenter.EXTRA_SCALEBUN_DATA)
+        reactApplicationContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("ScaleBunEngageNotificationOpened", openedPayload(dataJson))
+    }
+
+    private fun openedPayload(dataJson: String?): WritableMap {
+        val map = Arguments.createMap()
+        val data = Arguments.createMap()
+        if (!dataJson.isNullOrEmpty()) {
+            runCatching {
+                val obj = JSONObject(dataJson)
+                obj.keys().forEach { key -> data.putString(key, obj.optString(key)) }
+            }
+        }
+        map.putMap("data", data)
+        return map
+    }
+
+    private fun readableMapToJson(map: ReadableMap?): String? {
+        if (map == null) return null
+        return runCatching {
+            val obj = JSONObject()
+            val it = map.keySetIterator()
+            while (it.hasNextKey()) {
+                val key = it.nextKey()
+                obj.put(key, map.getString(key) ?: "")
+            }
+            obj.toString()
+        }.getOrNull()
+    }
+
+    companion object {
+        private const val SHAKE_THRESHOLD_G = 2.3f   // total |a| in g (gravity-removed)
+        private const val SHAKE_COOLDOWN_MS = 1500L
+    }
+}