Как Android рисует просмотры

Попробуйте способ создания композиций.
Jetpack Compose — рекомендуемый набор инструментов для создания пользовательского интерфейса для Android. Узнайте о фазах Compose.
Этапы составления →

Фреймворк Android запрашивает у Activity отрисовку макета, когда Activity получает фокус. Процедура отрисовки обрабатывается фреймворком Android, но Activity должна предоставить корневой узел своей иерархии макетов.

Фреймворк Android отрисовывает корневой узел макета, а также измеряет и отрисовывает дерево макета. Он отрисовывает, обходя дерево и отображая каждый View , который пересекает недопустимую область. Каждый ViewGroup отвечает за запрос на отрисовку каждого из своих дочерних элементов с помощью метода draw() , а каждый View отвечает за отрисовку самого себя. Поскольку дерево обходится в порядке предварительного обхода, фреймворк отрисовывает родительские элементы раньше — другими словами, позади — их дочерних элементов, а соседние элементы отрисовываются в том порядке, в котором они появляются в дереве.

Фреймворк Android отрисовывает макет в два этапа: этап измерения и этап компоновки. Этап измерения выполняется в measure(int, int) и представляет собой нисходящий обход дерева View . Каждое View передает спецификации размеров вниз по дереву в процессе рекурсии. В конце этапа измерения каждое View сохраняет свои измерения. Второй этап выполняется в layout(int, int, int, int) и также является нисходящим. На этом этапе каждый родительский элемент отвечает за позиционирование всех своих дочерних элементов, используя размеры, вычисленные на этапе измерения.

Два этапа процесса компоновки более подробно описаны в следующих разделах.

Инициировать проход измерения

Когда метод measure() объекта View возвращает управление, установите значения методов getMeasuredWidth() и getMeasuredHeight() , а также значения для всех потомков объекта View . Измеренные значения ширины и высоты объекта View должны соответствовать ограничениям, наложенным родительскими объектами View . Это помогает гарантировать, что по завершении измерения все родительские объекты примут измерения всех своих дочерних объектов.

Родительский компонент View может вызывать measure() несколько раз для своих дочерних компонентов. Например, родительский компонент может измерить размеры дочерних компонентов один раз, не указав конкретные параметры, чтобы определить их предпочтительные размеры. Если сумма размеров дочерних компонентов без ограничений слишком велика или слишком мала, родительский компонент может снова вызвать measure() со значениями, которые ограничивают размеры дочерних компонентов.

Для передачи размеров в процессе измерения используются два класса. Класс ViewGroup.LayoutParams используется для передачи объектами View предпочтительных размеров и положений. Базовый класс ViewGroup.LayoutParams описывает предпочтительную ширину и высоту объекта View . Для каждого параметра можно указать одно из следующих значений:

  • Точный размер.
  • MATCH_PARENT означает, что предпочтительный размер View равен размеру его родительского элемента за вычетом отступов.
  • WRAP_CONTENT означает, что предпочтительный размер View должен быть достаточным только для того, чтобы вместить его содержимое, плюс отступы.

Для разных подклассов ViewGroup существуют подклассы ViewGroup.LayoutParams . Например, у RelativeLayout есть свой собственный подкласс ViewGroup.LayoutParams , который позволяет центрировать дочерние объекты View по горизонтали и вертикали.

Объекты MeasureSpec используются для передачи требований вниз по дереву от родителя к потомку. Объект MeasureSpec может находиться в одном из трех режимов:

  • UNSPECIFIED : родительский элемент использует это для определения целевых размеров дочернего элемента View . Например, LinearLayout может вызвать measure() для своего дочернего элемента с высотой, установленной в UNSPECIFIED , и шириной, EXACTLY 240, чтобы узнать, какой высоты должен быть дочерний View при ширине 240 пикселей.
  • EXACTLY : родитель использует это, чтобы задать ребенку точный размер. Ребенок должен использовать этот размер и гарантировать, что все его потомки будут соответствовать этому размеру.
  • AT MOST : родитель использует это для установления максимального размера для ребенка. Ребенок должен гарантировать, что он сам и все его потомки укладываются в этот размер.

Инициировать этап компоновки.

Для инициализации макета вызовите requestLayout() . Этот метод обычно вызывается самим элементом View , когда он считает, что больше не может поместиться в своих границах.

Реализуйте собственную логику измерения и компоновки.

Если вы хотите реализовать собственную логику измерения или компоновки, переопределите методы, в которых эта логика реализована: onMeasure(int, int) и onLayout(boolean, int, int, int, int) . Эти методы вызываются методами measure(int, int) и layout(int, int, int, int) соответственно. Не пытайтесь переопределить методы measure(int, int) или layout(int, int) — оба эти метода являются final , поэтому их нельзя переопределить.

Следующий пример демонстрирует, как это сделать в классе `SplitLayout` из примера приложения WindowManager . Если SplitLayout имеет два или более дочерних представления, и на экране есть складка, то он размещает два дочерних представления по обе стороны от складки. Следующий пример показывает вариант использования переопределения размеров и компоновки, но для производственной среды используйте SlidingPaneLayout , если вам нужно такое поведение.

