@scalebun-release/react-native 2.5.0

package/android/src/main/java/com/scalebun/rn/crash/ScaleBunCrashPackage.kt

@@ -0,0 +1,22 @@
+package com.scalebun.rn.crash
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * ReactPackage for ScaleBunCrashModule.
+ *
+ * Not registered directly by consumers — it is composed by
+ * [com.scalebun.rn.ScaleBunPackage], which is wired via autolinking
+ * (`react-native.config.js`). No manual `MainApplication` registration required.
+ */
+class ScaleBunCrashPackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(ScaleBunCrashModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}

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

@@ -0,0 +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/android/src/main/java/com/scalebun/rn/engage/ScaleBunEngagePackage.kt

@@ -0,0 +1,22 @@
+package com.scalebun.rn.engage
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * ReactPackage for ScaleBunEngageModule (push-token acquisition).
+ *
+ * Retained for manual/standalone registration; the aggregate ScaleBunPackage is
+ * the autolinked entry point and already returns ScaleBunEngageModule, so this package
+ * is NOT autolinked (no double registration).
+ */
+class ScaleBunEngagePackage : ReactPackage {
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(ScaleBunEngageModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+        emptyList()
+}