Support sizing of Compose hosting views on iOS

compose/ui/ui/src/iosMain/kotlin/androidx/compose/ui/scene/ComposeContainer.ios.kt

@@ -37,9 +37,14 @@ import androidx.compose.ui.uikit.density
 import androidx.compose.ui.uikit.embedSubview
 import androidx.compose.ui.uikit.utils.CMPKeyValueObserver
 import androidx.compose.ui.uikit.utils.CMPUIWindowSceneUtils
+import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.Density
+import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.toIntSize
 import androidx.compose.ui.util.fastForEachReversed
 import androidx.compose.ui.viewinterop.UIKitInteropAction
 import androidx.compose.ui.viewinterop.UIKitInteropTransaction
@@ -54,8 +59,13 @@ import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 import kotlinx.cinterop.CPointed
 import kotlinx.cinterop.CPointer
+import kotlinx.cinterop.CValue
+import kotlinx.cinterop.useContents
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
+import platform.CoreGraphics.CGFloat
+import platform.CoreGraphics.CGSize
+import platform.CoreGraphics.CGSizeMake
 import platform.Foundation.NSKeyValueObservingOptionNew
 import platform.Foundation.addObserver
 import platform.Foundation.removeObserver
@@ -65,6 +75,7 @@ import platform.UIKit.UIResponder
 import platform.UIKit.UIUserInterfaceLayoutDirection
 import platform.UIKit.UIUserInterfaceStyle
 import platform.UIKit.UIViewController
+import platform.UIKit.UIViewNoIntrinsicMetric
 import platform.UIKit.UIWindow
 import platform.UIKit.UIWindowScene
 
@@ -81,7 +92,10 @@ internal class ComposeContainer(
     val view = ComposeContainerView(
         transparentForTouches = false,
         useOpaqueConfiguration = configuration.opaque,
-    )
+    ).apply {
+        onSizeThatFits = { composeSceneSizeSynchronizer.onSizeThatFitsRequest(it) }
+        onIntrinsicContentSize = { composeSceneSizeSynchronizer.preferredCGSize }
+    }
 
     private var mediator: ComposeSceneMediator? = null
     private val windowContext = PlatformWindowContext()
@@ -108,6 +122,14 @@ internal class ComposeContainer(
         getTopLeftOffsetInWindow = { IntOffset.Zero }, //full screen
         endEdgePanGestureBehavior = configuration.endEdgePanGestureBehavior
     )
