expo 53.0.17 → 53.0.18

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.18'
 
 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.18"
     consumerProguardFiles("proguard-rules.pro")
   }
   testOptions {

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

@@ -29,7 +29,11 @@ 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.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import java.lang.reflect.Field
 import java.lang.reflect.Method
@@ -63,10 +67,17 @@ 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 [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
 
@@ -129,6 +140,7 @@ class ReactActivityDelegateWrapper(
 
       activity.lifecycleScope.launch(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 +184,75 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onResume() {
-    if (shouldEmitPendingResume) {
-      return
-    }
-    delegate.onResume()
-    reactActivityLifecycleListeners.forEach { listener ->
-      listener.onResume(activity)
+    activity.lifecycleScope.launch {
+      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.
+    activity.lifecycleScope.launch {
+      if (!loadAppReady.isCompleted) {
+        loadAppReady.completeExceptionally(CancellationException("Activity paused before app loaded"))
+      }
+      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)
+    activity.lifecycleScope.launch {
+      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.
+    // Note: use our `coroutineScope` for onDestroy here
+    // because the lifecycleScope destroyed before the executions.
+    applicationCoroutineScope.launch {
+      if (!loadAppReady.isCompleted) {
+        // Cancel loadAppReady so any waiting coroutines are notified
+        loadAppReady.completeExceptionally(CancellationException("Activity destroyed before app loaded"))
+      }
+      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()
-      } catch (e: Exception) {
-        Log.e(TAG, "Exception occurred during onDestroy with delayed app loading", e)
       }
-    } else {
-      delegate.onDestroy()
     }
   }
 
@@ -252,20 +270,26 @@ 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)
+    activity.lifecycleScope.launch {
+      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@launch 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 +298,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 +309,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 +320,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 +331,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 +342,24 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onWindowFocusChanged(hasFocus: Boolean) {
-    delegate.onWindowFocusChanged(hasFocus)
+    activity.lifecycleScope.launch {
+      loadAppReady.await()
+      delegate.onWindowFocusChanged(hasFocus)
+    }
   }
 
   override fun requestPermissions(permissions: Array<out String>?, requestCode: Int, listener: PermissionListener?) {
-    delegate.requestPermissions(permissions, requestCode, listener)
+    activity.lifecycleScope.launch {
+      loadAppReady.await()
+      delegate.requestPermissions(permissions, requestCode, listener)
+    }
   }
 
   override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>?, grantResults: IntArray?) {
-    delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    activity.lifecycleScope.launch {
+      loadAppReady.await()
+      delegate.onRequestPermissionsResult(requestCode, permissions, grantResults)
+    }
   }
 
   override fun getContext(): Context {
@@ -338,7 +383,10 @@ class ReactActivityDelegateWrapper(
   }
 
   override fun onConfigurationChanged(newConfig: Configuration?) {
-    delegate.onConfigurationChanged(newConfig)
+    activity.lifecycleScope.launch {
+      loadAppReady.await()
+      delegate.onConfigurationChanged(newConfig)
+    }
   }
 
   //endregion
@@ -401,10 +449,6 @@ class ReactActivityDelegateWrapper(
       reactActivityLifecycleListeners.forEach { listener ->
         listener.onContentChanged(activity)
       }
-      if (shouldEmitPendingResume) {
-        shouldEmitPendingResume = false
-        onResume()
-      }
       return
     }
 
@@ -412,17 +456,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 +470,15 @@ class ReactActivityDelegateWrapper(
     }
   }
 
+  /**
+   * 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() }

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.18",
   "description": "The Expo SDK",
   "main": "src/Expo.ts",
   "module": "src/Expo.ts",
@@ -73,7 +73,7 @@
   "homepage": "https://github.com/expo/expo/tree/main/packages/expo",
   "dependencies": {
     "@babel/runtime": "^7.20.0",
-    "@expo/cli": "0.24.18",
+    "@expo/cli": "0.24.19",
     "@expo/config": "~11.0.12",
     "@expo/config-plugins": "~10.1.1",
     "@expo/fingerprint": "0.13.4",
@@ -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": "03398e0a2fa4f1bceebbf3a73c7bfb956a3ed18b"
 }