Wie Android Aufrufe generiert

Das Android-Framework fragt Activity, um das Layout zu zeichnen, wenn die Activity erhält Fokus. Das Android-Framework übernimmt das Zeichnen, aber der Activity muss den Stammknoten seiner Layouthierarchie angeben.

Das Android-Framework zeichnet den Stammknoten des Layouts und misst und zeichnet den Layoutbaum. Es indem wir den Baum durchgehen und jedes View, die sich mit der ungültigen Region überschneidet. Jeder ViewGroup ist verantwortlich für fordern, dass jedes seiner untergeordneten Elemente gezeichnet wird. Dazu wird der Operator draw() und jeder View ist für die Zeichnung selbst verantwortlich. Weil der Baum durchquert wird Vorbestellungen erfolgen, zieht das Framework die Eltern vor – mit anderen Worten – hinter ihrem untergeordnete Elemente und zeichnet gleichgeordnete Elemente in der Reihenfolge, in der sie in der Baumstruktur angezeigt werden.

<ph type="x-smartling-placeholder">

</ph> Hinweis: Das Framework zeichnet keine View-Objekte, die sich nicht in einer gültigen Region befinden. Es die Zeichnung des View-Hintergrunds für Sie. Sie können eine View zum Zeichnen durch Aufrufen invalidate().

Das Android-Framework zeichnet das Layout in einem Prozess mit zwei Durchgängen: einer Messungsübergabe und einer Layoutübergabe. Die die Maßnahme measure(int, int) und führt einen Top-down-Durchlauf des View-Baums durch. Jede View überträgt eine Dimension. Spezifikationen des Baums während der Rekursion. Am Ende der Messung View speichert seine Messwerte. Das Framework führt den zweiten Durchlauf layout(int, int, int, int) und ist ebenfalls von oben nach unten. Während dieser Zeit ist jedes übergeordnete Element für die Positionierung aller untergeordneten Elemente verantwortlich unter Verwendung der in der Messungsdurchlaufe berechneten Größen.

Die beiden Durchgänge des Layoutprozesses werden in den folgenden Abschnitten ausführlicher beschrieben.

Bestandene Messung starten

Wenn die Eigenschaft eines View-Objekts measure()-Methode gibt, legen Sie die getMeasuredWidth() und getMeasuredHeight() -Werte sowie denen für alle Nachfolgerelemente des View-Objekts. Ein View müssen die Werte der gemessenen Breite und Höhe des Objekts die Die übergeordneten Elemente des View-Objekts. So sorgen Sie dafür, dass am Ende der Messung alle alle Maße ihrer Kinder akzeptieren.

Ein übergeordnetes View-Element kann measure() für seine untergeordneten Elemente mehrmals aufrufen. Für Beispiel: Das übergeordnete Element kann die untergeordneten Elemente einmal mit nicht angegebenen Dimensionen messen, um ihre bevorzugte Größen. Wenn die Summe der nicht eingeschränkten Größen der untergeordneten Elemente zu groß oder zu klein ist, kann measure() erneut mit Werten aufrufen, die die Größen der untergeordneten Elemente einschränken.

Bei der Messungskarte werden zwei Klassen verwendet, um Dimensionen zu kommunizieren. Die ViewGroup.LayoutParams Klasse ist, wie View-Objekte ihre bevorzugten Größen und Positionen kommunizieren. Basis ViewGroup.LayoutParams-Klasse beschreibt die bevorzugte Breite und Höhe des View. Für jede Dimension kann eine der folgenden Optionen angegeben werden:

• Eine genaue Dimension.
• MATCH_PARENT, d. h. die bevorzugte Größe für View ist die Größe des übergeordneten Elements, minus Abstand.
• WRAP_CONTENT, Das heißt, die bevorzugte Größe für View ist gerade groß genug, um den Inhalt zu einschließen, hinzufügen.

Es gibt abgeleitete Klassen von ViewGroup.LayoutParams für verschiedene abgeleitete Klassen von ViewGroup. Beispiel: RelativeLayout hat eine eigene von ViewGroup.LayoutParams mit der Möglichkeit, untergeordnete Elemente View-Objekte horizontal und vertikal.

MeasureSpec Objekte sind werden verwendet, um Anforderungen in der Baumstruktur von der übergeordneten in die untergeordnete zu verschieben. Ein MeasureSpec kann sich hier befinden: einem von drei Modi:

• UNSPECIFIED: wird vom übergeordneten Element verwendet, um die Zieldimension eines untergeordneten View-Elements zu bestimmen. Beispiel: kann ein LinearLayout anrufen, measure() für das untergeordnete Element mit einer Höhe von UNSPECIFIED und einer Breite von EXACTLY 240 um zu ermitteln, wie groß das untergeordnete Element View bei einer Breite von 240 Pixeln sein möchte.
• EXACTLY: wird dies vom übergeordneten Element verwendet, um dem untergeordneten Element eine genaue Größe vorzugeben. Das untergeordnete Element muss diese Größe und dass alle Nachfolgerelemente in diese Größe passen.
• AT MOST: wird dies vom übergeordneten Element verwendet, um eine maximale Größe für das untergeordnete Element festzulegen. Das Kind muss dafür sorgen, dass alle Nachfolgerelemente in diese Größe passen.

Layoutübergabe initiieren

Rufen Sie zum Starten eines Layouts requestLayout() Dieses wird normalerweise von einem View selbst aufgerufen, wenn sie annimmt, dass sie nicht die innerhalb der Grenzen liegt.

Benutzerdefinierte Mess- und Layoutlogik implementieren

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

Das folgende Beispiel zeigt, wie dies in der SplitLayout Klasse aus der Fenstermanager Beispiel-App. Hat SplitLayout zwei oder mehr untergeordnete Ansichten und das Display hat einen Fold, werden die beiden untergeordneten Ansichten links und rechts vom Fold positioniert. Das folgende Beispiel zeigt eine Verwendung für das Überschreiben der Messung und das Layout, SlidingPaneLayout 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;
      }
   }
}