+
+    private val composeSceneSizeSynchronizer: ComposeSceneSizeSynchronizer =
+        ComposeSceneSizeSynchronizer(
+            view = view,
+            composeSceneSize = { mediator?.measureSceneSize(it) },
+            invalidateComposeSceneContainerSize = view::invalidateIntrinsicContentSize
+        )
+
     val hasInteropViews: Boolean get() = mediator?.hasInteropViews ?: false
 
     /*
@@ -248,6 +270,10 @@ internal class ComposeContainer(
             }
         }
 
+        mediator?.setOnLayoutCompletedListener {
+            composeSceneSizeSynchronizer.onComposeLayoutCompleted()
+        }
+
         activeStateListener = SceneActiveStateListener(
             getScene = ::windowScene
         ) { isSceneActive ->
@@ -276,6 +302,7 @@ internal class ComposeContainer(
         navigationEventInput.onDidMoveToWindow(null, view)
         architectureComponentsOwner.navigationEventDispatcher.removeInput(navigationEventInput)
 
+        mediator?.setOnLayoutCompletedListener(null)
         mediator = null
 
         activeStateListener?.dispose()
@@ -479,3 +506,128 @@ private class SceneGeometryObserver(
         onGeometryChanged()
     }
 }
+
+/**
+ * Synchronizes UIKit/SwiftUI sizing proposals (`sizeThatFits`) with the preferred size produced by
+ * the Compose scene under the corresponding constraints.
+ *
+ * - UIKit/SwiftUI proposes constraints via `sizeThatFits`
+ * - Compose produces a preferred size under those constraints after its layout completes
+ * - if the preferred size changes, we invalidate the *hosting* view intrinsic size so
+ *   UIKit/SwiftUI can re-run layout with the updated information
+ */
+internal class ComposeSceneSizeSynchronizer(
+    private val view: ComposeContainerView,
+    private val composeSceneSize: (Constraints) -> IntSize?,
+    private var invalidateComposeSceneContainerSize: () -> Unit = {},
+) {
+
+    private var latestSizeThatFitsConstraints: Constraints? = null
+    /**
+     * Latest constraints proposed by UIKit/SwiftUI through `sizeThatFits`.
+     */
+    private var lastMeasuredConstraints: Constraints? = null
+    /**
+     * Preferred size measured by Compose for [lastMeasuredConstraints].
+     */
+    private var preferredSize: IntSize? = null
+    /**
+     * Last size returned from `sizeThatFits`.
+     *
+     * Used as a temporary intrinsic size fallback until Compose measures and caches a real
+     * preferred size for the latest external proposal.
+     */
+    private var lastSizeThatFitsResult: CValue<CGSize>? = null
+
+    private val hasPreferredSize: Boolean get() = preferredSize != null
+
+    val preferredCGSize: CValue<CGSize>?
+        get() = preferredSize?.toCGSize(view.density) ?: lastSizeThatFitsResult
+
+    fun onSizeThatFitsRequest(size: CValue<CGSize>): CValue<CGSize> {
+        val constraints = size.useContents {
+            Constraints(
+                maxWidth = width.toConstraintValue(view.density),
+                maxHeight = height.toConstraintValue(view.density)
+            )
+        }
+
+        // `sizeThatFits` requests come from UIKit/SwiftUI and should win over stale internal state.
+        if (latestSizeThatFitsConstraints != constraints) {
+            latestSizeThatFitsConstraints = constraints
+        }
+
+        val result = preferredSizeForConstraints(constraints) ?: fallbackSizeThatFits(size)
+        lastSizeThatFitsResult = result
+
+        return result
+    }
+
+    private fun preferredSizeForConstraints(constraints: Constraints): CValue<CGSize>? {
+        if (!hasPreferredSize) return null
+
+        // Fast path: if Compose already measured preferred size for the exact same constraints,
+        // return it directly.
+        if (lastMeasuredConstraints == constraints) {
+            return preferredCGSize
+        }
+
+        val didUpdatePreferredSize = measureAndCachePreferredSize(constraints) ?: return null
+
+        if (didUpdatePreferredSize) {
+            invalidateComposeSceneContainerSize()
+        }
+
+        return preferredCGSize
+    }
+
+    fun onComposeLayoutCompleted() {
+        val constraints = latestSizeThatFitsConstraints ?: return
+        val didUpdatePreferredSize = measureAndCachePreferredSize(constraints) ?: return
+
+        if (didUpdatePreferredSize) {
+            invalidateComposeSceneContainerSize()
+        }
+    }
+
+    private fun measureAndCachePreferredSize(constraints: Constraints): Boolean? {
+        val preferredSize = composeSceneSize(constraints) ?: return null
+
+        lastMeasuredConstraints = constraints
+        val preferredSizeUpdated = preferredSize != this.preferredSize
+        if (preferredSizeUpdated) {
+            this.preferredSize = preferredSize
+        }
+        return preferredSizeUpdated
+    }
+
+    private fun fallbackSizeThatFits(size: CValue<CGSize>): CValue<CGSize> {
+        val viewSizeThatFits by lazy { view.superSizeThatFits(size) }
+
+        val width = if (size.useContents { width } == UIViewNoIntrinsicMetric) {
+            viewSizeThatFits.useContents { width }
+        } else {
+            size.useContents { width }
+        }
+        val height = if (size.useContents { height } == UIViewNoIntrinsicMetric) {
+            viewSizeThatFits.useContents { height }
+        } else {
+            size.useContents { height }
+        }
+
+        return with(view.density) {
+            DpSize(width.dp, height.dp).toSize().toIntSize().toCGSize(this)
+        }
+    }
+
+    private fun CGFloat.toConstraintValue(density: Density): Int {
+        if (this == UIViewNoIntrinsicMetric) return Constraints.Infinity
+        val px = with(density) { dp.roundToPx() }
+        if (px >= 0 || px == Constraints.Infinity) return px
+        throw IllegalArgumentException("Invalid constraint size: $this")
+    }
+}
+
+private fun IntSize.toCGSize(density: Density) = with(density) {
+    CGSizeMake(width.toDp().value.toDouble(), height.toDp().value.toDouble())
+}

