Wie Android Aufrufe generiert

Compose ausprobieren
Jetpack Compose ist das empfohlene UI-Toolkit für Android. Informationen zu den Compose-Phasen
Compose-Phasen →

Das Android-Framework fordert ein Activity auf, ihr Layout zu zeichnen, wenn das Activity den Fokus erhält. Das Android-Framework übernimmt den Zeichenvorgang, aber die Activity muss den Stammknoten ihrer Layout-Hierarchie bereitstellen.

Das Android-Framework zeichnet den Stammknoten des Layouts und misst und zeichnet den Layout-Baum. Dazu durchläuft es den Baum und rendert jede View, die sich mit der ungültigen Region überschneidet. Jede ViewGroup ist dafür verantwortlich, dass jedes ihrer untergeordneten Elemente mit der draw() Methode gezeichnet wird, und jede View ist dafür verantwortlich, sich selbst zu zeichnen. Da der Baum in der Reihenfolge der Präordnung durchlaufen wird, zeichnet das Framework übergeordnete Elemente vor – mit anderen Worten hinter – ihren untergeordneten Elementen und zeichnet gleichgeordnete Elemente in der Reihenfolge, in der sie im Baum angezeigt werden.

Das Android-Framework zeichnet das Layout in einem zweistufigen Prozess: einer Messphase und einer Layoutphase. Das Framework führt die Messphase in measure(int, int) aus und durchläuft den View-Baum von oben nach unten. Jede View überträgt während der Rekursion Dimensionsangaben nach unten im Baum. Am Ende der Messphase speichert jede View ihre Messungen. Das Framework führt die zweite Phase in layout(int, int, int, int) aus und durchläuft den Baum ebenfalls von oben nach unten. In dieser Phase ist jedes übergeordnete Element dafür verantwortlich, alle untergeordneten Elemente anhand der in der Messphase berechneten Größen zu positionieren.

Die beiden Phasen des Layoutprozesses werden in den folgenden Abschnitten genauer beschrieben.

Messphase starten

Wenn die Methode measure() eines View-Objekts zurückkehrt, legen Sie die Werte für getMeasuredWidth() und getMeasuredHeight() sowie für alle untergeordneten Elemente des View-Objekts fest. Die gemessenen Werte für Breite und Höhe eines View-Objekts müssen die Einschränkungen berücksichtigen, die von den übergeordneten Elementen des View-Objekts auferlegt werden. So wird sichergestellt, dass am Ende der Messphase alle übergeordneten Elemente alle Messungen ihrer untergeordneten Elemente akzeptieren.

Ein übergeordnetes View kann measure() mehrmals für seine untergeordneten Elemente aufrufen. So kann das übergeordnete Element die untergeordneten Elemente einmal mit nicht angegebenen Dimensionen messen, um ihre bevorzugten Größen zu ermitteln. Wenn die Summe der uneingeschränkten Größen der untergeordneten Elemente zu groß oder zu klein ist, kann das übergeordnete Element measure() noch einmal mit Werten aufrufen, die die Größen der untergeordneten Elemente einschränken.

In der Messphase werden zwei Klassen verwendet, um Dimensionen zu kommunizieren. Die ViewGroup.LayoutParams Klasse teilt mit, wie View Objekte ihre bevorzugten Größen und Positionen mitteilen. Die Basis ViewGroup.LayoutParams Klasse beschreibt die bevorzugte Breite und Höhe der View. Für jede Dimension kann eine der folgenden Angaben gemacht werden:

  • Eine genaue Dimension.
  • MATCH_PARENT, Die bevorzugte Größe für die View ist die Größe des übergeordneten Elements abzüglich des Innenabstands.
  • WRAP_CONTENT, Die bevorzugte Größe für die View ist gerade groß genug, um den Inhalt aufzunehmen, zuzüglich des Innenabstands.

Für verschiedene Unterklassen von ViewGroup gibt es Unterklassen von ViewGroup.LayoutParams. hat beispielsweise eine eigene abgeleitete Klasse von ViewGroup.LayoutParams mit der untergeordnete View Objekte horizontal und vertikal zentriert werden können.RelativeLayout

MeasureSpec -Objekte werden verwendet, um Anforderungen vom übergeordneten zum untergeordneten Element im Baum zu übertragen. Ein MeasureSpec kann einen von drei Modi haben:

  • UNSPECIFIED: Das übergeordnete Element verwendet diesen Modus, um die Zieldimension eines untergeordneten View-Elements zu bestimmen. Ein LinearLayout kann beispielsweise measure() für sein untergeordnetes Element aufrufen, wobei die Höhe auf UNSPECIFIED und die Breite auf EXACTLY 240 festgelegt ist, um herauszufinden, wie hoch das untergeordnete View bei einer Breite von 240 Pixeln sein soll.
  • EXACTLY: `EXACTLY`: Das übergeordnete Element verwendet diesen Modus, um dem untergeordneten Element eine genaue Größe aufzuerlegen. Das untergeordnete Element muss diese Größe verwenden und garantieren, dass alle untergeordneten Elemente in diese Größe passen.
  • AT MOST: Das übergeordnete Element verwendet diesen Modus, um dem untergeordneten Element eine maximale Größe aufzuerlegen. Das untergeordnete Element muss garantieren, dass es und alle untergeordneten Elemente in diese Größe passen.

Layoutphase starten

Rufen Sie requestLayout() auf, um ein Layout zu starten. Diese Methode wird in der Regel von einer View für sich selbst aufgerufen, wenn sie der Meinung ist, dass sie nicht mehr in ihre Grenzen passt.

Benutzerdefinierte Mess- und Layoutlogik implementieren

Wenn Sie eine benutzerdefinierte Mess- oder Layoutlogik implementieren möchten, überschreiben Sie die Methoden, in denen die Logik implementiert ist: onMeasure(int, int) und onLayout(boolean, int, int, int, int). Diese Methoden werden von measure(int, int) bzw. layout(int, int, int, int) aufgerufen. Versuchen Sie nicht, die Methoden measure(int, int) oder layout(int, int) zu überschreiben. Beide Methoden sind final und können daher nicht überschrieben werden.

Im folgenden Beispiel wird gezeigt, wie Sie dies in der `SplitLayout` Klasse aus der WindowManager Beispiel-App tun. Wenn das SplitLayout zwei oder mehr untergeordnete Ansichten hat und das Display eine Faltung aufweist, werden die beiden untergeordneten Ansichten auf beiden Seiten der Faltung positioniert. Das folgende Beispiel zeigt einen Anwendungsfall für das Überschreiben der Messung und des Layouts. Für die Produktion sollten Sie jedoch SlidingPaneLayout verwenden, wenn Sie dieses Verhalten wünschen.

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