In che modo Android traccia le visualizzazioni

Il framework Android chiede Activity per disegnare il proprio layout quando Activity riceve lo stato attivo. Il framework Android gestisce la procedura per il disegno, ma Activity deve fornire il nodo radice della gerarchia del suo layout.

Il framework Android disegna il nodo radice del layout, misura e traccia l'albero del layout. it disegna camminando sull'albero e visualizzando ogni View che interseca la regione non valida. Ogni ViewGroup è responsabile che richiede che ognuno dei suoi figli venga disegnato, utilizzando draw() e ogni View è responsabile del disegno stesso. Perché l'albero viene attraversato pre-ordinata, il framework attira i genitori prima, cioè dietro la loro bambini e disegna i fratelli nell'ordine in cui appaiono nell'albero.

Il framework Android disegna il layout in un processo a due passaggi: un superamento della misurazione e un passaggio del layout. La il framework esegue la misurazione measure(int, int) e esegue un attraversamento dall'alto verso il basso dell'albero View. Ogni View spinge le dimensioni le specifiche dell'intera struttura durante la ricorsione. Al termine della misurazione, ogni View memorizza le proprie misurazioni. Il framework esegue il secondo passaggio layout(int, int, int, int) e anche dall'alto verso il basso. Durante questa verifica, ogni genitore è responsabile del posizionamento di tutti i relativi elementi secondari utilizzando le dimensioni calcolate nella valutazione generata.

Le due fasi della procedura di creazione del layout sono descritte in maggiore dettaglio nelle sezioni seguenti.

Avviare un superamento della misura

Quando un oggetto View Metodo measure() restituisce, imposta la sua getMeasuredWidth() e getMeasuredHeight() oltre a quelli di tutti i discendenti dell'oggetto View. Un View i valori di larghezza e altezza misurati dell'oggetto devono rispettare i vincoli imposti Elementi padre dell'oggetto View. Questo aiuta a garantire che al termine della misurazione tutti i genitori accettano tutte le misurazioni dei propri figli.

Un elemento View principale potrebbe chiamare measure() più volte sui relativi elementi secondari. Per Ad esempio, l'elemento principale potrebbe misurare gli elementi secondari una volta con dimensioni non specificate per dimensioni preferite. Se la somma delle dimensioni non vincolate degli elementi secondari è troppo grande o troppo piccola, l'elemento principale potrebbe chiamare di nuovo measure() con valori che limitano le taglie dei bambini.

La misurazione approvata utilizza due classi per comunicare le dimensioni. La ViewGroup.LayoutParams è il modo in cui gli oggetti View comunicano le dimensioni e le posizioni preferite. La base La classe ViewGroup.LayoutParams descrive la larghezza e l'altezza preferite della View. Per ogni dimensione, è possibile specificare una delle seguenti opzioni:

  • Una dimensione esatta.
  • MATCH_PARENT, il che significa che la dimensione preferita per l'elemento View è la dimensione dell'elemento principale, meno spaziatura interna.
  • WRAP_CONTENT, il che significa che la dimensione preferita per View è abbastanza grande per racchiuderne il contenuto, più spaziatura interna.

Esistono sottoclassi di ViewGroup.LayoutParams per diverse sottoclassi di ViewGroup. Ad esempio: RelativeLayout ha il proprio sottoclasse di ViewGroup.LayoutParams che include la possibilità di centrare l'elemento secondario View oggetti orizzontalmente e verticalmente.

MeasureSpec oggetti sono utilizzata per spostare i requisiti dall'elemento principale a quello secondario. Un MeasureSpec può essere inserito una delle tre modalità:

  • UNSPECIFIED: l'elemento principale lo utilizza per determinare la dimensione target di un View secondario. Ad esempio: un LinearLayout potrebbe chiamare measure() nella riga secondaria con l'altezza impostata su UNSPECIFIED e una larghezza di EXACTLY 240 per scoprire quanto vuole essere alto il bambino View, con una larghezza di 240 pixel.
  • EXACTLY: il publisher principale lo usa per imporre una dimensione esatta all'elemento secondario. Il bambino deve utilizzare questa taglia garantire che tutti i suoi discendenti rientrino in queste dimensioni.
  • AT MOST: l'elemento principale lo utilizza per imporre una dimensione massima all'elemento secondario. Il ragazzo deve garantire che e tutti i suoi discendenti rientrano in queste dimensioni.

Avviare una tessera per il layout

Per avviare un layout, chiama requestLayout(). Questo viene generalmente chiamato da un View quando ritiene di non poter più adattarsi entro i suoi confini.

Implementa una logica di misurazione e di layout personalizzata

Se vuoi implementare una logica di misurazione o di layout personalizzata, sostituisci i metodi in cui la logica è implementato: onMeasure(int, int) e onLayout(boolean, int, int, int, int). Questi metodi vengono richiamati da measure(int, int) e rispettivamente layout(int, int, int, int). Non provare a eseguire l'override measure(int, int) o layout(int, int) metodi: entrambi i metodi sono final, perciò non è possibile eseguirne l'override.

L'esempio seguente mostra come eseguire questa operazione nell' "SplitLayout" della classe WindowManager di esempio. Se SplitLayout ha due o più visualizzazioni secondarie e il display ha un fold, le due visualizzazioni secondarie vengono posizionate su entrambi i lati della piegatura. L'esempio seguente mostra un utilizzo sostituire la misurazione e il layout, mentre per la produzione usa SlidingPaneLayout se vuoi questo comportamento.

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