Котлин 

/**
 * An example of split-layout for two views, separated by a display
 * feature that goes across the window. When both start and end views are
 * added, it checks whether there are display features that separate the area
 * in two—such as a fold or hinge—and places them side-by-side or
 * top-bottom.
 */
class SplitLayout : FrameLayout {
   private var windowLayoutInfo: WindowLayoutInfo? = null
   private var startViewId = 0
   private var endViewId = 0

   private var lastWidthMeasureSpec: Int = 0
   private var lastHeightMeasureSpec: Int = 0

   ...

   fun updateWindowLayout(windowLayoutInfo: WindowLayoutInfo) {
      this.windowLayoutInfo = windowLayoutInfo
      requestLayout()
   }

   override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
      val startView = findStartView()
      val endView = findEndView()
      val splitPositions = splitViewPositions(startView, endView)

      if (startView != null && endView != null && splitPositions != null) {
            val startPosition = splitPositions[0]
            val startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY)
            val startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY)
            startView.measure(startWidthSpec, startHeightSpec)
            startView.layout(
               startPosition.left, startPosition.top, startPosition.right,
               startPosition.bottom
            )

            val endPosition = splitPositions[1]
            val endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY)
            val endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY)
            endView.measure(endWidthSpec, endHeightSpec)
            endView.layout(
               endPosition.left, endPosition.top, endPosition.right,
               endPosition.bottom
            )
      } else {
            super.onLayout(changed, left, top, right, bottom)
      }
   }

   /**
   * Gets the position of the split for this view.
   * @return A rect that defines of split, or {@code null} if there is no split.
   */
   private fun splitViewPositions(startView: View?, endView: View?): Array? {
      if (windowLayoutInfo == null || startView == null || endView == null) {
            return null
      }

      // Calculate the area for view's content with padding.
      val paddedWidth = width - paddingLeft - paddingRight
      val paddedHeight = height - paddingTop - paddingBottom

      windowLayoutInfo?.displayFeatures
            ?.firstOrNull { feature -> isValidFoldFeature(feature) }
            ?.let { feature ->
               getFeaturePositionInViewRect(feature, this)?.let {
                  if (feature.bounds.left == 0) { // Horizontal layout.
                        val topRect = Rect(
                           paddingLeft, paddingTop,
                           paddingLeft + paddedWidth, it.top
                        )
                        val bottomRect = Rect(
                           paddingLeft, it.bottom,
                           paddingLeft + paddedWidth, paddingTop + paddedHeight
                        )

                        if (measureAndCheckMinSize(topRect, startView) &&
                           measureAndCheckMinSize(bottomRect, endView)
                        ) {
                           return arrayOf(topRect, bottomRect)
                        }
                  } else if (feature.bounds.top == 0) { // Vertical layout.
                        val leftRect = Rect(
                           paddingLeft, paddingTop,
                           it.left, paddingTop + paddedHeight
                        )
                        val rightRect = Rect(
                           it.right, paddingTop,
                           paddingLeft + paddedWidth, paddingTop + paddedHeight
                        )

                        if (measureAndCheckMinSize(leftRect, startView) &&
                           measureAndCheckMinSize(rightRect, endView)
                        ) {
                           return arrayOf(leftRect, rightRect)
                        }
                  }
               }
            }

      // You previously tried to fit the children and measure them. Since they
      // don't fit, measure again to update the stored values.
      measure(lastWidthMeasureSpec, lastHeightMeasureSpec)
      return null
   }

   override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
      super.onMeasure(widthMeasureSpec, heightMeasureSpec)
      lastWidthMeasureSpec = widthMeasureSpec
      lastHeightMeasureSpec = heightMeasureSpec
   }

   /**
   * Measures a child view and sees if it fits in the provided rect.
   * This method calls [View.measure] on the child view, which updates its
   * stored values for measured width and height. If the view ends up with
   * different values, measure again.
   */
   private fun measureAndCheckMinSize(rect: Rect, childView: View): Boolean {
      val widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST)
      val heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST)
      childView.measure(widthSpec, heightSpec)
      return childView.measuredWidthAndState and MEASURED_STATE_TOO_SMALL == 0 &&
               childView.measuredHeightAndState and MEASURED_STATE_TOO_SMALL == 0
   }

   private fun isValidFoldFeature(displayFeature: DisplayFeature) =
      (displayFeature as? FoldingFeature)?.let { feature ->
            getFeaturePositionInViewRect(feature, this) != null
      } ?: false
}

Java 

/**
* An example of split-layout for two views, separated by a display feature
* that goes across the window. When both start and end views are added, it checks
* whether there are display features that separate the area in two—such as
* fold or hinge—and places them side-by-side or top-bottom.
*/
public class SplitLayout extends FrameLayout {
   @Nullable
   private WindowLayoutInfo windowLayoutInfo = null;
   private int startViewId = 0;
   private int endViewId = 0;

   private int lastWidthMeasureSpec = 0;
   private int lastHeightMeasureSpec = 0;

   ...

