expo 53.0.17 → 53.0.19

package/android/build.gradle

@@ -32,7 +32,7 @@ buildscript {
 def reactNativeVersion = project.extensions.getByType(ExpoModuleExtension).reactNativeVersion
 
 group = 'host.exp.exponent'
-version = '53.0.17'
+version = '53.0.19'
 
 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.17"
+    versionName "53.0.19"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

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

@@ -29,8 +29,13 @@ 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.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import java.lang.reflect.Field
 import java.lang.reflect.Method
 import java.lang.reflect.Modifier
@@ -63,10 +68,25 @@ class ReactActivityDelegateWrapper(
   }
 
   /**
-   * When the app delay for `loadApp`, the React Native lifecycle will be disrupted.
-   * This flag indicates we should emit `onResume` after `loadApp`.
+   * A deferred that indicates when the app loading is ready
    */
-  private var shouldEmitPendingResume = false
+  private val loadAppReady = CompletableDeferred<Unit>()
+
+  /**
+   * A mutex to ensure all coroutines in a scope are running in atomic way.
+   *
+   * This is to act like [Activity] lifecycle,
+   * e.g. all work in [onResume] should be executed after all work in [onCreate] finished.
+   */
+  private val mutex = Mutex()
+
+  /**
+   * A [CoroutineScope] that binds its lifecycle as [ReactActivityDelegateWrapper].
+   * This is used for [onDestroy] because we need a longer lifecycle scope to call [onDestroy]
+   */
+  private val applicationCoroutineScope: CoroutineScope by lazy {
+    CoroutineScope(Dispatchers.Main)
+  }
 
   //region ReactActivityDelegate
 
@@ -99,7 +119,7 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun loadApp(appKey: String?) {
-    activity.lifecycleScope.launch(start = CoroutineStart.UNDISPATCHED) {
+    launchLifecycleScopeWithLock(start = CoroutineStart.UNDISPATCHED) {
       loadAppImpl(appKey, supportsDelayLoad = true)
     }
   }
@@ -127,8 +147,9 @@ class ReactActivityDelegateWrapper(
       // Instead we intercept `ReactActivityDelegate.onCreate` and replace the `mReactDelegate` with our version.
       // That's not ideal but works.
 
-      activity.lifecycleScope.launch(start = CoroutineStart.UNDISPATCHED) {
+      launchLifecycleScopeWithLock(start = CoroutineStart.UNDISPATCHED) {
         awaitDelayLoadAppWhenReady(delayLoadAppHandler)
+        loadAppReady.complete(Unit)
 
         if (VERSION.SDK_INT >= Build.VERSION_CODES.O && isWideColorGamutEnabled) {
           activity.window.colorMode = ActivityInfo.COLOR_MODE_WIDE_COLOR_GAMUT
@@ -172,69 +193,70 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onResume() {
-    if (shouldEmitPendingResume) {
-      return
-    }
-    delegate.onResume()
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onResume(activity)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onResume()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onResume(activity)
+      }
     }
   }
 
   override fun onPause() {
-    // If app is stopped before the delayed `loadApp`, we should cancel the pending resume
-    // and avoid propagating the pause event because the state was never resumed.
-    if (shouldEmitPendingResume) {
-      shouldEmitPendingResume = false
-      return
-    }
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onPause(activity)
-    }
-    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.
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onPause(activity)
+      }
+      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()
-      } 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)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      reactActivityLifecycleListeners.forEach { listener ->
+        listener.onUserLeaveHint(activity)
+      }
+      delegate.onUserLeaveHint()
     }
-    delegate.onUserLeaveHint()
   }
 
   override fun onDestroy() {
-    // If app is stopped before the delayed `loadApp`, we should cancel the pending resume
-    // and avoid propagating the destroy event because the state was never resumed.
-    if (shouldEmitPendingResume) {
-      shouldEmitPendingResume = false
-      return
-    }
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onDestroy(activity)
-    }
-    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)
+    // Note: use our `coroutineScope` for onDestroy here
+    // because the lifecycleScope destroyed before the executions.
+    applicationCoroutineScope.launch {
+      mutex.withLock {
+        loadAppReady.await()
+        reactActivityLifecycleListeners.forEach { listener ->
+          listener.onDestroy(activity)
+        }
+        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()
+        }
       }
-    } else {
-      delegate.onDestroy()
     }
   }
 
