expo 53.0.13 → 53.0.15

package/android/build.gradle

@@ -32,7 +32,7 @@ buildscript {
 def reactNativeVersion = project.extensions.getByType(ExpoModuleExtension).reactNativeVersion
 
 group = 'host.exp.exponent'
-version = '53.0.13'
+version = '53.0.15'
 
 expoModule {
   // We can't prebuild the module because it depends on the generated files.
@@ -43,7 +43,7 @@ android {
   namespace "expo.core"
   defaultConfig {
     versionCode 1
-    versionName "53.0.13"
+    versionName "53.0.15"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {
@@ -77,6 +77,8 @@ dependencies { dependencyHandler ->
   testImplementation 'androidx.test:core:1.5.0'
   testImplementation "com.google.truth:truth:1.1.2"
   testImplementation 'io.mockk:mockk:1.13.5'
+  testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.2'
+  testImplementation 'org.robolectric:robolectric:4.15.1'
 
   if (useLegacyAutolinking) {
     // Link expo modules as dependencies of the adapter. It uses `api` configuration so they all will be visible for the app as well.

package/android/src/main/java/expo/modules/ReactActivityDelegateWrapper.kt

@@ -1,13 +1,20 @@
 package expo.modules
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
+import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.os.Build
+import android.os.Build.VERSION
 import android.os.Bundle
+import android.util.Log
 import android.view.KeyEvent
 import android.view.ViewGroup
+import androidx.annotation.VisibleForTesting
 import androidx.collection.ArrayMap
+import androidx.lifecycle.lifecycleScope
 import com.facebook.react.ReactActivity
 import com.facebook.react.ReactActivityDelegate
 import com.facebook.react.ReactDelegate
@@ -18,17 +25,22 @@ import com.facebook.react.ReactNativeHost
 import com.facebook.react.ReactRootView
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.modules.core.PermissionListener
+import expo.modules.core.interfaces.ReactActivityHandler.DelayLoadAppHandler
 import expo.modules.core.interfaces.ReactActivityLifecycleListener
 import expo.modules.kotlin.Utils
 import expo.modules.rncompatibility.ReactNativeFeatureFlags
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.launch
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
 
 class ReactActivityDelegateWrapper(
   private val activity: ReactActivity,
   private val isNewArchitectureEnabled: Boolean,
-  private var delegate: ReactActivityDelegate
+  @get:VisibleForTesting internal var delegate: ReactActivityDelegate
 ) : ReactActivityDelegate(activity, null) {
   constructor(activity: ReactActivity, delegate: ReactActivityDelegate) :
     this(activity, false, delegate)
@@ -44,9 +56,14 @@ class ReactActivityDelegateWrapper(
   private val _reactHost: ReactHost? by lazy {
     delegate.reactHost
   }
+  private val delayLoadAppHandler: DelayLoadAppHandler? by lazy {
+    reactActivityHandlers.asSequence()
+      .mapNotNull { it.getDelayLoadAppHandler(activity, reactNativeHost) }
+      .firstOrNull()
+  }
 
   /**
-   * When the app delay for `loadApp`, the ReactInstanceManager's lifecycle will be disrupted.
+   * When the app delay for `loadApp`, the React Native lifecycle will be disrupted.
    * This flag indicates we should emit `onResume` after `loadApp`.
    */
   private var shouldEmitPendingResume = false
@@ -82,53 +99,12 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun loadApp(appKey: String?) {
-    // Give modules a chance to wrap the ReactRootView in a container ViewGroup. If some module
-    // wants to do this, we override the functionality of `loadApp` and call `setContentView` with
-    // the new container view instead.
-    val rootViewContainer = reactActivityHandlers.asSequence()
-      .mapNotNull { it.createReactRootViewContainer(activity) }
-      .firstOrNull()
-    if (rootViewContainer != null) {
-      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
-      mReactDelegate.isAccessible = true
-      val reactDelegate = mReactDelegate[delegate] as ReactDelegate
-
-      reactDelegate.loadApp(appKey)
-      val reactRootView = reactDelegate.reactRootView
-      (reactRootView?.parent as? ViewGroup)?.removeView(reactRootView)
-      rootViewContainer.addView(reactRootView, ViewGroup.LayoutParams.MATCH_PARENT)
-      activity.setContentView(rootViewContainer)
-      reactActivityLifecycleListeners.forEach { listener ->
-        listener.onContentChanged(activity)
-      }
-      return
-    }
-
-    val delayLoadAppHandler = reactActivityHandlers.asSequence()
-      .mapNotNull { it.getDelayLoadAppHandler(activity, reactNativeHost) }
-      .firstOrNull()
-    if (delayLoadAppHandler != null) {
-      shouldEmitPendingResume = true
-      delayLoadAppHandler.whenReady {
-        Utils.assertMainThread()
-        invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
-        reactActivityLifecycleListeners.forEach { listener ->
-          listener.onContentChanged(activity)
-        }
-        if (shouldEmitPendingResume) {
-          shouldEmitPendingResume = false
-          onResume()
-        }
-      }
-      return
-    }
-
-    invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onContentChanged(activity)
+    activity.lifecycleScope.launch(start = CoroutineStart.UNDISPATCHED) {
+      loadAppImpl(appKey, supportsDelayLoad = true)
     }
   }
 
+  @SuppressLint("DiscouragedPrivateApi")
   override fun onCreate(savedInstanceState: Bundle?) {
     // Give handlers a chance as early as possible to replace the wrapped delegate object.
     // If they do, we call the new wrapped delegate's `onCreate` instead of overriding it here.
@@ -144,38 +120,49 @@ class ReactActivityDelegateWrapper(
       mDelegateField.set(activity, newDelegate)
       delegate = newDelegate
 
-      invokeDelegateMethod<Unit, Bundle?>("onCreate", arrayOf(Bundle::class.java), arrayOf(savedInstanceState))
+      delegate.onCreate(savedInstanceState)
     } else {
       // Since we just wrap `ReactActivityDelegate` but not inherit it, in its `onCreate`,
       // the calls to `createRootView()` or `getMainComponentName()` have no chances to be our wrapped methods.
       // Instead we intercept `ReactActivityDelegate.onCreate` and replace the `mReactDelegate` with our version.
       // That's not ideal but works.
-      val launchOptions = composeLaunchOptions()
-      val reactDelegate: ReactDelegate
-      if (ReactNativeFeatureFlags.enableBridgelessArchitecture) {
-        reactDelegate = ReactDelegate(
-          plainActivity,
-          reactHost,
-          mainComponentName,
-          launchOptions
-        )
-      } else {
-        reactDelegate = object : ReactDelegate(
-          plainActivity,
-          reactNativeHost,
-          mainComponentName,
-          launchOptions
-        ) {
-          override fun createRootView(): ReactRootView {
-            return this@ReactActivityDelegateWrapper.createRootView() ?: super.createRootView()
+
+      activity.lifecycleScope.launch(start = CoroutineStart.UNDISPATCHED) {
+        awaitDelayLoadAppWhenReady(delayLoadAppHandler)
+
+        if (VERSION.SDK_INT >= Build.VERSION_CODES.O && isWideColorGamutEnabled) {
+          activity.window.colorMode = ActivityInfo.COLOR_MODE_WIDE_COLOR_GAMUT
+        }
+
+        val launchOptions = composeLaunchOptions()
+        val reactDelegate: ReactDelegate
+        if (ReactNativeFeatureFlags.enableBridgelessArchitecture) {
+          reactDelegate = ReactDelegate(
+            plainActivity,
+            reactHost,
+            mainComponentName,
+            launchOptions
+          )
+        } else {
+          reactDelegate = object : ReactDelegate(
+            plainActivity,
+            reactNativeHost,
+            mainComponentName,
+            launchOptions,
+            isFabricEnabled
+          ) {
+            override fun createRootView(): ReactRootView {
+              return this@ReactActivityDelegateWrapper.createRootView() ?: super.createRootView()
+            }
           }
         }
-      }
-      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
-      mReactDelegate.isAccessible = true
-      mReactDelegate.set(delegate, reactDelegate)
-      if (mainComponentName != null) {
-        loadApp(mainComponentName)
+
+        val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
+        mReactDelegate.isAccessible = true
+        mReactDelegate.set(delegate, reactDelegate)
+        if (mainComponentName != null) {
+          loadAppImpl(mainComponentName, supportsDelayLoad = false)
+        }
       }
     }
 
@@ -188,7 +175,7 @@ class ReactActivityDelegateWrapper(
     if (shouldEmitPendingResume) {
       return
     }
-    invokeDelegateMethod<Unit>("onResume")
+    delegate.onResume()
     reactActivityLifecycleListeners.forEach { listener ->
       listener.onResume(activity)
     }
@@ -204,14 +191,26 @@ class ReactActivityDelegateWrapper(
     reactActivityLifecycleListeners.forEach { listener ->
       listener.onPause(activity)
     }
-    return invokeDelegateMethod("onPause")
+    if (delayLoadAppHandler != null) {
+      try {
+        // For the delay load case, we may enter a different call flow than react-native.
+        // For example, Activity stopped before delay load finished.
+        // We stop before the ReactActivityDelegate gets a chance to set up.
+        // In this case, we should catch the exceptions.
+        delegate.onPause()
+      } catch (e: Exception) {
+        Log.e(TAG, "Exception occurred during onPause with delayed app loading", e)
+      }
+    } else {
+      delegate.onPause()
+    }
   }
 
   override fun onUserLeaveHint() {
     reactActivityLifecycleListeners.forEach { listener ->
       listener.onUserLeaveHint(activity)
     }
-    return invokeDelegateMethod("onUserLeaveHint")
+    delegate.onUserLeaveHint()
   }
 
   override fun onDestroy() {
@@ -224,7 +223,19 @@ class ReactActivityDelegateWrapper(
     reactActivityLifecycleListeners.forEach { listener ->
       listener.onDestroy(activity)
     }
-    return invokeDelegateMethod("onDestroy")
+    if (delayLoadAppHandler != null) {
+      try {
+        // For the delay load case, we may enter a different call flow than react-native.
+        // For example, Activity stopped before delay load finished.
+        // We stop before the ReactActivityDelegate gets a chance to set up.
+        // In this case, we should catch the exceptions.
+        delegate.onDestroy()
+      } catch (e: Exception) {
+        Log.e(TAG, "Exception occurred during onDestroy with delayed app loading", e)
+      }
+    } else {
+      delegate.onDestroy()
+    }
   }
 
   override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
@@ -318,6 +329,10 @@ class ReactActivityDelegateWrapper(
     return invokeDelegateMethod("isFabricEnabled")
   }
 
+  override fun isWideColorGamutEnabled(): Boolean {
+    return invokeDelegateMethod("isWideColorGamutEnabled")
+  }
+
   override fun composeLaunchOptions(): Bundle? {
     return invokeDelegateMethod("composeLaunchOptions")
   }
@@ -341,8 +356,9 @@ class ReactActivityDelegateWrapper(
     return method!!.invoke(delegate) as T
   }
 
+  @VisibleForTesting
   @Suppress("UNCHECKED_CAST")
-  private fun <T, A> invokeDelegateMethod(
+  internal fun <T, A> invokeDelegateMethod(
     name: String,
     argTypes: Array<Class<*>>,
     args: Array<A>
@@ -356,5 +372,68 @@ class ReactActivityDelegateWrapper(
     return method!!.invoke(delegate, *args) as T
   }
 
+  private suspend fun loadAppImpl(appKey: String?, supportsDelayLoad: Boolean) {
+    // Give modules a chance to wrap the ReactRootView in a container ViewGroup. If some module
+    // wants to do this, we override the functionality of `loadApp` and call `setContentView` with
+    // the new container view instead.
+    val rootViewContainer = reactActivityHandlers.asSequence()
+      .mapNotNull { it.createReactRootViewContainer(activity) }
+      .firstOrNull()
+    if (rootViewContainer != null) {
+      val mReactDelegate = ReactActivityDelegate::class.java.getDeclaredField("mReactDelegate")
+      mReactDelegate.isAccessible = true
+      val reactDelegate = mReactDelegate[delegate] as ReactDelegate
+
+      reactDelegate.loadApp(appKey)
+      val reactRootView = reactDelegate.reactRootView
+      (reactRootView?.parent as? ViewGroup)?.removeView(reactRootView)
+      rootViewContainer.addView(reactRootView, ViewGroup.LayoutParams.MATCH_PARENT)
+      activity.setContentView(rootViewContainer)
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onContentChanged(activity)
+      }
+      return
+    }
+
+    if (supportsDelayLoad) {
+      awaitDelayLoadAppWhenReady(delayLoadAppHandler)
+      invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onContentChanged(activity)
+      }
+      if (shouldEmitPendingResume) {
+        shouldEmitPendingResume = false
+        onResume()
+      }
+      return
+    }
+
+    invokeDelegateMethod<Unit, String?>("loadApp", arrayOf(String::class.java), arrayOf(appKey))
+    reactActivityLifecycleListeners.forEach { listener ->
+      listener.onContentChanged(activity)
+    }
+    if (shouldEmitPendingResume) {
+      shouldEmitPendingResume = false
+      onResume()
+    }
+  }
+
+  private suspend fun awaitDelayLoadAppWhenReady(delayLoadAppHandler: DelayLoadAppHandler?) {
+    if (delayLoadAppHandler == null) {
+      return
+    }
+    shouldEmitPendingResume = true
+    suspendCoroutine { continuation ->
+      delayLoadAppHandler.whenReady {
+        Utils.assertMainThread()
+        continuation.resume(Unit)
+      }
+    }
+  }
+
   //endregion
+
+  companion object {
+    private val TAG = ReactActivityDelegate::class.simpleName
+  }
 }

package/android/src/main/java/expo/modules/fetch/FetchExceptions.kt

@@ -7,8 +7,8 @@ import expo.modules.kotlin.exception.CodedException
 internal class FetchUnknownException :
   CodedException("Unknown error")
 
-internal class FetchRequestCancelledException :
-  CodedException("Cancelled request")
+internal class FetchRequestCanceledException :
+  CodedException("Fetch request has been canceled")
 
 internal class FetchAndroidContextLostException :
   CodedException("The Android context has been lost")

package/android/src/main/java/expo/modules/fetch/NativeRequest.kt

@@ -43,6 +43,6 @@ internal class NativeRequest(appContext: AppContext, internal val response: Nati
   fun cancel() {
     val task = this.task ?: return
     task.cancel()
-    response.emitRequestCancelled()
+    response.emitRequestCanceled()
   }
 }

package/android/src/main/java/expo/modules/fetch/NativeResponse.kt

@@ -3,6 +3,7 @@
 package expo.modules.fetch
 
 import android.util.Log
+import expo.modules.core.logging.localizedMessageWithCauseLocalizedMessage
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.sharedobjects.SharedObject
 import kotlinx.coroutines.CoroutineScope
@@ -68,14 +69,14 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
     if (isInvalidState(ResponseState.BODY_STREAMING_STARTED)) {
       return
     }
-    state = ResponseState.BODY_STREAMING_CANCELLED
+    state = ResponseState.BODY_STREAMING_CANCELED
   }
 
-  fun emitRequestCancelled() {
-    val error = FetchRequestCancelledException()
+  fun emitRequestCanceled() {
+    val error = FetchRequestCanceledException()
     this.error = error
     if (state == ResponseState.BODY_STREAMING_STARTED) {
-      emit("didFailWithError", error)
+      emit("didFailWithError", error.localizedMessageWithCauseLocalizedMessage())
     }
     state = ResponseState.ERROR_RECEIVED
   }
@@ -97,7 +98,7 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
   //region Callback implementations
 
   override fun onFailure(call: Call, e: IOException) {
-    // Canceled request should be handled by emitRequestCancelled
+    // Canceled request should be handled by emitRequestCanceled
     if (e.message === "Canceled") {
       return
     }
@@ -106,14 +107,14 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
         ResponseState.STARTED,
         ResponseState.RESPONSE_RECEIVED,
         ResponseState.BODY_STREAMING_STARTED,
-        ResponseState.BODY_STREAMING_CANCELLED
+        ResponseState.BODY_STREAMING_CANCELED
       )
     ) {
       return
     }
 
     if (state == ResponseState.BODY_STREAMING_STARTED) {
-      emit("didFailWithError", e)
+      emit("didFailWithError", e.localizedMessageWithCauseLocalizedMessage())
     }
     error = e
     state = ResponseState.ERROR_RECEIVED
@@ -174,7 +175,7 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
         if (isInvalidState(
             ResponseState.RESPONSE_RECEIVED,
             ResponseState.BODY_STREAMING_STARTED,
-            ResponseState.BODY_STREAMING_CANCELLED
+            ResponseState.BODY_STREAMING_CANCELED
           )
         ) {
           break
@@ -190,7 +191,7 @@ internal class NativeResponse(appContext: AppContext, private val coroutineScope
     } catch (e: IOException) {
       this.error = e
       if (state == ResponseState.BODY_STREAMING_STARTED) {
-        emit("didFailWithError", e)
+        emit("didFailWithError", e.localizedMessageWithCauseLocalizedMessage())
       }
       state = ResponseState.ERROR_RECEIVED
     }

package/android/src/main/java/expo/modules/fetch/ResponseState.kt

@@ -8,6 +8,6 @@ internal enum class ResponseState(val intValue: Int) {
   RESPONSE_RECEIVED(2),
   BODY_COMPLETED(3),
   BODY_STREAMING_STARTED(4),
-  BODY_STREAMING_CANCELLED(5),
+  BODY_STREAMING_CANCELED(5),
   ERROR_RECEIVED(6)
 }

package/android/src/test/java/expo/modules/ReactActivityDelegateWrapperDelayLoadTest.kt

@@ -0,0 +1,336 @@
+package expo.modules
+
+import android.app.Activity
+import android.app.Application
+import android.content.Context
+import com.facebook.react.ReactActivity
+import com.facebook.react.ReactActivityDelegate
+import com.facebook.react.ReactApplication
+import com.facebook.react.ReactHost
+import com.facebook.react.ReactNativeHost
+import com.facebook.react.ReactRootView
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.fabricEnabled
+import com.facebook.react.defaults.DefaultReactActivityDelegate
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.soloader.SoLoader
+import expo.modules.core.interfaces.Package
+import expo.modules.core.interfaces.ReactActivityHandler
+import expo.modules.core.interfaces.ReactActivityHandler.DelayLoadAppHandler
+import expo.modules.core.interfaces.ReactActivityLifecycleListener
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.slot
+import io.mockk.spyk
+import io.mockk.unmockkAll
+import io.mockk.verify
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.Config
+
+@RunWith(RobolectricTestRunner::class)
+@Config(application = MockApplication::class)
+internal class ReactActivityDelegateWrapperDelayLoadTest {
+  @RelaxedMockK
+  private lateinit var delayLoadAppHandler: DelayLoadAppHandler
+
+  private lateinit var mockPackageWithDelay: MockPackageWithDelayHandler
+  private lateinit var mockPackageWithoutDelay: MockPackageWithoutDelayHandler
+  private lateinit var activityController: ActivityController<MockActivity>
+  private val activity: MockActivity
+    get() = activityController.get()
+
+  @OptIn(ExperimentalCoroutinesApi::class)
+  @Before
+  fun setUp() {
+    SoLoader.setInTestMode()
+    mockkObject(ExpoModulesPackage.Companion)
+    mockkStatic(ReactNativeFeatureFlags::class)
+    every { ReactNativeFeatureFlags.enableBridgelessArchitecture() } returns true
+    every { ReactNativeFeatureFlags.enableFabricRenderer() } returns true
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+
+    MockKAnnotations.init(this)
+
+    mockPackageWithDelay = MockPackageWithDelayHandler(delayLoadAppHandler)
+    mockPackageWithoutDelay = MockPackageWithoutDelayHandler()
+  }
+
+  @After
+  fun tearDown() {
+    unmockkAll()
+  }
+
+  @Test
+  fun `should proceed loadApp immediately when no delayLoadAppHandler`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithoutDelay)
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    verify { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+  }
+
+  @Test
+  fun `should block loadApp until delayLoadAppHandler finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+
+    verify(exactly = 0) { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+    callbackSlot.captured.run()
+    verify(exactly = 1) { spyDelegateWrapper.invokeDelegateMethod("loadApp", arrayOf(String::class.java), arrayOf("main")) }
+  }
+
+  @Test
+  fun `should call lifecycle methods in correct order with delay load`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    callbackSlot.captured.run()
+    verify(exactly = 2) { spyDelegateWrapper.onResume() }
+    verify(exactly = 1) { spyDelegate.onResume() }
+    verify(exactly = 0) { spyDelegateWrapper.onPause() }
+    verify(exactly = 0) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 0) { spyDelegate.onPause() }
+    verify(exactly = 0) { spyDelegate.onDestroy() }
+
+    activityController.pause().stop().destroy()
+    verify(exactly = 1) { spyDelegateWrapper.onPause() }
+    verify(exactly = 1) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 1) { spyDelegate.onPause() }
+    verify(exactly = 1) { spyDelegate.onDestroy() }
+  }
+
+  @Test
+  fun `should have normal lifecycle when no delayLoadHandler`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithoutDelay)
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 1) { spyDelegate.onResume() }
+
+    activityController.pause().stop().destroy()
+    verify(exactly = 1) { spyDelegateWrapper.onPause() }
+    verify(exactly = 1) { spyDelegateWrapper.onDestroy() }
+    verify(exactly = 1) { spyDelegate.onPause() }
+    verify(exactly = 1) { spyDelegate.onDestroy() }
+  }
+
+  @Test
+  fun `should cancel pending resume if activity pause before delay load finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    activityController.pause()
+    callbackSlot.captured.run()
+    verify(exactly = 0) { spyDelegate.onResume() }
+  }
+
+  @Test
+  fun `should cancel pending resume if activity stop before delay load finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    activityController.pause().stop()
+    callbackSlot.captured.run()
+    verify(exactly = 0) { spyDelegate.onResume() }
+  }
+
+  @Test
+  fun `should cancel pending resume if activity destroy before delay load finished`() = runTest {
+    every { ExpoModulesPackage.Companion.packageList } returns listOf(mockPackageWithDelay)
+
+    val callbackSlot = slot<Runnable>()
+    every { delayLoadAppHandler.whenReady(capture(callbackSlot)) } answers {
+      // Don't call the callback immediately to simulate delay
+    }
+
+    activityController = Robolectric.buildActivity(MockActivity::class.java)
+      .also {
+        val activity = it.get()
+        (activity.application as MockApplication).bindCurrentActivity(activity)
+      }
+      .setup()
+    val spyDelegateWrapper = activity.reactActivityDelegate as ReactActivityDelegateWrapper
+    val spyDelegate = spyDelegateWrapper.delegate
+
+    verify(exactly = 1) { spyDelegateWrapper.onCreate(any()) }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
+    verify(exactly = 0) { spyDelegate.onResume() }
+
+    activityController.pause().stop().destroy()
+    callbackSlot.captured.run()
+    verify(exactly = 0) { spyDelegate.onResume() }
+  }
+}
+
+internal class MockPackageWithDelayHandler(delayHandler: DelayLoadAppHandler) : Package {
+  private val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+
+  init {
+    every { reactActivityHandler.createReactRootViewContainer(any()) } returns null
+    every { reactActivityHandler.onDidCreateReactActivityDelegate(any(), any()) } returns null
+    every { reactActivityHandler.getDelayLoadAppHandler(any(), any()) } returns delayHandler
+  }
+
+  override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
+    return listOf(reactActivityLifecycleListener)
+  }
+
+  override fun createReactActivityHandlers(activityContext: Context?): List<ReactActivityHandler> {
+    return listOf(reactActivityHandler)
+  }
+}
+
+internal class MockPackageWithoutDelayHandler : Package {
+  private val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+
+  init {
+    every { reactActivityHandler.createReactRootViewContainer(any()) } returns null
+    every { reactActivityHandler.onDidCreateReactActivityDelegate(any(), any()) } returns null
+    every { reactActivityHandler.getDelayLoadAppHandler(any(), any()) } returns null
+  }
+
+  override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
+    return listOf(reactActivityLifecycleListener)
+  }
+
+  override fun createReactActivityHandlers(activityContext: Context?): List<ReactActivityHandler> {
+    return listOf(reactActivityHandler)
+  }
+}
+
+internal class MockApplication : Application(), ReactApplication {
+  private var currentActivity: Activity? = null
+
+  override fun onCreate() {
+    super.onCreate()
+    setTheme(androidx.appcompat.R.style.Theme_AppCompat)
+  }
+
+  internal fun bindCurrentActivity(activity: Activity?) {
+    currentActivity = activity
+  }
+
+  override val reactNativeHost: ReactNativeHost = mockk<ReactNativeHost>(relaxed = true)
+
+  override val reactHost: ReactHost by lazy {
+    mockk<ReactHost>(relaxed = true)
+      .also {
+        val mockReactSurface = mockk<ReactSurface>(relaxed = true)
+        every { mockReactSurface.view } returns ReactRootView(currentActivity)
+        every { it.createSurface(any(), any(), any()) } returns mockReactSurface
+      }
+  }
+}
+
+internal class MockActivity : ReactActivity() {
+  override fun getMainComponentName(): String = "main"
+
+  override fun createReactActivityDelegate(): ReactActivityDelegate = spyk(
+    ReactActivityDelegateWrapper(
+      this,
+      BuildConfig.IS_NEW_ARCHITECTURE_ENABLED,
+      spyk(
+        object : DefaultReactActivityDelegate(
+          this,
+          mainComponentName,
+          fabricEnabled
+        ) {}
+      )
+    )
+  )
+}

package/bundledNativeModules.json

@@ -1,8 +1,8 @@
 {
-  "@expo/fingerprint": "~0.13.1",
+  "@expo/fingerprint": "~0.13.3",
   "@expo/metro-runtime": "~5.0.4",
   "@expo/vector-icons": "^14.1.0",
-  "@expo/ui": "~0.1.1-alpha.9",
+  "@expo/ui": "~0.1.1-alpha.10",
   "@react-native-async-storage/async-storage": "2.1.2",
   "@react-native-community/datetimepicker": "8.4.1",
   "@react-native-masked-view/masked-view": "0.3.2",
@@ -17,34 +17,34 @@
   "expo-app-auth": "~11.1.0",
   "expo-app-loader-provider": "~8.0.0",
   "expo-apple-authentication": "~7.2.4",
-  "expo-application": "~6.1.4",
-  "expo-asset": "~11.1.5",
+  "expo-application": "~6.1.5",
+  "expo-asset": "~11.1.6",
   "expo-audio": "~0.4.7",
   "expo-auth-session": "~6.2.0",
-  "expo-av": "~15.1.6",
-  "expo-background-fetch": "~13.1.5",
-  "expo-background-task": "~0.2.7",
+  "expo-av": "~15.1.7",
+  "expo-background-fetch": "~13.1.6",
+  "expo-background-task": "~0.2.8",
   "expo-battery": "~9.1.4",
   "expo-blur": "~14.1.5",
   "expo-brightness": "~13.1.4",
-  "expo-build-properties": "~0.14.6",
+  "expo-build-properties": "~0.14.8",
   "expo-calendar": "~14.1.4",
-  "expo-camera": "~16.1.9",
-  "expo-cellular": "~7.1.4",
+  "expo-camera": "~16.1.10",
+  "expo-cellular": "~7.1.5",
   "expo-checkbox": "~4.1.4",
-  "expo-clipboard": "~7.1.4",
+  "expo-clipboard": "~7.1.5",
   "expo-constants": "~17.1.6",
   "expo-contacts": "~14.2.5",
   "expo-crypto": "~14.1.5",
-  "expo-dev-client": "~5.2.1",
+  "expo-dev-client": "~5.2.2",
   "expo-device": "~7.1.4",
   "expo-document-picker": "~13.1.6",
-  "expo-file-system": "~18.1.10",
-  "expo-font": "~13.3.1",
-  "expo-gl": "~15.1.6",
+  "expo-file-system": "~18.1.11",
+  "expo-font": "~13.3.2",
+  "expo-gl": "~15.1.7",
   "expo-google-app-auth": "~8.3.0",
   "expo-haptics": "~14.1.4",
-  "expo-image": "~2.3.0",
+  "expo-image": "~2.3.1",
   "expo-image-loader": "~5.1.0",
   "expo-image-manipulator": "~13.1.7",
   "expo-image-picker": "~16.1.4",
@@ -52,24 +52,24 @@
   "expo-insights": "~0.9.3",
   "expo-keep-awake": "~14.1.4",
   "expo-linear-gradient": "~14.1.5",
-  "expo-linking": "~7.1.5",
-  "expo-local-authentication": "~16.0.4",
-  "expo-localization": "~16.1.5",
-  "expo-location": "~18.1.5",
-  "expo-mail-composer": "~14.1.4",
+  "expo-linking": "~7.1.6",
+  "expo-local-authentication": "~16.0.5",
+  "expo-localization": "~16.1.6",
+  "expo-location": "~18.1.6",
+  "expo-mail-composer": "~14.1.5",
   "expo-manifests": "~0.16.5",
   "expo-maps": "~0.11.0",
   "expo-media-library": "~17.1.7",
   "expo-mesh-gradient": "~0.3.4",
   "expo-module-template": "~10.16.6",
-  "expo-modules-core": "~2.4.0",
+  "expo-modules-core": "~2.4.1",
   "expo-navigation-bar": "~4.2.6",
   "expo-network": "~7.1.5",
   "expo-notifications": "~0.31.3",
   "expo-print": "~14.1.4",
   "expo-live-photo": "~0.1.4",
-  "expo-router": "~5.1.1",
-  "expo-screen-capture": "~7.1.4",
+  "expo-router": "~5.1.2",
+  "expo-screen-capture": "~7.1.5",
   "expo-screen-orientation": "~8.1.7",
   "expo-secure-store": "~14.2.3",
   "expo-sensors": "~14.1.4",
@@ -77,18 +77,18 @@
   "expo-sms": "~13.1.4",
   "expo-speech": "~13.1.7",
   "expo-splash-screen": "~0.30.9",
-  "expo-sqlite": "~15.2.12",
+  "expo-sqlite": "~15.2.13",
   "expo-status-bar": "~2.2.3",
   "expo-store-review": "~8.1.5",
   "expo-symbols": "~0.4.5",
   "expo-system-ui": "~5.0.9",
-  "expo-task-manager": "~13.1.5",
+  "expo-task-manager": "~13.1.6",
   "expo-tracking-transparency": "~5.2.4",
   "expo-updates": "~0.28.15",
   "expo-video-thumbnails": "~9.1.3",
   "expo-video": "~2.2.2",
   "expo-web-browser": "~14.2.0",
-  "jest-expo": "~53.0.7",
+  "jest-expo": "~53.0.8",
   "lottie-react-native": "7.2.2",
   "react": "19.0.0",
   "react-dom": "19.0.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "53.0.13",
+  "version": "53.0.15",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -73,20 +73,20 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "0.24.15",
-    "@expo/config": "~11.0.10",
+    "@expo/cli": "0.24.16",
+    "@expo/config": "~11.0.11",
     "@expo/config-plugins": "~10.0.3",
-    "@expo/fingerprint": "0.13.1",
+    "@expo/fingerprint": "0.13.3",
     "@expo/metro-config": "0.20.15",
     "@expo/vector-icons": "^14.0.0",
     "babel-preset-expo": "~13.2.1",
-    "expo-asset": "~11.1.5",
+    "expo-asset": "~11.1.6",
     "expo-constants": "~17.1.6",
-    "expo-file-system": "~18.1.10",
-    "expo-font": "~13.3.1",
+    "expo-file-system": "~18.1.11",
+    "expo-font": "~13.3.2",
     "expo-keep-awake": "~14.1.4",
-    "expo-modules-autolinking": "2.1.12",
-    "expo-modules-core": "2.4.0",
+    "expo-modules-autolinking": "2.1.13",
+    "expo-modules-core": "2.4.1",
     "react-native-edge-to-edge": "1.6.0",
     "whatwg-url-without-unicode": "8.0.0-3"
   },
@@ -119,5 +119,5 @@
       "optional": true
     }
   },
-  "gitHead": "ee5bda70ea20e9f1411fbdc346fca76d9ac57f57"
+  "gitHead": "ceb57fc0dd75de75dc7006e20792b29e947226f3"
 }