expo-modules-core 56.0.22 → 56.0.24

package/CHANGELOG.md

@@ -10,6 +10,17 @@
 
 ### 💡 Others
 
+## 56.0.24 — 2026-08-17
+
+_This version does not introduce any user-facing changes._
+
+## 56.0.23 — 2026-08-06
+
+### 🐛 Bug fixes
+
+- [iOS] Fixed the tap that closes a SwiftUI menu also pressing the React Native view underneath it. ([#48419](https://github.com/expo/expo/issues/48419) by [@bohdanstefaniuk](https://github.com/bohdanstefaniuk)) ([#48463](https://github.com/expo/expo/pull/48463) by [@intergalacticspacehighway](https://github.com/intergalacticspacehighway))
+- [Android] Fixed hosted Compose views missing layout after reattachment or in-place configuration changes. ([#48370](https://github.com/expo/expo/issues/48370) by [@lujjjh](https://github.com/lujjjh))
+
 ## 56.0.22 — 2026-07-23
 
 ### 🎉 New features

package/android/build.gradle

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

package/android/src/compose/expo/modules/kotlin/views/ExpoComposeView.kt

@@ -2,6 +2,7 @@ package expo.modules.kotlin.views
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.content.res.Configuration
 import android.util.Log
 import android.view.View
 import android.view.ViewGroup
@@ -113,6 +114,15 @@ abstract class ExpoComposeView<T : ComposeProps>(
     }
   }
 
+  override fun dispatchConfigurationChanged(newConfig: Configuration) {
+    super.dispatchConfigurationChanged(newConfig)
+    // React Native owns this view's bounds and may not schedule another Android layout pass
+    // when a configuration change leaves its Yoga layout unchanged.
+    if (withHostingView && isAttachedToWindow && isLaidOut) {
+      requestLayout()
+    }
+  }
+
   /**
    * Validates that this non-hosting Compose view has a valid Compose parent.
    *
@@ -193,6 +203,15 @@ abstract class ExpoComposeView<T : ComposeProps>(
     if (withHostingView) {
       clipChildren = false
       clipToPadding = false
+      addOnAttachStateChangeListener(
+        OnAttachAfterDetachmentListener(
+          onAttachAfterDetachment = {
+            // Restore the Android layout pass after a real detach. The listener deliberately
+            // ignores the first attach and React Native's same-loop reparenting.
+            requestLayout()
+          }
+        )
+      )
       addComposeView()
     } else {
       this.visibility = GONE

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

@@ -214,6 +214,14 @@ extension ExpoSwiftUI {
     public override func didMoveToWindow() {
       super.didMoveToWindow()
 
+      #if os(iOS)
+      if let window {
+        // SwiftUI content can open a menu, and UIKit passes the tap that closes it through to
+        // React Native underneath. The gate stops that tap from reaching the view below.
+        SystemMenuTouchGate.install(in: window)
+      }
+      #endif
+
       if window != nil, let parentController = reactViewController() {
         #if !os(macOS)
         if parentController as? UINavigationController == nil && parentController as? UITabBarController == nil {

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

@@ -0,0 +1,127 @@
+// Copyright 2015-present 650 Industries. All rights reserved.
+
+#if os(iOS)
+// Also brings in the subclass header, required to set `state` from the touch callbacks
+// and to call `ignore(_:for:)` on React Native's touch handler.
+import UIKit.UIGestureRecognizerSubclass
+
+/**
+  We create a custom gesture recognizer to stop React Root listening to touches when user taps background while Menu is opened.
+  Menu when opened attaches a container view `_UIContextMenuContainerView` to the window.
+  On tapping it, React Root's `RCTSurfaceTouchHandler` also listens to the touch and causes Pressables to fire onPress.
+ */
+internal final class SystemMenuTouchGate: UIGestureRecognizer {
+  init() {
+    super.init(target: nil, action: nil)
+    // Both default to true. Never hold a touch back, and never let React Native's handler see a
+    // reason to cancel: it calls `_cancelTouches` for any outside recognizer that cancels in view.
+    delaysTouchesEnded = false
+    cancelsTouchesInView = false
+  }
+
+  // MARK: - Detecting an open menu
+
+  /**
+   The one view UIKit adds to the window for a presented context menu.
+   */
+  static func isContextMenuContainerClassName(_ className: String) -> Bool {
+    return className == "_UI".appending("ContextMenuContainerView")
+  }
+
+  /**
+    Consider Menu to be open when the container is present, still accepts interaction, and is modal.
+    UIKit turns `isUserInteractionEnabled` off the moment dismissal commits, so taps made during
+    the dismiss animation pass through to the app again. `accessibilityViewIsModal` is how UIKit
+    marks the container as blocking the content behind it — a semantic signal beside the class name.
+   */
+  static func isOpenContextMenuContainer(
+    className: String,
+    isUserInteractionEnabled: Bool,
+    accessibilityViewIsModal: Bool
+  ) -> Bool {
+    return isUserInteractionEnabled && accessibilityViewIsModal && isContextMenuContainerClassName(className)
+  }
+
+  static func isContextMenuContainer(_ view: UIView) -> Bool {
+    return isOpenContextMenuContainer(
+      className: NSStringFromClass(type(of: view)),
+      isUserInteractionEnabled: view.isUserInteractionEnabled,
+      accessibilityViewIsModal: view.accessibilityViewIsModal
+    )
+  }
+
+  /**
+   UIKit adds the container as a direct subview of the window, above the app's content, so only the
+   window's own subviews are worth checking. Anything deeper belongs to the app itself.
+   */
+  static func isShowingContextMenu(
+    in window: UIWindow,
+    isContainer: @MainActor (UIView) -> Bool = SystemMenuTouchGate.isContextMenuContainer
+  ) -> Bool {
+    for subview in window.subviews where isContainer(subview) {
+      return true
+    }
+    return false
+  }
+
+  // MARK: - Cancelling React Native's touches
+
+  /**
+   Matched by name so that this file needs no React Native headers.
+   */
+  static func isSurfaceTouchHandlerClassName(_ className: String) -> Bool {
+    return className == "RCTSurfaceTouchHandler"
+  }
+
+  static func isSurfaceTouchHandler(_ recognizer: UIGestureRecognizer) -> Bool {
+    return isSurfaceTouchHandlerClassName(NSStringFromClass(type(of: recognizer)))
+  }
+
+  /**
+   React Native's touch handlers along the touched view's superview chain.
+   */
+  static func surfaceTouchHandlers(
+    above view: UIView?,
+    isSurfaceTouchHandler: @MainActor (UIGestureRecognizer) -> Bool = SystemMenuTouchGate.isSurfaceTouchHandler
+  ) -> [UIGestureRecognizer] {
+    var handlers: [UIGestureRecognizer] = []
+    var current = view
+    while let view = current {
+      for recognizer in view.gestureRecognizers ?? [] where isSurfaceTouchHandler(recognizer) {
+        handlers.append(recognizer)
+      }
+      current = view.superview
+    }
+    return handlers
+  }
+
+  // MARK: - Installing
+
+  /**
+   Adds one gate to the window. The window owns it for as long as it lives, and the gate stays
+   inert until a menu is actually open, so there is nothing to tear down per host.
+   */
+  static func install(in window: UIWindow) {
+    let isInstalled = window.gestureRecognizers?.contains { $0 is SystemMenuTouchGate } ?? false
+    guard !isInstalled else {
+      return
+    }
+    window.addGestureRecognizer(SystemMenuTouchGate())
+  }
+
+  // MARK: - UIGestureRecognizer
+
+  override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent) {
+    super.touchesBegan(touches, with: event)
+
+    if let window = view as? UIWindow, Self.isShowingContextMenu(in: window) {
+      for touch in touches {
+        for handler in Self.surfaceTouchHandlers(above: touch.view) {
+          handler.ignore(touch, for: event)
+        }
+      }
+    }
+    state = .failed
+  }
+}
+#endif

package/ios/Utilities/SceneGeometry.swift

@@ -0,0 +1,85 @@
+// Copyright 2026-present 650 Industries. All rights reserved.
+
+#if os(iOS) || os(tvOS)
+
+import UIKit
+
+/**
+ Geometry lookups that start from the view asking the question, because iOS 27 makes iPhone apps
+ freely resizable. Neither `UIScreen.main` nor the first key window in any connected scene describes
+ the space a given view has, since either can belong to a differently sized scene.
+ */
+public enum SceneGeometry {
+  public static func windowScene(for view: UIView? = nil) -> UIWindowScene? {
+    if let scene = view?.window?.windowScene {
+      return scene
+    }
+    return foregroundScene() ?? windowScenes().first
+  }
+
+  /// Deliberately strict, for callers deciding whether to attach a window to a scene at all.
+  public static func foregroundActiveScene() -> UIWindowScene? {
+    return windowScenes().first { $0.activationState == .foregroundActive }
+  }
+
+  /// Nil when no scene is on screen, so callers don't present UI into a background scene.
+  public static func foregroundScene() -> UIWindowScene? {
+    let scenes = windowScenes()
+    return scenes.first { $0.activationState == .foregroundActive }
+      ?? scenes.first { $0.activationState == .foregroundInactive }
+  }
+
+  private static func windowScenes() -> [UIWindowScene] {
+    return UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+  }
+
+  public static func keyWindow(for view: UIView? = nil) -> UIWindow? {
+    guard let scene = windowScene(for: view) else {
+      return nil
+    }
+    return scene.windows.first { $0.isKeyWindow } ?? scene.windows.first
+  }
+
+  public static func bounds(for view: UIView? = nil) -> CGRect {
+    return (view?.window ?? keyWindow(for: view))?.bounds ?? .zero
+  }
+
+  public static func safeAreaSize(for view: UIView? = nil) -> CGSize {
+    guard let window = view?.window ?? keyWindow(for: view) else {
+      return .zero
+    }
+    let safeArea = window.safeAreaLayoutGuide.layoutFrame.size
+    if safeArea.width > 0 && safeArea.height > 0 {
+      return safeArea
+    }
+    return window.bounds.size
+  }
+
+  /// Never cache the result. Scale can differ per scene.
+  public static func displayScale(for view: UIView? = nil) -> CGFloat {
+    return resolveDisplayScale(candidates: [
+      view?.traitCollection.displayScale,
+      windowScene(for: view)?.traitCollection.displayScale,
+      UITraitCollection.current.displayScale
+    ])
+  }
+
+  /// Returns the first positive candidate. `UITraitCollection` reports an unspecified scale as 0.
+  internal static func resolveDisplayScale(candidates: [CGFloat?]) -> CGFloat {
+    for case let candidate? in candidates where candidate > 0 {
+      return candidate
+    }
+    return 1
+  }
+}
+
+#if os(iOS)
+public extension SceneGeometry {
+  /// Reads `effectiveGeometry` because `UIWindowScene.interfaceOrientation` is deprecated as of iOS 26.
+  static func interfaceOrientation(for view: UIView? = nil) -> UIInterfaceOrientation {
+    return windowScene(for: view)?.effectiveGeometry.interfaceOrientation ?? .unknown
+  }
+}
+#endif
+
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-modules-core",
-  "version": "56.0.22",
+  "version": "56.0.24",
   "description": "The core of Expo Modules architecture",
   "main": "src/index.ts",
   "types": "build/index.d.ts",
@@ -66,7 +66,7 @@
     "@types/invariant": "^2.2.33",
     "expo-module-scripts": "56.0.3"
   },
-  "gitHead": "60c9da71e15060aa859a7a6e85f4b14062b761f4",
+  "gitHead": "39f9dc47fb5ddd099a2533dd0ff24be7126a1ed0",
   "scripts": {
     "build": "expo-module build",
     "clean": "expo-module clean",