Jak Android generuje wyświetlenia

Wypróbuj sposób tworzenia wiadomości
Jetpack Compose to zalecany zestaw narzędzi interfejsu na Androida. Więcej informacji o etapach tworzenia wiadomości

Platforma Androida prosi Activity o rysowanie układu, gdy obiekt Activity jest zaznaczony. Platforma Android obsługuje procedurę rysowania, ale Activity musi podać węzeł główny swojej hierarchii układu.

Platforma Androida pobiera węzeł główny układu, dokonuje pomiarów i rysuje drzewo układu. Wyświetla się przez przeszukiwanie drzewa i renderowanie każdego węzła View, który przecina nieprawidłowy region. Każdy element ViewGroup odpowiada za żądanie narysowania wszystkich swoich elementów podrzędnych za pomocą metody draw(), a każdy element View odpowiada za narysowanie samego siebie. Ponieważ drzewo jest przemierzane w kolejności wstępnej, framework rysuje elementy nadrzędne przed elementami podrzędnymi (czyli za nimi) oraz elementy siostrzane w kolejności, w jakiej występują w drzewie.

Platforma Android rysuje układ w 2 etapach: pomiar i układ. Framework wykonuje pomiar w measure(int, int) i przechodzi od góry do dołu po drzewie View. Każdy element View przesuwa specyfikacje wymiarów w dół drzewa podczas rekurencji. Na końcu zaliczenia testu każdy View zapisuje swoje pomiary. Drugi przejazd frameworku jest wykonywany w trybie layout(int, int, int, int)i także od góry do dołu. W tym procesie każdy wydawca nadrzędny odpowiada za umieszczenie wszystkich swoich elementów podrzędnych przy użyciu rozmiarów obliczonych w ramach pomiarów.

Dwa etapy procesu tworzenia układu opisujemy bardziej szczegółowo w kolejnych sekcjach.

Rozpocznij procedurę zaliczania pomiarów

Gdy metoda measure() obiektu View zwraca wartość, ustaw wartości getMeasuredWidth() i getMeasuredHeight(), a także wartości wszystkich potomków obiektu View. Zmierzone wartości szerokości i wysokości obiektu View muszą być zgodne z ograniczeniami narzuconymi przez nadrzędne obiektu View. Dzięki temu na koniec okresu pomiarowego wszyscy rodzice zaakceptują wszystkie pomiary swoich dzieci.

Rodzic View może wywołać measure() więcej niż raz w przypadku swoich dzieci. Na przykład element nadrzędny może raz mierzyć elementy podrzędne z nieokreślonymi wymiarami, aby określić preferowane rozmiary. Jeśli suma nieograniczonych rozmiarów podrzędnych jest zbyt duża lub zbyt mała, element nadrzędny może ponownie wywołać funkcję measure(), podając wartości, które ograniczają rozmiary podrzędne.

Przekaz pomiaru używa 2 klas do przekazywania wymiarów. Klasa ViewGroup.LayoutParams informuje obiekty View o ich preferowanych rozmiarach i pozycjach. Podstawowa klasa ViewGroup.LayoutParams określa preferowaną szerokość i wysokość klasy View. W przypadku każdego wymiaru możesz określić jedną z tych opcji:

  • Dokładny wymiar.
  • MATCH_PARENT, co oznacza, że preferowany rozmiar dla View to rozmiar jego elementu nadrzędnego pomniejszony o odstęp.
  • WRAP_CONTENT, co oznacza, że preferowany rozmiar View jest wystarczająco duży, aby pomieścić jego zawartość, oraz odstęp.

Istnieją podklasy ViewGroup.LayoutParams dla różnych podklas ViewGroup. Na przykład RelativeLayout ma własną podklasę klasy ViewGroup.LayoutParams, która umożliwia wyśrodkowanie obiektów podrzędnych View w poziomie i w pionie.

Obiekty MeasureSpec są używane do przenoszenia wymagań z drzewa nadrzędnego na element podrzędny. MeasureSpec może mieć jeden z 3 trybów:

  • UNSPECIFIED: element nadrzędny używa tego parametru do określania docelowej wymiary podrzędnego View. Na przykład LinearLayout może wywołać measure() na swoim dziecku, ustawiając wysokość na UNSPECIFIED, a szerokość na EXACTLY 240, aby dowiedzieć się, jak wysoki chce być View, biorąc pod uwagę szerokość 240 pikseli.
  • EXACTLY: rodzic używa tego, aby narzucić dokładny rozmiar na element podrzędny. Dziecko musi używać tego rozmiaru i gwarantować, że wszystkie jego potomki mieszczą się w tym rozmiarze.
  • AT MOST: element nadrzędny używa tego atrybutu do narzucenia maksymalnego rozmiaru elementowi podrzędnemu. Podmiot podrzędny musi zagwarantować, że on sam i wszystkie jego potomkowie mieszczą się w tym rozmiarze.

Rozpoczęcie przechodzenia przez układ

Aby zainicjować układ, wywołaj requestLayout(). Ta metoda jest zwykle wywoływana przez View, gdy uważa, że nie mieści się już w swoich granicach.

Implementowanie niestandardowych pomiarów i logiki układu

Jeśli chcesz wdrożyć niestandardowy pomiar lub logikę układu, zastąp metody implementacji tej logiki: onMeasure(int, int) i onLayout(boolean, int, int, int, int). Te metody są wywoływane odpowiednio przez measure(int, int)layout(int, int, int, int). Nie próbuj zastąpić metod measure(int, int) ani layout(int, int), ponieważ obie są metodami final, co oznacza, że nie można ich zastąpić.

Poniższy przykład pokazuje, jak to zrobić w klasie `SplitLayout` z aplikacji WindowManager. Jeśli widok SplitLayout ma co najmniej 2 podrzędne widoki, a ekran jest złożony, widoki te są umieszczane po obu stronach zagięcia. Poniższy przykład pokazuje przypadek użycia, w którym zastąpiono pomiar i rozmieszczenie, ale w produkcji użyj parametru SlidingPaneLayout, jeśli chcesz uzyskać takie działanie.

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