@@ -252,20 +274,28 @@ class ReactActivityDelegateWrapper(
      *
      * TODO (@bbarthec): fix it upstream?
      */
-    if (!ReactNativeFeatureFlags.enableBridgelessArchitecture && delegate.reactInstanceManager.currentReactContext == null) {
-      val reactContextListener = object : ReactInstanceEventListener {
-        override fun onReactContextInitialized(context: ReactContext) {
-          delegate.reactInstanceManager.removeReactInstanceEventListener(this)
-          delegate.onActivityResult(requestCode, resultCode, data)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      if (!ReactNativeFeatureFlags.enableBridgelessArchitecture && delegate.reactInstanceManager.currentReactContext == null) {
+        val reactContextListener = object : ReactInstanceEventListener {
+          override fun onReactContextInitialized(context: ReactContext) {
+            delegate.reactInstanceManager.removeReactInstanceEventListener(this)
+            delegate.onActivityResult(requestCode, resultCode, data)
+          }
         }
+        return@launchLifecycleScopeWithLock delegate.reactInstanceManager.addReactInstanceEventListener(
+          reactContextListener
+        )
       }
-      return delegate.reactInstanceManager.addReactInstanceEventListener(reactContextListener)
-    }
 
-    delegate.onActivityResult(requestCode, resultCode, data)
+      delegate.onActivityResult(requestCode, resultCode, data)
+    }
   }
 
   override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -274,6 +304,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onKeyUp(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -282,6 +315,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onKeyLongPress(keyCode: Int, event: KeyEvent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     // if any of the handlers return true, intentionally consume the event instead of passing it
     // through to the delegate
     return reactActivityHandlers
@@ -290,6 +326,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onBackPressed(): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     val listenerResult = reactActivityLifecycleListeners
       .map(ReactActivityLifecycleListener::onBackPressed)
       .fold(false) { accu, current -> accu || current }
@@ -298,6 +337,9 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onNewIntent(intent: Intent?): Boolean {
+    if (!loadAppReady.isCompleted) {
+      return false
+    }
     val listenerResult = reactActivityLifecycleListeners
       .map { it.onNewIntent(intent) }
       .fold(false) { accu, current -> accu || current }
@@ -306,15 +348,24 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onWindowFocusChanged(hasFocus: Boolean) {
-    delegate.onWindowFocusChanged(hasFocus)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onWindowFocusChanged(hasFocus)
+    }
   }
 
   override fun requestPermissions(permissions: Array<out String>?, requestCode: Int, listener: PermissionListener?) {
-    delegate.requestPermissions(permissions, requestCode, listener)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.requestPermissions(permissions, requestCode, listener)
+    }
   }
 
   override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>?, grantResults: IntArray?) {
-    delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    }
   }
 
   override fun getContext(): Context {
@@ -338,7 +389,10 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onConfigurationChanged(newConfig: Configuration?) {
-    delegate.onConfigurationChanged(newConfig)
+    launchLifecycleScopeWithLock {
+      loadAppReady.await()
+      delegate.onConfigurationChanged(newConfig)
+    }
   }
 
   //endregion
@@ -401,10 +455,6 @@ class ReactActivityDelegateWrapper(
       reactActivityLifecycleListeners.forEach { listener ->
         listener.onContentChanged(activity)
       }
-      if (shouldEmitPendingResume) {
-        shouldEmitPendingResume = false
-        onResume()
-      }
       return
     }
 
@@ -412,17 +462,12 @@ class ReactActivityDelegateWrapper(
     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()
@@ -431,6 +476,26 @@ class ReactActivityDelegateWrapper(
     }
   }
 
+  private fun launchLifecycleScopeWithLock(
+    start: CoroutineStart = CoroutineStart.DEFAULT,
+    block: suspend CoroutineScope.() -> Unit
+  ) {
+    activity.lifecycleScope.launch(start = start) {
+      mutex.withLock {
+        block()
+      }
+    }
+  }
+
+  /**
+   * Set the [loadAppReady] to completed state.
+   * This is only for unit tests when a test setups mocks and skips the [Activity] lifecycle.
+   */
+  @VisibleForTesting
+  internal fun setLoadAppReadyForTesting() {
+    loadAppReady.complete(Unit)
+  }
+
   //endregion
 
   companion object {

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

@@ -135,7 +135,7 @@ internal class ReactActivityDelegateWrapperDelayLoadTest {
     verify(exactly = 0) { spyDelegate.onResume() }
 
     callbackSlot.captured.run()
-    verify(exactly = 2) { spyDelegateWrapper.onResume() }
+    verify(exactly = 1) { spyDelegateWrapper.onResume() }
     verify(exactly = 1) { spyDelegate.onResume() }
     verify(exactly = 0) { spyDelegateWrapper.onPause() }
     verify(exactly = 0) { spyDelegateWrapper.onDestroy() }
@@ -173,60 +173,6 @@ internal class ReactActivityDelegateWrapperDelayLoadTest {
     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)

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

@@ -20,9 +20,9 @@ import org.junit.Before
 import org.junit.Test
 
 internal class ReactActivityDelegateWrapperTest {
-  lateinit var mockPackage0: MockPackage
+  private lateinit var mockPackage0: MockPackage
 
-  lateinit var mockPackage1: MockPackage
+  private lateinit var mockPackage1: MockPackage
 
   @RelaxedMockK
   lateinit var activity: ReactActivity
@@ -47,6 +47,7 @@ internal class ReactActivityDelegateWrapperTest {
   @Test
   fun `onBackPressed should call each handler's callback just once`() {
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onBackPressed() } returns true
 
     delegateWrapper.onBackPressed()
@@ -59,6 +60,7 @@ internal class ReactActivityDelegateWrapperTest {
   @Test
   fun `onBackPressed should return true if someone returns true`() {
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onBackPressed() } returns false
     every { mockPackage1.reactActivityLifecycleListener.onBackPressed() } returns true
     every { delegate.onBackPressed() } returns false
@@ -71,6 +73,7 @@ internal class ReactActivityDelegateWrapperTest {
   fun `onNewIntent should call each handler's callback just once`() {
     val intent = mockk<Intent>()
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onNewIntent(intent) } returns false
     every { mockPackage1.reactActivityLifecycleListener.onNewIntent(intent) } returns true
     every { delegate.onNewIntent(intent) } returns false
@@ -86,6 +89,7 @@ internal class ReactActivityDelegateWrapperTest {
   fun `onNewIntent should return true if someone returns true`() {
     val intent = mockk<Intent>()
     val delegateWrapper = ReactActivityDelegateWrapper(activity, delegate)
+    delegateWrapper.setLoadAppReadyForTesting()
     every { mockPackage0.reactActivityLifecycleListener.onNewIntent(intent) } returns false
     every { mockPackage1.reactActivityLifecycleListener.onNewIntent(intent) } returns true
     every { delegate.onNewIntent(intent) } returns false
@@ -97,7 +101,7 @@ internal class ReactActivityDelegateWrapperTest {
 
 internal class MockPackage : Package {
   val reactActivityLifecycleListener = mockk<ReactActivityLifecycleListener>(relaxed = true)
-  val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
+  private val reactActivityHandler = mockk<ReactActivityHandler>(relaxed = true)
 
   override fun createReactActivityLifecycleListeners(activityContext: Context?): List<ReactActivityLifecycleListener> {
     return listOf(reactActivityLifecycleListener)

package/bundledNativeModules.json

@@ -19,7 +19,7 @@
   "expo-apple-authentication": "~7.2.4",
   "expo-application": "~6.1.5",
   "expo-asset": "~11.1.7",
-  "expo-audio": "~0.4.7",
+  "expo-audio": "~0.4.8",
   "expo-auth-session": "~6.2.1",
   "expo-av": "~15.1.7",
   "expo-background-fetch": "~13.1.6",
@@ -65,7 +65,7 @@
   "expo-modules-core": "~2.4.2",
   "expo-navigation-bar": "~4.2.7",
   "expo-network": "~7.1.5",
-  "expo-notifications": "~0.31.3",
+  "expo-notifications": "~0.31.4",
   "expo-print": "~14.1.4",
   "expo-live-photo": "~0.1.4",
   "expo-router": "~5.1.3",
@@ -77,7 +77,7 @@
   "expo-sms": "~13.1.4",
   "expo-speech": "~13.1.7",
   "expo-splash-screen": "~0.30.10",
-  "expo-sqlite": "~15.2.13",
+  "expo-sqlite": "~15.2.14",
   "expo-status-bar": "~2.2.3",
   "expo-store-review": "~8.1.5",
   "expo-symbols": "~0.4.5",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo",
-  "version": "53.0.17",
+  "version": "53.0.19",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -73,9 +73,9 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "0.24.18",
-    "@expo/config": "~11.0.12",
-    "@expo/config-plugins": "~10.1.1",
+    "@expo/cli": "0.24.20",
+    "@expo/config": "~11.0.13",
+    "@expo/config-plugins": "~10.1.2",
     "@expo/fingerprint": "0.13.4",
     "@expo/metro-config": "0.20.17",
     "@expo/vector-icons": "^14.0.0",
@@ -85,7 +85,7 @@
     "expo-file-system": "~18.1.11",
     "expo-font": "~13.3.2",
     "expo-keep-awake": "~14.1.4",
-    "expo-modules-autolinking": "2.1.13",
+    "expo-modules-autolinking": "2.1.14",
     "expo-modules-core": "2.4.2",
     "react-native-edge-to-edge": "1.6.0",
     "whatwg-url-without-unicode": "8.0.0-3"
@@ -119,5 +119,5 @@
       "optional": true
     }
   },
-  "gitHead": "1c4a89b0c0adebb53ef84b4a6ac25864e4652917"
+  "gitHead": "134c147ee4274f9688929ac66cfef950947659d0"
 }