expo-modules-core 57.0.5 → 57.0.7

package/CHANGELOG.md

@@ -10,6 +10,20 @@
 
 ### 💡 Others
 
+## 57.0.7 — 2026-07-22
+
+_This version does not introduce any user-facing changes._
+
+## 57.0.6 — 2026-07-17
+
+### 🎉 New features
+
+- [iOS] `ExpoSwiftUI.IgnoreSafeArea` that ignores the device and container safe area regions. ([#47619](https://github.com/expo/expo/pull/47619) by [@nishan](https://github.com/intergalacticspacehighway))
+
+### 🐛 Bug fixes
+
+- [Android] Fix `canAskAgain` returning `false` for re-requestable permissions in the "Ask every time" state. ([#46683](https://github.com/expo/expo/pull/46683) by [@alanjhughes](https://github.com/alanjhughes))
+
 ## 57.0.5 — 2026-07-15
 
 _This version does not introduce any user-facing changes._
@@ -22,6 +36,8 @@ _This version does not introduce any user-facing changes._
 
 ### 🐛 Bug fixes
 
+- [iOS] Fix SwiftUI-hosted React views corrupting Fabric rendering after unmount: `UIViewHost` now hands SwiftUI a disposable isolation container instead of the React-managed view, so leaked `autoresizingMask`/frame/visibility mutations (including deferred ones from `Menu`/`ContextMenu` teardown) can no longer zero-size or hide unrelated components. ([#47707](https://github.com/expo/expo/pull/47707) by [@cvburgess](https://github.com/cvburgess))
+- [Android] Fix Compose-hosted React Native content (e.g. the `@expo/ui` community `BottomSheet`) keeping a stale size after a rapid resize such as dismissing the software keyboard, leaving bottom-anchored content stranded mid-view. The final shadow node size update could be dropped when its one-shot pre-draw listener fired without a following draw pass; the pending update is now also posted to the view so the latest size always flushes. ([#47778](https://github.com/expo/expo/issues/47778) by [@zayyartun-cgm](https://github.com/zayyartun-cgm)) ([#47810](https://github.com/expo/expo/pull/47810) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
 - [iOS] Fixed a crash when the runtime is reloaded while async function calls are still suspended in their native body. Concurrent functions now decode `this` and the arguments buffer synchronously inside the host call and schedule only converted native values, so no JSI-owned wrappers are destroyed off the JS thread after the runtime is torn down. ([#47716](https://github.com/expo/expo/issues/47716), [#47717](https://github.com/expo/expo/pull/47717) by [@AlirezaHadjar](https://github.com/AlirezaHadjar))
 - [Android] Support `android.graphics.Color` arguments and props on Android below API 26 by adding a `ColorCompat` wrapper, since the class-based `Color` API (`Color.valueOf` and the float accessors) only exists on API 26 and above. ([#47546](https://github.com/expo/expo/issues/47546) by [@anasvemmully](https://github.com/anasvemmully)) ([#47575](https://github.com/expo/expo/pull/47575) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
 - [iOS] Fix a `SIGABRT` crash when unmounting a SwiftUI view tree that still holds a focused field nested inside a container (e.g. an `@expo/ui` `TextField` inside an `HStack` or `LabeledContent` in a `Form`), such as dismissing a modal from a native header button. Resigning the first responder on unmount now recurses through the removed subtree instead of only handling a top-level focusable view. ([#47682](https://github.com/expo/expo/issues/47682) by [@andreavrr](https://github.com/andreavrr)) ([#47709](https://github.com/expo/expo/pull/47709) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))

package/android/build.gradle

@@ -27,7 +27,7 @@ if (shouldIncludeCompose) {
 }
 
 group = 'host.exp.exponent'
-version = '57.0.5'
+version = '57.0.7'
 
 def isExpoModulesCoreTests = {
   Gradle gradle = getGradle()
@@ -94,7 +94,7 @@ android {
   defaultConfig {
     consumerProguardFiles 'proguard-rules.pro'
     versionCode 1
-    versionName "57.0.5"
+    versionName "57.0.7"
     buildConfigField "String", "EXPO_MODULES_CORE_VERSION", "\"${versionName}\""
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
 

package/android/src/main/java/expo/modules/adapters/react/permissions/PermissionsService.kt

@@ -27,6 +27,7 @@ import java.util.Queue
 
 private const val PERMISSIONS_REQUEST: Int = 13
 private const val PREFERENCE_FILENAME = "expo.modules.permissions.asked"
+private const val BLOCKED_PERMISSION_KEY_PREFIX = "blocked:"
 
 open class PermissionsService(val context: Context) : InternalModule, Permissions, LifecycleEventListener {
   private var mActivityProvider: ActivityProvider? = null
@@ -49,6 +50,42 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
     }
   }
 
+  /**
+   * Android can't tell a permanently denied permission apart from a re-askable one ("Ask every time", or a revoked
+   * one-time grant) at query time, so we record it ourselves.
+   */
+  private fun isBlocked(permission: String): Boolean =
+    mAskedPermissionsCache.getBoolean(blockedPermissionKey(permission), false)
+
+  private fun setBlocked(permission: String, blocked: Boolean) {
+    mAskedPermissionsCache.edit(commit = true) {
+      putBoolean(blockedPermissionKey(permission), blocked)
+    }
+  }
+
+  private fun blockedPermissionKey(permission: String): String = "$BLOCKED_PERMISSION_KEY_PREFIX$permission"
+
+  /**
+   * Record whether each permission became permanently denied. A denied result with no rationale to show means the user blocked it.
+   * Anything else clears the flag. This is the only time the denied states are distinguishable,
+   * so we persist the result for later ``getPermissions` calls.
+   */
+  private fun withBlockedTracking(listener: PermissionsResponseListener): PermissionsResponseListener =
+    PermissionsResponseListener { result ->
+      listener.onResult(
+        result.mapValues { (permission, response) ->
+          if (response.status == PermissionsStatus.DENIED) {
+            val blocked = !shouldShowRequestPermissionRationale(permission)
+            setBlocked(permission, blocked)
+            PermissionsResponse(response.status, !blocked)
+          } else {
+            setBlocked(permission, false)
+            response
+          }
+        }
+      )
+    }
+
   override fun getExportedInterfaces(): List<Class<out Any>> = listOf(Permissions::class.java)
 
   @Throws(IllegalStateException::class)
@@ -155,10 +192,10 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
           newListener.onResult(mutableMapOf())
           return
         }
-        askForManifestPermissions(permissionsToAsk, newListener)
+        askForManifestPermissions(permissionsToAsk, withBlockedTracking(newListener))
       }
     } else {
-      askForManifestPermissions(permissions, responseListener)
+      askForManifestPermissions(permissions, withBlockedTracking(responseListener))
     }
   }
 
@@ -213,7 +250,7 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
     return ContextCompat.checkSelfPermission(context, permission)
   }
 
-  private fun canAskAgain(permission: String): Boolean {
+  protected open fun shouldShowRequestPermissionRationale(permission: String): Boolean {
     return mActivityProvider?.currentActivity?.let {
       ActivityCompat.shouldShowRequestPermissionRationale(it, permission)
     } == true
@@ -236,7 +273,7 @@ open class PermissionsService(val context: Context) : InternalModule, Permission
     return PermissionsResponse(
       status,
       if (status == PermissionsStatus.DENIED) {
-        canAskAgain(permission)
+        !isBlocked(permission)
       } else {
         true
       }

package/android/src/main/java/expo/modules/kotlin/views/ShadowNodeProxy.kt

@@ -10,6 +10,7 @@ class ShadowNodeProxy(expoView: ExpoView) {
 
   private var pendingFlush: ((stateWrapper: Any) -> Unit)? = null
   private var preDrawListener: ViewTreeObserver.OnPreDrawListener? = null
+  private val flushRunnable = Runnable { drainPendingFlush() }
 
   // Schedule in predraw listener to avoid early return in re-entrancy
   // We have a proper fix [here](https://github.com/facebook/react-native/pull/56311)
@@ -29,25 +30,37 @@ class ShadowNodeProxy(expoView: ExpoView) {
 
   private fun scheduleFlush(flush: (stateWrapper: Any) -> Unit) {
     pendingFlush = flush
-    val observer = weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive } ?: return
-
-    // Remove the previous attached listener
-    preDrawListener?.let(observer::removeOnPreDrawListener)
-
-    val listener = object : ViewTreeObserver.OnPreDrawListener {
-      override fun onPreDraw(): Boolean {
-        preDrawListener = null
-        // The view is attached while drawing, so this re-fetch returns the same
-        // observer that is dispatching us. removeOnPreDrawListener throws on a dead
-        // observer, hence the isAlive guard.
-        weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive }?.removeOnPreDrawListener(this)
-        val flushNow = pendingFlush
-        pendingFlush = null
-        weakExpoView.get()?.stateWrapper?.let { flushNow?.invoke(it) }
-        return true
+    val view = weakExpoView.get() ?: return
+    val observer = view.viewTreeObserver?.takeIf { it.isAlive }
+
+    if (observer != null) {
+      // Remove the previous attached listener
+      preDrawListener?.let(observer::removeOnPreDrawListener)
+
+      val listener = object : ViewTreeObserver.OnPreDrawListener {
+        override fun onPreDraw(): Boolean {
+          preDrawListener = null
+          // The view is attached while drawing, so this re-fetch returns the same
+          // observer that is dispatching us. removeOnPreDrawListener throws on a dead
+          // observer, hence the isAlive guard.
+          weakExpoView.get()?.viewTreeObserver?.takeIf { it.isAlive }?.removeOnPreDrawListener(this)
+          drainPendingFlush()
+          return true
+        }
       }
+      preDrawListener = listener
+      observer.addOnPreDrawListener(listener)
     }
-    preDrawListener = listener
-    observer.addOnPreDrawListener(listener)
+
+    // Predraw listener do not get called for each keyboard transition event so we add a fallback flush to be called here
+    // https://github.com/expo/expo/issues/47778
+    view.removeCallbacks(flushRunnable)
+    view.post(flushRunnable)
+  }
+
+  private fun drainPendingFlush() {
+    val flushNow = pendingFlush ?: return
+    pendingFlush = null
+    weakExpoView.get()?.stateWrapper?.let { flushNow.invoke(it) }
   }
 }

package/ios/Core/Views/SwiftUI/SwiftUIHostingView.swift

@@ -60,11 +60,6 @@ extension ExpoSwiftUI {
      */
     private let hostingController: UIHostingController<AnyView>
 
-    /**
-     Tracks whether safe area has been configured (can only be set once on mount)
-     */
-    private var hasSafeAreaBeenConfigured = false
-
     /**
      Initializes a SwiftUI hosting view with the given SwiftUI view type.
      */
@@ -121,11 +116,8 @@ extension ExpoSwiftUI {
         log.error("Updating props for \(ContentView.self) has failed: \(error.localizedDescription)")
       }
 
-      if !hasSafeAreaBeenConfigured,
-         let safeAreaProps = props as? SafeAreaControllable,
-         let ignoreSafeArea = safeAreaProps.ignoreSafeArea {
-        hostingController.disableSafeArea(ignoreSafeArea)
-        hasSafeAreaBeenConfigured = true
+      if let safeAreaProps = props as? SafeAreaControllable {
+        hostingController.setSafeAreaRegions(ignoring: safeAreaProps.ignoreSafeArea)
       }
     }
 
@@ -260,45 +252,26 @@ extension ExpoSwiftUI {
 }
 
 extension UIHostingController {
-  func disableSafeArea(_ mode: ExpoSwiftUI.IgnoreSafeArea) {
-    if #available(iOS 16.4, tvOS 16.4, macOS 13.3, *) {
+  /// Applies the `ignoreSafeArea` mode reactively, restoring the default safe area when `nil` so
+  /// clearing the prop re-enables the safe area without an app reload.
+  func setSafeAreaRegions(ignoring mode: ExpoSwiftUI.IgnoreSafeArea?) {
+    // `safeAreaRegions` needs iOS 16.4+; the precompiled xcframework targets 16.0, so no-op below it.
+    guard #available(iOS 16.4, tvOS 16.4, macOS 13.3, *) else {
+      return
+    }
+    var regions: SafeAreaRegions = .all
+    if let mode {
       switch mode {
       case .all:
-        self.safeAreaRegions.remove(.all)
+        regions = []
+      case .container:
+        regions.remove(.container)
       case .keyboard:
-        self.safeAreaRegions.remove(.keyboard)
-      }
-    } else {
-      // For older versions
-      // https://gist.github.com/steipete/da72299613dcc91e8d729e48b4bb582c
-      // https://developer.apple.com/forums/thread/658432
-      guard let viewClass = object_getClass(view) else { return }
-
-      let suffix = mode == .all ? "_IgnoresSafeArea" : "_IgnoresKeyboard"
-      let viewSubclassName = String(cString: class_getName(viewClass)).appending(suffix)
-      if let viewSubclass = NSClassFromString(viewSubclassName) {
-          object_setClass(view, viewSubclass)
-      } else {
-          guard let viewClassNameUtf8 = (viewSubclassName as NSString).utf8String else { return }
-          guard let viewSubclass = objc_allocateClassPair(viewClass, viewClassNameUtf8, 0) else { return }
-
-          if mode == .all,
-             let method = class_getInstanceMethod(UIView.self, #selector(getter: UIView.safeAreaInsets)) {
-              let safeAreaInsets: @convention(block) (AnyObject) -> UIEdgeInsets = { _ in
-                  return .zero
-              }
-              class_addMethod(viewSubclass, #selector(getter: UIView.safeAreaInsets),
-                              imp_implementationWithBlock(safeAreaInsets), method_getTypeEncoding(method))
-          }
-
-          if let method = class_getInstanceMethod(viewClass, NSSelectorFromString("keyboardWillShowWithNotification:")) {
-              let keyboardWillShow: @convention(block) (AnyObject, AnyObject) -> Void = { _, _ in }
-              class_addMethod(viewSubclass, NSSelectorFromString("keyboardWillShowWithNotification:"),
-                              imp_implementationWithBlock(keyboardWillShow), method_getTypeEncoding(method))
-          }
-          objc_registerClassPair(viewSubclass)
-          object_setClass(view, viewSubclass)
-        }
+        regions.remove(.keyboard)
       }
     }
+    if safeAreaRegions != regions {
+      safeAreaRegions = regions
+    }
+  }
 }

package/ios/Core/Views/SwiftUI/SwiftUIViewHost.swift

@@ -13,7 +13,6 @@ extension ExpoSwiftUI {
 
     #if os(macOS)
     func makeNSView(context: Context) -> NSView {
-      context.coordinator.originalAutoresizingMask = view.autoresizingMask
       return view
     }
 
@@ -23,8 +22,17 @@ extension ExpoSwiftUI {
     #endif
 
     func makeUIView(context: Context) -> UIView {
-      context.coordinator.originalAutoresizingMask = view.autoresizingMask
+      #if os(macOS)
       return view
+      #else
+      // SwiftUI mutates the view it hosts (autoresizingMask, frame, visibility), sometimes
+      // asynchronously after teardown, corrupting unmounted or recycled React views.
+      // Hand it a disposable container instead. Fixes expo/expo#47706; supersedes the #40604 mitigation.
+      let container = ReactViewIsolationContainer()
+      container.hostedView = view
+      container.addSubview(view)
+      return container
+      #endif
     }
 
     func updateUIView(_ uiView: UIView, context: Context) {
@@ -32,11 +40,7 @@ extension ExpoSwiftUI {
     }
 
     static func dismantleUIView(_ uiView: UIView, coordinator: Coordinator) {
-      // https://github.com/expo/expo/issues/40604
-      // UIViewRepresentable attaches autoresizingMask w+h to the hosted UIView
-      // This causes issues for RN views when they are recycled.
-      // So we restore the original autoresizingMask to avoid issues.
-      uiView.autoresizingMask = coordinator.originalAutoresizingMask
+      // Nothing to restore — SwiftUI only ever touched the container.
     }
 
     func makeCoordinator() -> Coordinator {
@@ -44,7 +48,6 @@ extension ExpoSwiftUI {
     }
 
     class Coordinator {
-      var originalAutoresizingMask: UIView.AutoresizingMask = []
       init() {}
     }
 
@@ -63,5 +66,24 @@ extension ExpoSwiftUI {
     }
   }
 
+  #if !os(macOS)
+  /**
+   Disposable UIView handed to SwiftUI in place of the React-managed view —
+   see `UIViewHost.makeUIView`.
+   */
+  private final class ReactViewIsolationContainer: UIView {
+    weak var hostedView: UIView?
+
+    override func layoutSubviews() {
+      super.layoutSubviews()
+      // Ignore transient zero bounds (initial layout, teardown) — never propagate them.
+      guard let hostedView, hostedView.superview === self, !bounds.isEmpty else {
+        return
+      }
+      if hostedView.frame != bounds {
+        hostedView.frame = bounds
+      }
+    }
+  }
+  #endif
 }
-

package/ios/Core/Views/SwiftUI/SwiftUIViewProps.swift

@@ -7,6 +7,7 @@ internal let GLOBAL_EVENT_NAME = "onGlobalEvent"
 extension ExpoSwiftUI {
   public enum IgnoreSafeArea: String, Enumerable {
     case all
+    case container
     case keyboard
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "57.0.5",
+  "version": "57.0.7",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@expo/expo-modules-macros-plugin": "0.6.1",
-    "expo-modules-jsi": "~57.0.3",
+    "expo-modules-jsi": "~57.0.4",
     "invariant": "^2.2.4"
   },
   "peerDependencies": {
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "b9503d06b8e130abfca1bc16f671dbefb41ad709",
+  "gitHead": "a4789f1e53353f4929b0baddcfe5a7c622b99c71",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",