Как Android отрисовывает представления

Попробуйте Compose
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.

Kotlin

/**
 * 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;
      }
   }
}