compose/ui/ui/src/iosMain/kotlin/androidx/compose/ui/scene/ComposeHostingView.ios.kt

@@ -50,11 +50,18 @@ internal class ComposeHostingView(
         content = content,
         coroutineContext = coroutineContext,
         lifecycleDelegate = lifecycleDelegate
-    )
+    ).also {
+        it.view.setIntrinsicContentSizeInvalidationHandler(this) {
+            invalidateIntrinsicContentSize()
+        }
+    }
 
     // Used for testing
     val rootRedrawer: MetalRedrawer? get() = container.view.redrawer
     fun hasInvalidations(): Boolean = container.hasInvalidations()
+    // Invoked when this hosting view invalidates its intrinsic size.
+    // Kept as an internal test hook to assert SwiftUI/UIKit relayout signaling.
+    var onIntrinsicContentSizeInvalidated: (() -> Unit)? = null
 
     init {
         addSubview(container.view)
@@ -70,6 +77,11 @@ internal class ComposeHostingView(
         return container.view.intrinsicContentSize
     }
 
+    override fun invalidateIntrinsicContentSize() {
+        super.invalidateIntrinsicContentSize()
+        onIntrinsicContentSizeInvalidated?.invoke()
+    }
+
     override fun layoutSubviews() {
         super.layoutSubviews()
 
@@ -79,13 +91,13 @@ internal class ComposeHostingView(
         if (initialSize == null ||
             initialSize == bounds.dpSize() ||
             container.hasInteropViews) {
-            container.view.setFrame(bounds)
+            synchronizeComposeViewFrame()
             return
         }
 
         val scope = container.nestedCoroutineScope()
         if (!scope.isActive) {
-            container.view.setFrame(bounds)
+            synchronizeComposeViewFrame()
             return
         }
 
@@ -100,7 +112,7 @@ internal class ComposeHostingView(
             if (actualSize != null && actualSize != bounds.dpSize() && !container.hasInteropViews) {
                 animateSizeTransition(initialSize = initialSize)
             } else {
-                container.view.setFrame(bounds)
+                synchronizeComposeViewFrame()
             }
         }
     }
@@ -127,10 +139,15 @@ internal class ComposeHostingView(
         container.disposeComposeScene()
     }
 
+    private fun synchronizeComposeViewFrame() {
+        container.view.setFrame(bounds)
+    }
+
     private var isAnimating = false
+
     private fun animateSizeTransition(initialSize: DpSize) {
         if (isAnimating) {
-            container.view.setFrame(bounds)
+            synchronizeComposeViewFrame()
             return
         }
         isAnimating = true
@@ -157,7 +174,7 @@ internal class ComposeHostingView(
             animations()
         }
         container.view.clipsToBounds = false
-        container.view.setFrame(bounds)
+        synchronizeComposeViewFrame()
     }
 }
 
@@ -177,4 +194,4 @@ internal fun UIView.transitionProgress(initialSize: DpSize): Float {
         else -> 1f
     }
     return progress.coerceIn(0.0f, 1.0f)
-}
+}

compose/ui/ui/src/iosMain/kotlin/androidx/compose/ui/scene/ComposeHostingViewController.ios.kt

@@ -53,11 +53,18 @@ internal class ComposeHostingViewController(
         content = content,
         coroutineContext = coroutineContext,
         lifecycleDelegate = lifecycleDelegate
-    )
+    ).also {
+        it.view.setIntrinsicContentSizeInvalidationHandler(this) {
+            onIntrinsicContentSizeInvalidated?.invoke()
+        }
+    }
 
     // Used for testing
     val rootRedrawer: MetalRedrawer? get() = container.view.redrawer
     fun hasInvalidations(): Boolean = container.hasInvalidations()
