flutter · auto-submit · Nov 27, 2023 · Nov 9, 2023 · Nov 15, 2023 · Nov 15, 2023
diff --git a/lib/ui/platform_dispatcher.dart b/lib/ui/platform_dispatcher.dart
@@ -1479,7 +1479,7 @@ class _ViewConfiguration {
   /// The pixel density of the output surface.
   final double devicePixelRatio;
 
-  /// The size requested for the view in logical pixels.
+  /// The size requested for the view in physical pixels.
   Size get physicalSize => _viewConfiguration.size; 
   Size get physicalSize => _viewConfiguration.size; 
   final Size size;
 
   /// The number of physical pixels on each side of the display rectangle into
@@ -1981,6 +1981,113 @@ class ViewPadding {
 )
 typedef WindowPadding = ViewPadding;
 
+/// Immutable layout constraints for [FlutterView]s.
+///
+/// Similar to [BoxConstraints], a [Size] respects a [ViewConstraints] if, and
+/// only if, all of the following relations hold:
+///
+/// * [minWidth] <= [Size.width] <= [maxWidth]
+/// * [minHeight] <= [Size.height] <= [maxHeight]
+///
+/// The constraints themselves must satisfy these relations:
+///
+/// * 0.0 <= [minWidth] <= [maxWidth] <= [double.infinity]
+/// * 0.0 <= [minHeight] <= [maxHeight] <= [double.infinity]
+///
+/// For each constraint, [double.infinity] is a legal value.
+///
+/// For a generic class that represents these kind of constraints, see the
+/// [BoxConstraints] class.
+class ViewConstraints {
+  /// Creates view constraints with the given constraints.
+  const ViewConstraints({
+    this.minWidth = 0.0,
+    this.maxWidth = double.infinity,
+    this.minHeight = 0.0,
+    this.maxHeight = double.infinity,
+  });
+
+  /// Creates view constraints that is respected only by the given size.
+  ViewConstraints.tight(Size size)
+    : minWidth = size.width,
+      maxWidth = size.width,
+      minHeight = size.height,
+      maxHeight = size.height;
+
+  /// The minimum width that satisfies the constraints.
+  final double minWidth;
+
+  /// The maximum width that satisfies the constraints.
+  ///
+  /// Might be [double.infinity].
+  final double maxWidth;
+
+  /// The minimum height that satisfies the constraints.
+  final double minHeight;
+
+  /// The maximum height that satisfies the constraints.
+  ///
+  /// Might be [double.infinity].
+  final double maxHeight;
+
+  /// Whether the given size satisfies the constraints.
+  bool isSatisfiedBy(Size size) {
+    return (minWidth <= size.width) && (size.width <= maxWidth) &&
+           (minHeight <= size.height) && (size.height <= maxHeight);
+  }
+
+  /// Whether there is exactly one size that satisfies the constraints.
+  bool get isTight => minWidth >= maxWidth && minHeight >= maxHeight;
+
+  /// Scales each constraint parameter by the inverse of the given factor.
+  ViewConstraints operator/(double factor) {
+    return ViewConstraints(
+      minWidth: minWidth / factor,
+      maxWidth: maxWidth / factor,
+      minHeight: minHeight / factor,
+      maxHeight: maxHeight / factor,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) {
+      return true;
+    }
+    if (other.runtimeType != runtimeType) {
+      return false;
+    }
+    return other is ViewConstraints
+        && other.minWidth == minWidth
+        && other.maxWidth == maxWidth
+        && other.minHeight == minHeight
+        && other.maxHeight == maxHeight;
+  }
+
+  @override
+  int get hashCode => Object.hash(minWidth, maxWidth, minHeight, maxHeight);
+
+  @override
+  String toString() {
+    if (minWidth == double.infinity && minHeight == double.infinity) {
+      return 'ViewConstraints(biggest)';
+    }
+    if (minWidth == 0 && maxWidth == double.infinity &&
+        minHeight == 0 && maxHeight == double.infinity) {
+      return 'ViewConstraints(unconstrained)';
+    }
+    String describe(double min, double max, String dim) {
+      if (min == max) {
+        return '$dim=${min.toStringAsFixed(1)}';
+      }
+      return '${min.toStringAsFixed(1)}<=$dim<=${max.toStringAsFixed(1)}';
+    }
+    final String width = describe(minWidth, maxWidth, 'w');
+    final String height = describe(minHeight, maxHeight, 'h');
+    return 'ViewConstraints($width, $height)';
+  }
+}
+
 /// Area of the display that may be obstructed by a hardware feature.
 ///
 /// This is populated only on Android.

diff --git a/lib/ui/window.dart b/lib/ui/window.dart
@@ -138,8 +138,42 @@ class FlutterView {
   ///    The value here is equal to the value exposed on [display].
   double get devicePixelRatio => _viewConfiguration.devicePixelRatio;
 
-  /// The dimensions of the rectangle into which the scene rendered in this view
-  /// will be drawn on the screen, in physical pixels.
+  /// The sizing constraints in physical pixels for this view.
+  ///
+  /// The view can take on any [Size] that fulfills these constraints. These
+  /// constraints are typically used by an UI framework as the input for its
+  /// layout algorithm to determine an approrpiate size for the view. To size
+  /// the view, the selected size must be provided to the [render] method and it
+  /// must satisfy the constraints.
+  ///
+  /// When this changes, [PlatformDispatcher.onMetricsChanged] is called.
+  ///
+  /// At startup, the constraints for the view may not be known before Dart code
+  /// runs. If this value is observed early in the application lifecycle, it may
+  /// report constraints with all dimensions set to zero.
+  ///
+  /// This value does not take into account any on-screen keyboards or other
+  /// system UI. If the constraints are tight, the [padding] and [viewInsets]
+  /// properties provide information about how much of each side of the view may
+  /// be obscured by system UI. If the constraints are loose, this information
+  /// is not known upfront.
+  ///
+  /// See also:
+  ///
+  ///  * [physicalSize], which returns the current size of the view.
+  // TODO(goderbauer): Wire this up so embedders can configure it. This will
+  //   also require to message the size provided to the render call back to the
+  //   embedder.
+  ViewConstraints get physicalConstraints => ViewConstraints.tight(physicalSize);
+
+  /// The current dimensions of the rectangle as last reported by the platform
+  /// into which scenes rendered in this view are drawn.
+  ///
+  /// If the view is configured with loose [physicalConstraints] this value
+  /// may be outdated by a few frames as it only updates when the size chosen
+  /// for a frame (as provided to the [render] method) is processed by the
+  /// platform. Because of this, [physicalConstraints] should be used instead of
+  /// this value as the root input to the layout algorithm of UI frameworks.
   ///
   /// When this changes, [PlatformDispatcher.onMetricsChanged] is called. When
   /// using the Flutter framework, using [MediaQuery.of] to obtain the size (via
@@ -324,25 +358,32 @@ class FlutterView {
   /// then obtain a [Scene] object, which you can display to the user via this
   /// [render] function.
   ///
+  /// If the view is configured with loose [physicalConstraints] (i.e.
+  /// [ViewConstraints.isTight] returns false) a `size` satisfying those
+  /// constraints must be provided. This method does not check that the provided
+  /// `size` actually meets the constraints (this should be done in a higher
+  /// level), but an illegal `size` may result in undefined rendering behavior.
+  /// If no `size` is provided, [physicalSize] is used instead.
+  ///
   /// See also:
   ///
   /// * [SchedulerBinding], the Flutter framework class which manages the
   ///   scheduling of frames.
   /// * [RendererBinding], the Flutter framework class which manages layout and
   ///   painting.
-  void render(Scene scene) {
+  void render(Scene scene, {Size? size}) {
     // Duplicated calls or calls outside of onBeginFrame/onDrawFrame (indicated
     // by _renderedViews being null) are ignored. See _renderedViews.
     // TODO(dkwingsmt): We should change this skip into an assertion.
     // https://github.com/flutter/flutter/issues/137073
     final bool validRender = platformDispatcher._renderedViews?.add(this) ?? false;
     if (validRender) {
-      _render(viewId, scene as _NativeScene);
+      _render(viewId, scene as _NativeScene, size?.width ?? physicalSize.width, size?.height ?? physicalSize.height);
     }
   }
 
-  @Native<Void Function(Int64, Pointer<Void>)>(symbol: 'PlatformConfigurationNativeApi::Render')
-  external static void _render(int viewId, _NativeScene scene);
+  @Native<Void Function(Int64, Pointer<Void>, Double, Double)>(symbol: 'PlatformConfigurationNativeApi::Render')
+  external static void _render(int viewId, _NativeScene scene, double width, double height);
 
   /// Change the retained semantics data about this [FlutterView].
   ///

diff --git a/lib/ui/window/platform_configuration.cc b/lib/ui/window/platform_configuration.cc
@@ -449,10 +449,13 @@ void PlatformConfiguration::CompletePlatformMessageResponse(
   response->Complete(std::make_unique<fml::DataMapping>(std::move(data)));
 }
 
-void PlatformConfigurationNativeApi::Render(int64_t view_id, Scene* scene) {
+void PlatformConfigurationNativeApi::Render(int64_t view_id,
+                                            Scene* scene,
+                                            double width,
+                                            double height) {
   UIDartState::ThrowIfUIOperationsProhibited();
-  UIDartState::Current()->platform_configuration()->client()->Render(view_id,
-                                                                     scene);
+  UIDartState::Current()->platform_configuration()->client()->Render(
+      view_id, scene, width, height);
 }
 
 void PlatformConfigurationNativeApi::SetNeedsReportTimings(bool value) {

diff --git a/lib/ui/window/platform_configuration.h b/lib/ui/window/platform_configuration.h
@@ -69,7 +69,10 @@ class PlatformConfigurationClient {
   /// @brief      Updates the client's rendering on the GPU with the newly
   ///             provided Scene.
   ///
-  virtual void Render(int64_t view_id, Scene* scene) = 0;
+  virtual void Render(int64_t view_id,
+                      Scene* scene,
+                      double width,
+                      double height) = 0;
 
   //--------------------------------------------------------------------------
   /// @brief      Receives an updated semantics tree from the Framework.
@@ -557,7 +560,10 @@ class PlatformConfigurationNativeApi {
 
   static void ScheduleFrame();
 
-  static void Render(int64_t view_id, Scene* scene);
+  static void Render(int64_t view_id,
+                     Scene* scene,
+                     double width,
+                     double height);
 
   static void UpdateSemantics(SemanticsUpdate* update);
 

diff --git a/lib/web_ui/lib/platform_dispatcher.dart b/lib/web_ui/lib/platform_dispatcher.dart
@@ -288,6 +288,25 @@ abstract class ViewPadding {
   }
 }
 
+abstract class ViewConstraints {
+  const factory ViewConstraints({
+    double minWidth,
+    double maxWidth,
+    double minHeight,
+    double maxHeight,
+  }) = engine.ViewConstraints;
+
+  factory ViewConstraints.tight(Size size) = engine.ViewConstraints.tight;
+
+  double get minWidth;
+  double get maxWidth;
+  double get minHeight;
+  double get maxHeight;
+  bool isSatisfiedBy(Size size);
+  bool get isTight;
+  ViewConstraints operator/(double factor);
+}
+
 @Deprecated(
   'Use ViewPadding instead. '
   'This feature was deprecated after v3.8.0-14.0.pre.',

diff --git a/lib/web_ui/lib/src/engine/window.dart b/lib/web_ui/lib/src/engine/window.dart
@@ -96,8 +96,9 @@ base class EngineFlutterView implements ui.FlutterView {
   }
 
   @override
-  void render(ui.Scene scene) {
+  void render(ui.Scene scene, {ui.Size? size}) {
     assert(!isDisposed, 'Trying to render a disposed EngineFlutterView.');
+    // TODO(goderbauer): Respect the provided size when "physicalConstraints" are not always tight. See TODO on "physicalConstraints".
     platformDispatcher.render(scene, this);
   }
 
@@ -121,6 +122,10 @@ base class EngineFlutterView implements ui.FlutterView {
   late final PlatformViewMessageHandler platformViewMessageHandler =
       PlatformViewMessageHandler(platformViewsContainer: dom.platformViewsHost);
 
+  // TODO(goderbauer): Provide API to configure constraints. See also TODO in "render".
+  @override
+  ViewConstraints get physicalConstraints => ViewConstraints.tight(physicalSize);
+
   @override
   ui.Size get physicalSize {
     if (_physicalSize == null) {
@@ -649,3 +654,84 @@ class ViewPadding implements ui.ViewPadding {
   @override
   final double bottom;
 }
+
+class ViewConstraints implements ui.ViewConstraints {
+  const ViewConstraints({
+    this.minWidth = 0.0,
+    this.maxWidth = double.infinity,
+    this.minHeight = 0.0,
+    this.maxHeight = double.infinity,
+  });
+
+  ViewConstraints.tight(ui.Size size)
+    : minWidth = size.width,
+      maxWidth = size.width,
+      minHeight = size.height,
+      maxHeight = size.height;
+
+  @override
+  final double minWidth;
+  @override
+  final double maxWidth;
+  @override
+  final double minHeight;
+  @override
+  final double maxHeight;
+
+  @override
+  bool isSatisfiedBy(ui.Size size) {
+    return (minWidth <= size.width) && (size.width <= maxWidth) &&
+           (minHeight <= size.height) && (size.height <= maxHeight);
+  }
+
+  @override
+  bool get isTight => minWidth >= maxWidth && minHeight >= maxHeight;
+
+  @override
+  ViewConstraints operator/(double factor) {
+    return ViewConstraints(
+      minWidth: minWidth / factor,
+      maxWidth: maxWidth / factor,
+      minHeight: minHeight / factor,
+      maxHeight: maxHeight / factor,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) {
+      return true;
+    }
+    if (other.runtimeType != runtimeType) {
+      return false;
+    }
+    return other is ViewConstraints
+        && other.minWidth == minWidth
+        && other.maxWidth == maxWidth
+        && other.minHeight == minHeight
+        && other.maxHeight == maxHeight;
+  }
+
+  @override
+  int get hashCode => Object.hash(minWidth, maxWidth, minHeight, maxHeight);
+
+  @override
+  String toString() {
+    if (minWidth == double.infinity && minHeight == double.infinity) {
+      return 'ViewConstraints(biggest)';
+    }
+    if (minWidth == 0 && maxWidth == double.infinity &&
+        minHeight == 0 && maxHeight == double.infinity) {
+      return 'ViewConstraints(unconstrained)';
+    }
+    String describe(double min, double max, String dim) {
+      if (min == max) {
+        return '$dim=${min.toStringAsFixed(1)}';
+      }
+      return '${min.toStringAsFixed(1)}<=$dim<=${max.toStringAsFixed(1)}';
+    }
+    final String width = describe(minWidth, maxWidth, 'w');
+    final String height = describe(minHeight, maxHeight, 'h');
+    return 'ViewConstraints($width, $height)';
+  }
+}
diff --git a/lib/web_ui/lib/window.dart b/lib/web_ui/lib/window.dart
@@ -15,6 +15,7 @@ abstract class FlutterView {
   PlatformDispatcher get platformDispatcher;
   int get viewId;
   double get devicePixelRatio;
+  ViewConstraints get physicalConstraints;
   Size get physicalSize;
   ViewPadding get viewInsets;
   ViewPadding get viewPadding;
@@ -23,7 +24,7 @@ abstract class FlutterView {
   GestureSettings get gestureSettings;
   List<DisplayFeature> get displayFeatures;
   Display get display;
-  void render(Scene scene) => platformDispatcher.render(scene, this);
+  void render(Scene scene, {Size? size});
   void updateSemantics(SemanticsUpdate update) => platformDispatcher.updateSemantics(update);
 }