   void updateWindowLayout(WindowLayoutInfo windowLayoutInfo) {
      this.windowLayoutInfo = windowLayoutInfo;
      requestLayout();
   }

   @Override
   protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
      @Nullable
      View startView = findStartView();
      @Nullable
      View endView = findEndView();
      @Nullable
      List splitPositions = splitViewPositions(startView, endView);

      if (startView != null && endView != null && splitPositions != null) {
            Rect startPosition = splitPositions.get(0);
            int startWidthSpec = MeasureSpec.makeMeasureSpec(startPosition.width(), EXACTLY);
            int startHeightSpec = MeasureSpec.makeMeasureSpec(startPosition.height(), EXACTLY);
            startView.measure(startWidthSpec, startHeightSpec);
            startView.layout(
                  startPosition.left,
                  startPosition.top,
                  startPosition.right,
                  startPosition.bottom
            );

            Rect endPosition = splitPositions.get(1);
            int endWidthSpec = MeasureSpec.makeMeasureSpec(endPosition.width(), EXACTLY);
            int endHeightSpec = MeasureSpec.makeMeasureSpec(endPosition.height(), EXACTLY);
            startView.measure(endWidthSpec, endHeightSpec);
            startView.layout(
                  endPosition.left,
                  endPosition.top,
                  endPosition.right,
                  endPosition.bottom
            );
      } else {
            super.onLayout(changed, left, top, right, bottom);
      }
   }

   /**
   * Gets the position of the split for this view.
   * @return A rect that defines of split, or {@code null} if there is no split.
   */
   @Nullable
   private List splitViewPositions(@Nullable View startView, @Nullable View endView) {
      if (windowLayoutInfo == null || startView == null || endView == null) {
            return null;
      }

      int paddedWidth = getWidth() - getPaddingLeft() - getPaddingRight();
      int paddedHeight = getHeight() - getPaddingTop() - getPaddingBottom();

      List displayFeatures = windowLayoutInfo.getDisplayFeatures();

      @Nullable
      DisplayFeature feature = displayFeatures
               .stream()
               .filter(item ->
                  isValidFoldFeature(item)
               )
               .findFirst()
               .orElse(null);

      if (feature != null) {
            Rect position = SampleToolsKt.getFeaturePositionInViewRect(feature, this, true);
            Rect featureBounds = feature.getBounds();
            if (featureBounds.left == 0) { // Horizontal layout.
               Rect topRect = new Rect(
                        getPaddingLeft(),
                        getPaddingTop(),
                        getPaddingLeft() + paddedWidth,
                        position.top
               );
               Rect bottomRect = new Rect(
                        getPaddingLeft(),
                        position.bottom,
                        getPaddingLeft() + paddedWidth,
                        getPaddingTop() + paddedHeight
               );
               if (measureAndCheckMinSize(topRect, startView) &&
                        measureAndCheckMinSize(bottomRect, endView)) {
                  ArrayList rects = new ArrayList();
                  rects.add(topRect);
                  rects.add(bottomRect);
                  return rects;
               }
            } else if (featureBounds.top == 0) { // Vertical layout.
               Rect leftRect = new Rect(
                        getPaddingLeft(),
                        getPaddingTop(),
                        position.left,
                        getPaddingTop() + paddedHeight
               );
               Rect rightRect = new Rect(
                        position.right,
                        getPaddingTop(),
                        getPaddingLeft() + paddedWidth,
                        getPaddingTop() + paddedHeight
               );
               if (measureAndCheckMinSize(leftRect, startView) &&
                        measureAndCheckMinSize(rightRect, endView)) {
                  ArrayList rects = new ArrayList();
                  rects.add(leftRect);
                  rects.add(rightRect);
                  return rects;
               }
            }
      }

      // You previously tried to fit the children and measure them. Since
      // they don't fit, measure again to update the stored values.
      measure(lastWidthMeasureSpec, lastHeightMeasureSpec);
      return null;
   }

   @Override
   protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
      super.onMeasure(widthMeasureSpec, heightMeasureSpec);
      lastWidthMeasureSpec = widthMeasureSpec;
      lastHeightMeasureSpec = heightMeasureSpec;
   }

   /**
   * Measures a child view and sees if it fits in the provided rect.
   * This method calls [View.measure] on the child view, which updates
   * its stored values for measured width and height. If the view ends up with
   * different values, measure again.
   */
   private boolean measureAndCheckMinSize(Rect rect, View childView) {
      int widthSpec = MeasureSpec.makeMeasureSpec(rect.width(), AT_MOST);
      int heightSpec = MeasureSpec.makeMeasureSpec(rect.height(), AT_MOST);
      childView.measure(widthSpec, heightSpec);
      return (childView.getMeasuredWidthAndState() & MEASURED_STATE_TOO_SMALL) == 0 &&
               (childView.getMeasuredHeightAndState() & MEASURED_STATE_TOO_SMALL) == 0;
   }

   private boolean isValidFoldFeature(DisplayFeature displayFeature) {
      if (displayFeature instanceof FoldingFeature) {
            return SampleToolsKt.getFeaturePositionInViewRect(displayFeature, this, true) != null;
      } else {
            return false;
      }
   }
}