+    // Invoked when this hosting view invalidates its intrinsic size.
+    // Kept as an internal test hook to assert SwiftUI/UIKit relayout signaling.
+    var onIntrinsicContentSizeInvalidated: (() -> Unit)? = null
 
     @Suppress("DEPRECATION")
     override fun preferredStatusBarStyle(): UIStatusBarStyle =

compose/ui/ui/src/iosMain/kotlin/androidx/compose/ui/scene/ComposeSceneMediator.ios.kt

@@ -23,6 +23,7 @@ import androidx.compose.runtime.State
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
+import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.InternalComposeUiApi
 import androidx.compose.ui.draganddrop.UIKitDragAndDropManager
 import androidx.compose.ui.geometry.Offset
@@ -74,6 +75,7 @@ import androidx.compose.ui.input.pointer.isAltPressed
 import androidx.compose.ui.input.pointer.isCtrlPressed
 import androidx.compose.ui.input.pointer.isMetaPressed
 import androidx.compose.ui.input.pointer.isShiftPressed
+import androidx.compose.ui.unit.Constraints
 import androidx.compose.ui.unit.Density
 import androidx.compose.ui.unit.DpOffset
 import androidx.compose.ui.unit.IntRect
@@ -206,8 +208,8 @@ internal class ComposeSceneMediator(
     ) -> ComposeScene,
 ) {
     private var onPreviewKeyEvent: (KeyEvent) -> Boolean = { false }
-
     private var onKeyEvent: (KeyEvent) -> Boolean = { false }
+    private var onLayoutCompleted: (() -> Unit) = {}
     private var animateKeyboardOffsetChanges by mutableStateOf(false)
     private var platformScreenReader = object : PlatformScreenReader {
         override var isActive by mutableStateOf(false)
@@ -276,7 +278,7 @@ internal class ComposeSceneMediator(
      * Density of the hosting UIKit screen.
      *
      * This value is intentionally separate from [composeSceneDensity] so we can support setting
-     * composeSceneDensity without regressions.
+     * [composeSceneDensity] without regressions.
      */
     val screenDensity: Density get() = _overlayView.density
 
@@ -639,8 +641,23 @@ internal class ComposeSceneMediator(
     private var lastRenderTime = CACurrentMediaTime().toNanoSeconds()
     fun render(canvas: Canvas, nanoTime: Long) {
         lastRenderTime = nanoTime
-        with(sceneRenderingScope) {
-            scene.render(frameRecomposer, canvas, nanoTime)
+        scene.render(canvas, nanoTime)
+    }
+
+    /**
+     * Renders the current content on [canvas]: advances the host [frameRecomposer] by one frame,
+     * then runs the scene's measure/layout and draw phases. [nanoTime] is the frame time used to
+     * drive all animations in the content (and any other code using [withFrameNanos]).
+     */
+    private fun ComposeScene.render(canvas: Canvas, nanoTime: Long) {
+        sceneRenderingScope.postponingSceneInvalidations {
+            frameRecomposer.performFrame(nanoTime)
+            measureAndLayout()
+            onLayoutCompleted()
+            draw(canvas)
+        }
+        if (hasInvalidations()) {
+            redrawer.setNeedsRedraw()
         }
     }
 
@@ -759,6 +776,16 @@ internal class ComposeSceneMediator(
         this.onKeyEvent = onKeyEvent ?: { false }
     }
 
+    /**
+     * Sets the single callback invoked after the scene measure/layout phase during rendering.
+     * Passing `null` clears the current callback.
+     */
+    fun setOnLayoutCompletedListener(listener: (() -> Unit)?) {
+        onLayoutCompleted = listener ?: {}
+    }
+
+    fun measureSceneSize(constraints: Constraints): IntSize = scene.measureContent(constraints)
+
     /**
      * Converts [UIPress] objects to [KeyEvent] and dispatches them to the appropriate handlers.
      * @param presses a [Set] of [UIPress] objects. Erasure happens due to K/N not supporting Obj-C lightweight generics.