@hot-updater/react-native 0.27.0 → 0.28.0

package/android/src/main/java/com/hotupdater/HotUpdaterImpl.kt

@@ -15,6 +15,8 @@ class HotUpdaterImpl {
     private val context: Context
     private val bundleStorage: BundleStorageService
     private val preferences: PreferencesService
+    private val recoveryManager: HotUpdaterRecoveryManager
+    private var currentLaunchSelection: LaunchSelection? = null
 
     /**
      * Primary constructor with dependency injection (for testing)
@@ -27,6 +29,7 @@ class HotUpdaterImpl {
         this.context = context.applicationContext
         this.bundleStorage = bundleStorage
         this.preferences = preferences
+        this.recoveryManager = HotUpdaterRecoveryManager(this.context)
     }
 
     /**
@@ -265,7 +268,7 @@ class HotUpdaterImpl {
      * Gets the path to the bundle file
      * @return The path to the bundle file
      */
-    fun getJSBundleFile(): String = bundleStorage.getBundleURL()
+    fun getJSBundleFile(): String = prepareLaunchIfNeeded().bundleUrl
 
     /**
      * Updates the bundle from the specified URL
@@ -299,6 +302,7 @@ class HotUpdaterImpl {
      */
     suspend fun reload(reactContext: Context) {
         try {
+            currentLaunchSelection = null
             withContext(Dispatchers.Main) {
                 performReactReload(reactContext)
             }
@@ -309,6 +313,7 @@ class HotUpdaterImpl {
 
     suspend fun reloadProcess(reactContext: Context) {
         try {
+            currentLaunchSelection = null
             withContext(Dispatchers.Main) {
                 if (!restartApplication(reactContext)) {
                     Log.w(TAG, "Falling back to in-process reload because process restart could not be started")
@@ -330,22 +335,24 @@ class HotUpdaterImpl {
 
     // Use a cold restart in release builds so bundle application does not depend on RN reload timing.
     private fun restartApplication(reactContext: Context): Boolean {
+        val applicationContext = reactContext.applicationContext
         val currentActivity =
             (reactContext as? com.facebook.react.bridge.ReactApplicationContext)?.currentActivity
-        if (currentActivity == null) {
-            Log.w(TAG, "Cannot restart app: current activity unavailable")
-            return false
-        }
 
         return try {
             val restartIntent =
-                Intent(currentActivity, HotUpdaterRestartActivity::class.java).apply {
+                Intent(applicationContext, HotUpdaterRestartActivity::class.java).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                     addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
-                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, currentActivity.packageName)
+                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, applicationContext.packageName)
                     putExtra(HotUpdaterRestartActivity.EXTRA_TARGET_PID, Process.myPid())
                 }
-            val options = ActivityOptions.makeCustomAnimation(currentActivity, 0, 0)
-            currentActivity.startActivity(restartIntent, options.toBundle())
+            if (currentActivity != null) {
+                val options = ActivityOptions.makeCustomAnimation(currentActivity, 0, 0)
+                currentActivity.startActivity(restartIntent, options.toBundle())
+            } else {
+                applicationContext.startActivity(restartIntent)
+            }
 
             Log.i(TAG, "Started restart trampoline to apply update bundle")
             return true
@@ -356,12 +363,11 @@ class HotUpdaterImpl {
     }
 
     /**
-     * Notifies the system that the app has successfully started with the given bundle.
-     * If the bundle matches the staging bundle, it promotes to stable.
-     * @param bundleId The ID of the currently running bundle
+     * Returns the launch report for the current process.
+     * Startup success and rollback are finalized before JS reads it.
      * @return Map containing status and optional crashedBundleId
      */
-    fun notifyAppReady(bundleId: String): Map<String, Any?> = bundleStorage.notifyAppReady(bundleId)
+    fun notifyAppReady(): Map<String, Any?> = bundleStorage.notifyAppReady()
 
     /**
      * Gets the crashed bundle history.
@@ -387,7 +393,27 @@ class HotUpdaterImpl {
         val success = bundleStorage.resetChannel()
         if (success) {
             preferences.setItem(CHANNEL_STORAGE_KEY, null)
+            currentLaunchSelection = null
         }
         return success
     }
+
+    private fun prepareLaunchIfNeeded(): LaunchSelection {
+        currentLaunchSelection?.let { return it }
+
+        val pendingRecovery = recoveryManager.consumePendingCrashRecovery()
+        val selection = bundleStorage.prepareLaunch(pendingRecovery)
+        recoveryManager.startMonitoring(
+            bundleId = selection.launchedBundleId,
+            shouldRollback = selection.shouldRollbackOnCrash,
+            onContentAppeared = { launchedBundleId ->
+                bundleStorage.markLaunchCompleted(launchedBundleId)
+            },
+            onRecoveryRestartRequested = {
+                restartApplication(context)
+            },
+        )
+        currentLaunchSelection = selection
+        return selection
+    }
 }

package/android/src/main/java/com/hotupdater/HotUpdaterRecoveryManager.kt

@@ -0,0 +1,533 @@
+package com.hotupdater
+
+import android.app.AlarmManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Handler
+import android.os.Looper
+import android.os.Process
+import android.os.SystemClock
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.JSExceptionHandler
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactMarker
+import com.facebook.react.bridge.ReactMarkerConstants
+import org.json.JSONObject
+import java.io.File
+import java.lang.reflect.Field
+import kotlin.system.exitProcess
+
+internal class HotUpdaterRecoveryManager(
+    context: Context,
+) {
+    private val appContext = context.applicationContext
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val bundleStoreDir = getBundleStoreDir(appContext)
+    private val crashMarkerFile = File(bundleStoreDir, CRASH_MARKER_FILENAME)
+    private val watchdogStateFile = File(bundleStoreDir, WATCHDOG_STATE_FILENAME)
+
+    private var currentBundleId: String? = null
+    private var shouldRollbackOnCrash = false
+    private var isMonitoring = false
+    private var recoveryRequested = false
+    private var contentAppearedCallback: ((String?) -> Unit)? = null
+    private var recoveryRestartCallback: (() -> Boolean)? = null
+
+    private val stopMonitoringRunnable =
+        Runnable {
+            cancelRecoveryWatchdog()
+            Log.d(TAG, "Stopping crash monitoring for current launch")
+            isMonitoring = false
+            recoveryRequested = false
+            shouldRollbackOnCrash = false
+            currentBundleId = null
+            contentAppearedCallback = null
+            recoveryRestartCallback = null
+            activeManager = null
+            updateNativeLaunchState(null, false)
+        }
+
+    private val installJsExceptionHooksRunnable =
+        object : Runnable {
+            override fun run() {
+                if (!isMonitoring) {
+                    return
+                }
+
+                installJavaScriptExceptionHooks()
+                mainHandler.postDelayed(this, JS_EXCEPTION_HOOK_RETRY_DELAY_MS)
+            }
+        }
+
+    private val contentAppearedListener =
+        ReactMarker.MarkerListener { name, _, _ ->
+            if (name == ReactMarkerConstants.CONTENT_APPEARED) {
+                handleContentAppeared()
+            }
+        }
+
+    fun consumePendingCrashRecovery(): PendingCrashRecovery? {
+        if (!crashMarkerFile.exists()) {
+            return null
+        }
+
+        return try {
+            val recovery = PendingCrashRecovery.fromJson(JSONObject(crashMarkerFile.readText()))
+            Log.d(
+                TAG,
+                "Consumed pending crash marker bundleId=${recovery.launchedBundleId} shouldRollback=${recovery.shouldRollback}",
+            )
+            recovery
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to read crash marker", e)
+            null
+        } finally {
+            crashMarkerFile.delete()
+        }
+    }
+
+    fun startMonitoring(
+        bundleId: String?,
+        shouldRollback: Boolean,
+        onContentAppeared: (String?) -> Unit,
+        onRecoveryRestartRequested: () -> Boolean,
+    ) {
+        crashMarkerFile.parentFile?.mkdirs()
+        contentAppearedCallback = onContentAppeared
+        currentBundleId = bundleId
+        shouldRollbackOnCrash = shouldRollback
+        isMonitoring = true
+        recoveryRequested = false
+        recoveryRestartCallback = onRecoveryRestartRequested
+        activeManager = this
+
+        ensureExceptionHandlerInstalled()
+        ensureNativeSignalHandlerInstalled()
+
+        mainHandler.removeCallbacks(installJsExceptionHooksRunnable)
+        mainHandler.removeCallbacks(stopMonitoringRunnable)
+        ReactMarker.removeListener(contentAppearedListener)
+        ReactMarker.addListener(contentAppearedListener)
+        updateNativeLaunchState(bundleId, shouldRollback)
+        if (shouldRollback) {
+            startRecoveryWatchdog()
+        } else {
+            cancelRecoveryWatchdog()
+        }
+        mainHandler.post(installJsExceptionHooksRunnable)
+
+        Log.d(TAG, "Started crash monitoring bundleId=$bundleId shouldRollback=$shouldRollback")
+    }
+
+    private fun handleContentAppeared() {
+        if (!isMonitoring) {
+            return
+        }
+
+        Log.d(TAG, "First content appeared for bundleId=$currentBundleId")
+        ReactMarker.removeListener(contentAppearedListener)
+        mainHandler.removeCallbacks(installJsExceptionHooksRunnable)
+        mainHandler.removeCallbacks(stopMonitoringRunnable)
+        contentAppearedCallback?.invoke(currentBundleId)
+        shouldRollbackOnCrash = false
+        updateNativeLaunchState(currentBundleId, false)
+        cancelRecoveryWatchdog()
+        mainHandler.postDelayed(stopMonitoringRunnable, MONITORING_GRACE_PERIOD_MS)
+    }
+
+    private fun ensureExceptionHandlerInstalled() {
+        if (exceptionHandlerInstalled) {
+            return
+        }
+
+        previousExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            val manager = activeManager
+            manager?.writeCrashMarker()
+
+            if (manager?.requestAutomaticRecovery() == true) {
+                Process.killProcess(Process.myPid())
+                exitProcess(10)
+            }
+
+            previousExceptionHandler?.uncaughtException(thread, throwable)
+                ?: run {
+                    Process.killProcess(Process.myPid())
+                    exitProcess(10)
+                }
+        }
+        exceptionHandlerInstalled = true
+    }
+
+    private fun writeCrashMarker() {
+        if (!isMonitoring) {
+            return
+        }
+
+        try {
+            val payload =
+                JSONObject().apply {
+                    put("bundleId", currentBundleId ?: JSONObject.NULL)
+                    put("shouldRollback", shouldRollbackOnCrash)
+                }
+            crashMarkerFile.parentFile?.mkdirs()
+            crashMarkerFile.writeText(payload.toString())
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to write crash marker", e)
+        }
+    }
+
+    private fun startRecoveryWatchdog() {
+        try {
+            watchdogStateFile.parentFile?.mkdirs()
+            watchdogStateFile.writeText((System.currentTimeMillis() + MONITORING_GRACE_PERIOD_MS).toString())
+            scheduleRecoveryWatchdogTick(appContext, WATCHDOG_TICK_INTERVAL_MS)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to schedule recovery watchdog", e)
+        }
+    }
+
+    private fun cancelRecoveryWatchdog() {
+        watchdogStateFile.delete()
+        cancelRecoveryWatchdogAlarm(appContext)
+    }
+
+    private fun requestAutomaticRecovery(): Boolean {
+        if (!isMonitoring || !shouldRollbackOnCrash) {
+            return false
+        }
+
+        synchronized(this) {
+            if (recoveryRequested) {
+                return true
+            }
+            recoveryRequested = true
+        }
+
+        val started = recoveryRestartCallback?.invoke() == true
+        if (!started) {
+            synchronized(this) {
+                recoveryRequested = false
+            }
+            Log.w(TAG, "Failed to schedule automatic recovery restart")
+        } else {
+            Log.i(TAG, "Scheduled automatic recovery restart for bundleId=$currentBundleId")
+        }
+        return started
+    }
+
+    private fun handleJavaScriptException(exception: Exception): Boolean {
+        Log.e(TAG, "Caught React startup exception for bundleId=$currentBundleId", exception)
+        writeCrashMarker()
+        return requestAutomaticRecovery()
+    }
+
+    private fun ensureNativeSignalHandlerInstalled() {
+        if (signalHandlerInstalled || !loadNativeLibrary()) {
+            return
+        }
+
+        try {
+            nativeInstallSignalHandler(crashMarkerFile.absolutePath)
+            signalHandlerInstalled = true
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Signal handler not available", e)
+        }
+    }
+
+    private fun updateNativeLaunchState(
+        bundleId: String?,
+        shouldRollback: Boolean,
+    ) {
+        if (!signalHandlerInstalled || !nativeLibraryLoaded) {
+            return
+        }
+
+        try {
+            nativeUpdateLaunchState(bundleId, shouldRollback)
+        } catch (e: UnsatisfiedLinkError) {
+            Log.w(TAG, "Failed to update native launch state", e)
+        }
+    }
+
+    private fun installJavaScriptExceptionHooks() {
+        val application = appContext as? ReactApplication ?: return
+
+        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+            installReactHostExceptionHook(application)
+        } else {
+            installLegacyExceptionHook(application)
+        }
+    }
+
+    private fun installReactHostExceptionHook(application: ReactApplication) {
+        val reactHost = getReactHost(application) ?: return
+        val reactHostDelegate =
+            findField(reactHost.javaClass, "mReactHostDelegate")?.let { field ->
+                field.isAccessible = true
+                field.get(reactHost)
+            }
+                ?: findField(reactHost.javaClass, "reactHostDelegate")?.let { field ->
+                    field.isAccessible = true
+                    field.get(reactHost)
+                }
+                ?: return
+
+        val delegateIdentity = System.identityHashCode(reactHostDelegate)
+        if (patchedReactHostDelegateIds.add(delegateIdentity)) {
+            val exceptionHandlerField = findField(reactHostDelegate.javaClass, "exceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedReactHostDelegateIds.remove(delegateIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            @Suppress("UNCHECKED_CAST")
+            val previousHandler =
+                exceptionHandlerField.get(reactHostDelegate) as? (Exception) -> Unit
+
+            exceptionHandlerField.set(reactHostDelegate) { exception: Exception ->
+                if (activeManager?.handleJavaScriptException(exception) != true) {
+                    previousHandler?.invoke(exception) ?: throw exception
+                }
+            }
+        }
+
+        val reactContext =
+            findMethod(reactHost.javaClass, "getCurrentReactContext")?.invoke(reactHost) as? ReactContext
+        reactContext?.let { patchReactContextExceptionHandler(it) }
+    }
+
+    private fun installLegacyExceptionHook(application: ReactApplication) {
+        val instanceManager = application.reactNativeHost.reactInstanceManager
+        val managerIdentity = System.identityHashCode(instanceManager)
+        if (patchedInstanceManagerIds.add(managerIdentity)) {
+            val exceptionHandlerField = findField(instanceManager.javaClass, "mJSExceptionHandler")
+            if (exceptionHandlerField == null) {
+                patchedInstanceManagerIds.remove(managerIdentity)
+                return
+            }
+
+            exceptionHandlerField.isAccessible = true
+            val previousHandler = exceptionHandlerField.get(instanceManager) as? JSExceptionHandler
+            exceptionHandlerField.set(instanceManager, RecoveryJSExceptionHandler(previousHandler))
+        }
+
+        instanceManager.currentReactContext?.let { reactContext ->
+            patchReactContextExceptionHandler(reactContext)
+            patchCatalystInstanceExceptionHandler(reactContext)
+        }
+    }
+
+    private fun patchReactContextExceptionHandler(reactContext: ReactContext) {
+        val contextIdentity = System.identityHashCode(reactContext)
+        if (!patchedReactContextIds.add(contextIdentity)) {
+            return
+        }
+
+        val previousHandler = reactContext.jsExceptionHandler
+        if (previousHandler is RecoveryJSExceptionHandler) {
+            return
+        }
+
+        reactContext.setJSExceptionHandler(RecoveryJSExceptionHandler(previousHandler))
+    }
+
+    private fun patchCatalystInstanceExceptionHandler(reactContext: ReactContext) {
+        val catalystInstance =
+            try {
+                reactContext.catalystInstance
+            } catch (_: Exception) {
+                null
+            } ?: return
+
+        val catalystIdentity = System.identityHashCode(catalystInstance)
+        if (!patchedCatalystInstanceIds.add(catalystIdentity)) {
+            return
+        }
+
+        val exceptionHandlerField = findField(catalystInstance.javaClass, "mJSExceptionHandler")
+        if (exceptionHandlerField == null) {
+            patchedCatalystInstanceIds.remove(catalystIdentity)
+            return
+        }
+
+        exceptionHandlerField.isAccessible = true
+        val previousHandler = exceptionHandlerField.get(catalystInstance) as? JSExceptionHandler
+        if (previousHandler is RecoveryJSExceptionHandler) {
+            return
+        }
+        exceptionHandlerField.set(catalystInstance, RecoveryJSExceptionHandler(previousHandler))
+    }
+
+    private fun getReactHost(application: ReactApplication): Any? =
+        try {
+            findMethod(application.javaClass, "getReactHost")?.invoke(application)
+        } catch (_: Exception) {
+            null
+        }
+
+    private fun findMethod(
+        clazz: Class<*>,
+        name: String,
+    ) = runCatching { clazz.getMethod(name) }.getOrNull()
+
+    private fun findField(
+        clazz: Class<*>,
+        name: String,
+    ): Field? {
+        var current: Class<*>? = clazz
+        while (true) {
+            val currentClass = current ?: break
+            runCatching { currentClass.getDeclaredField(name) }
+                .getOrNull()
+                ?.let { return it }
+            current = currentClass.superclass
+        }
+        return null
+    }
+
+    private fun loadNativeLibrary(): Boolean {
+        if (nativeLibraryLoadAttempted) {
+            return nativeLibraryLoaded
+        }
+
+        nativeLibraryLoadAttempted = true
+        nativeLibraryLoaded =
+            try {
+                System.loadLibrary("hotupdater_recovery")
+                true
+            } catch (e: UnsatisfiedLinkError) {
+                Log.w(TAG, "Failed to load recovery native library", e)
+                false
+            }
+        return nativeLibraryLoaded
+    }
+
+    private external fun nativeInstallSignalHandler(crashMarkerPath: String)
+
+    private external fun nativeUpdateLaunchState(
+        bundleId: String?,
+        shouldRollback: Boolean,
+    )
+
+    private class RecoveryJSExceptionHandler(
+        private val previousHandler: JSExceptionHandler?,
+    ) : JSExceptionHandler {
+        override fun handleException(e: Exception) {
+            if (activeManager?.handleJavaScriptException(e) != true) {
+                previousHandler?.handleException(e) ?: throw e
+            }
+        }
+    }
+
+    companion object {
+        private const val TAG = "HotUpdaterRecovery"
+        private const val CRASH_MARKER_FILENAME = "recovery-crash-marker.json"
+        private const val WATCHDOG_STATE_FILENAME = "recovery-watchdog-state.txt"
+        private const val WATCHDOG_ACTION = "com.hotupdater.RECOVERY_WATCHDOG"
+        private const val MONITORING_GRACE_PERIOD_MS = 10_000L
+        private const val WATCHDOG_TICK_INTERVAL_MS = 1_500L
+        private const val JS_EXCEPTION_HOOK_RETRY_DELAY_MS = 50L
+
+        @Volatile
+        private var nativeLibraryLoadAttempted = false
+
+        @Volatile
+        private var nativeLibraryLoaded = false
+
+        @Volatile
+        private var signalHandlerInstalled = false
+
+        @Volatile
+        private var exceptionHandlerInstalled = false
+
+        @Volatile
+        private var previousExceptionHandler: Thread.UncaughtExceptionHandler? = null
+
+        @Volatile
+        private var activeManager: HotUpdaterRecoveryManager? = null
+
+        private val patchedInstanceManagerIds = mutableSetOf<Int>()
+        private val patchedCatalystInstanceIds = mutableSetOf<Int>()
+        private val patchedReactContextIds = mutableSetOf<Int>()
+        private val patchedReactHostDelegateIds = mutableSetOf<Int>()
+
+        @JvmStatic
+        fun handleRecoveryWatchdog(context: Context) {
+            val appContext = context.applicationContext
+            val watchdogStateFile = File(getBundleStoreDir(appContext), WATCHDOG_STATE_FILENAME)
+            val deadlineAt = watchdogStateFile.takeIf(File::exists)?.readText()?.toLongOrNull()
+            if (deadlineAt == null) {
+                cancelRecoveryWatchdogAlarm(appContext)
+                watchdogStateFile.delete()
+                return
+            }
+
+            val crashMarkerFile = File(getBundleStoreDir(appContext), CRASH_MARKER_FILENAME)
+            if (crashMarkerFile.exists()) {
+                Log.i(TAG, "Recovery watchdog detected crash marker, relaunching app")
+                watchdogStateFile.delete()
+                cancelRecoveryWatchdogAlarm(appContext)
+                launchRecoveryRestart(appContext)
+                return
+            }
+
+            if (System.currentTimeMillis() >= deadlineAt) {
+                watchdogStateFile.delete()
+                cancelRecoveryWatchdogAlarm(appContext)
+                return
+            }
+
+            scheduleRecoveryWatchdogTick(appContext, WATCHDOG_TICK_INTERVAL_MS)
+        }
+
+        private fun getBundleStoreDir(context: Context): File = File(context.getExternalFilesDir(null) ?: context.filesDir, "bundle-store")
+
+        private fun getRecoveryWatchdogIntent(context: Context): Intent =
+            Intent(context, HotUpdaterRecoveryReceiver::class.java).setAction(WATCHDOG_ACTION)
+
+        private fun getRecoveryWatchdogPendingIntent(context: Context): PendingIntent =
+            PendingIntent.getBroadcast(
+                context,
+                0,
+                getRecoveryWatchdogIntent(context),
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+            )
+
+        private fun scheduleRecoveryWatchdogTick(
+            context: Context,
+            delayMs: Long,
+        ) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            val triggerAt = SystemClock.elapsedRealtime() + delayMs
+            alarmManager.set(
+                AlarmManager.ELAPSED_REALTIME_WAKEUP,
+                triggerAt,
+                getRecoveryWatchdogPendingIntent(context),
+            )
+        }
+
+        private fun cancelRecoveryWatchdogAlarm(context: Context) {
+            val alarmManager = context.getSystemService(AlarmManager::class.java) ?: return
+            alarmManager.cancel(getRecoveryWatchdogPendingIntent(context))
+        }
+
+        private fun launchRecoveryRestart(context: Context) {
+            val restartIntent =
+                Intent(context, HotUpdaterRestartActivity::class.java).apply {
+                    putExtra(HotUpdaterRestartActivity.EXTRA_PACKAGE_NAME, context.packageName)
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                    addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION)
+                }
+
+            try {
+                context.startActivity(restartIntent)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to launch recovery restart", e)
+            }
+        }
+    }
+}

package/android/src/main/java/com/hotupdater/HotUpdaterRecoveryReceiver.kt

@@ -0,0 +1,14 @@
+package com.hotupdater
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+
+class HotUpdaterRecoveryReceiver : BroadcastReceiver() {
+    override fun onReceive(
+        context: Context,
+        intent: Intent,
+    ) {
+        HotUpdaterRecoveryManager.handleRecoveryWatchdog(context)
+    }
+}

package/android/src/newarch/HotUpdaterModule.kt

@@ -145,16 +145,10 @@ class HotUpdaterModule internal constructor(
         // No-op
     }
 
-    override fun notifyAppReady(params: ReadableMap): WritableNativeMap {
+    override fun notifyAppReady(): WritableNativeMap {
         val result = WritableNativeMap()
-        val bundleId = params.getString("bundleId")
-        if (bundleId == null) {
-            result.putString("status", "STABLE")
-            return result
-        }
-
         val impl = getInstance()
-        val statusMap = impl.notifyAppReady(bundleId)
+        val statusMap = impl.notifyAppReady()
 
         result.putString("status", statusMap["status"] as? String ?: "STABLE")
         statusMap["crashedBundleId"]?.let {