Determinazione delle dimensioni di una visualizzazione Android in fase di esecuzione

Sto cercando di applicare un'animazione a una vista nella mia app Android dopo aver creato la mia attività. Per fare ciò, è necessario determinare la dimensione corrente della vista e quindi impostare un'animazione per ridimensionare dalla dimensione corrente alla nuova dimensione. Questa parte deve essere eseguita in fase di runtime, poiché la vista scala a dimensioni diverse a seconda dell'input dell'utente. Il mio layout è definito in XML.

Sembra un compito facile, e ci sono molte domande SO riguardo a questo anche se nessuna ha risolto il mio problema, ovviamente. Quindi forse mi manca qualcosa di ovvio. Ottengo un controllo della mia vista da:

ImageView myView = (ImageView) getWindow().findViewById(R.id.MyViewID);

Questo funziona bene, ma quando si chiama getWidth(), getHeight(), getMeasuredWidth(), getLayoutParams().width, ecc, tutti di ritorno 0. Ho anche provato manualmente chiamando measure()sulla vista seguita da una chiamata a getMeasuredWidth(), ma che non ha alcun effetto.

Ho provato a chiamare questi metodi e ispezionare l'oggetto nel debugger nella mia attività onCreate()e in onPostCreate(). Come posso calcolare le dimensioni esatte di questa vista in fase di esecuzione?

Utilizzare ViewTreeObserver sulla vista per attendere il primo layout. Solo dopo il primo layout getWidth () / getHeight () / getMeasuredWidth () / getMeasuredHeight () funzionerà.

ViewTreeObserver viewTreeObserver = view.getViewTreeObserver();
if (viewTreeObserver.isAlive()) {
  viewTreeObserver.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
    @Override
    public void onGlobalLayout() {
      view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
      viewWidth = view.getWidth();
      viewHeight = view.getHeight();
    }
  });
}

Esistono in realtà più soluzioni, a seconda dello scenario:

1. Il metodo sicuro, funzionerà appena prima di disegnare la vista, dopo che la fase di layout è terminata:

public static void runJustBeforeBeingDrawn(final View view, final Runnable runnable) {
    final OnPreDrawListener preDrawListener = new OnPreDrawListener() {
        @Override
        public boolean onPreDraw() {
            view.getViewTreeObserver().removeOnPreDrawListener(this);
            runnable.run();
            return true;
        }
    };
    view.getViewTreeObserver().addOnPreDrawListener(preDrawListener); 
}

Utilizzo del campione:

    ViewUtil.runJustBeforeBeingDrawn(yourView, new Runnable() {
        @Override
        public void run() {
            //Here you can safely get the view size (use "getWidth" and "getHeight"), and do whatever you wish with it
        }
    });

2. In alcuni casi, è sufficiente misurare manualmente le dimensioni della vista:

view.measure(MeasureSpec.UNSPECIFIED, MeasureSpec.UNSPECIFIED);
int width=view.getMeasuredWidth(); 
int height=view.getMeasuredHeight();

Se conosci le dimensioni del contenitore:

    val widthMeasureSpec = View.MeasureSpec.makeMeasureSpec(maxWidth, View.MeasureSpec.AT_MOST)
    val heightMeasureSpec = View.MeasureSpec.makeMeasureSpec(maxHeight, View.MeasureSpec.AT_MOST)
    view.measure(widthMeasureSpec, heightMeasureSpec)
    val width=view.measuredWidth
    val height=view.measuredHeight

3. se hai una visualizzazione personalizzata che hai esteso, puoi ottenere le sue dimensioni con il metodo "onMeasure", ma penso che funzioni bene solo in alcuni casi:

protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
    final int newHeight= MeasureSpec.getSize(heightMeasureSpec);
    final int newWidth= MeasureSpec.getSize(widthMeasureSpec);
    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

4. Se scrivi in ​​Kotlin, puoi usare la funzione successiva, che dietro le quinte funziona esattamente come runJustBeforeBeingDrawnho scritto:

   view.doOnPreDraw { actionToBeTriggered() }

   Nota che devi aggiungerlo a gradle (trovato tramite qui ):

   implementation 'androidx.core:core-ktx:#.#'

Stai chiamando getWidth()prima che la visuale sia effettivamente visualizzata sullo schermo?

Un errore comune commesso dai nuovi sviluppatori Android è quello di utilizzare la larghezza e l'altezza di una vista all'interno del suo costruttore. Quando viene chiamato il costruttore di una vista, Android non sa ancora quanto sarà grande la vista, quindi le dimensioni sono impostate su zero. Le dimensioni reali vengono calcolate durante la fase di layout, che avviene dopo la costruzione ma prima di disegnare qualsiasi cosa. È possibile utilizzare il onSizeChanged()metodo per ricevere una notifica dei valori quando sono noti oppure è possibile utilizzare i metodi getWidth()e in un getHeight()secondo momento, ad esempio nel onDraw()metodo.

Sulla base del consiglio di @ mbaird, ho trovato una soluzione praticabile sottoclassando la ImageViewclasse e sostituendola onLayout(). Ho quindi creato un'interfaccia osservatore che la mia attività ha implementato e passato un riferimento a se stessa alla classe, che le ha permesso di dire all'attività quando era effettivamente terminato il dimensionamento.

Non sono convinto al 100% che questa sia la soluzione migliore (quindi non sto ancora contrassegnando questa risposta come corretta), ma funziona e secondo la documentazione è la prima volta che si riesce a trovare la dimensione effettiva di una vista.

Ecco il codice per ottenere il layout sovrascrivendo una vista se API <11 (API 11 include la funzione View.OnLayoutChangedListener):

public class CustomListView extends ListView
{
    private OnLayoutChangedListener layoutChangedListener;

    public CustomListView(Context context)
    {
        super(context);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b)
    {
        if (layoutChangedListener != null)
        {
            layoutChangedListener.onLayout(changed, l, t, r, b);
        }
        super.onLayout(changed, l, t, r, b);
    }

    public void setLayoutChangedListener(
        OnLayoutChangedListener layoutChangedListener)
    {
        this.layoutChangedListener = layoutChangedListener;
    }
}
public interface OnLayoutChangedListener
{
    void onLayout(boolean changed, int l, int t, int r, int b);
}

Puoi controllare questa domanda . È possibile utilizzare la View's post () metodo.

Usa il codice sottostante, fornisce la dimensione della vista.

@Override
public void onWindowFocusChanged(boolean hasFocus) {
       super.onWindowFocusChanged(hasFocus);
       Log.e("WIDTH",""+view.getWidth());
       Log.e("HEIGHT",""+view.getHeight());
}

Questo funziona per me nel mio onClickListener:

yourView.postDelayed(new Runnable() {               
    @Override
    public void run() {         
        yourView.invalidate();
        System.out.println("Height yourView: " + yourView.getHeight());
        System.out.println("Width yourView: " + yourView.getWidth());               
    }
}, 1);

Sono stato anche perso in giro getMeasuredWidth()ed getMeasuredHeight() getHeight()e getWidth()per un lungo periodo .......... più tardi ho scoperto che ottenere larghezza e l'altezza della vista in onSizeChanged()è il modo migliore per farlo ........ è possibile in modo dinamico ottieni la larghezza ATTUALE e l'altezza CORRENTE della tua vista sovrascrivendo il onSizeChanged(metodo).

potrei voler dare un'occhiata a questo che ha uno snippet di codice elaborato. Nuovo post sul blog: come ottenere le dimensioni di larghezza e altezza di una vista personalizzata (estende la vista) in Android http://syedrakibalhasan.blogspot.com/2011/02/how-to-get-width-and-height-dimensions.html

È possibile ottenere sia la posizione che la dimensione della vista sullo schermo

 val viewTreeObserver: ViewTreeObserver = videoView.viewTreeObserver;

if (viewTreeObserver.isAlive) {
    viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
        override fun onGlobalLayout() {
            //Remove Listener
            videoView.viewTreeObserver.removeOnGlobalLayoutListener(this);

            //View Dimentions
            viewWidth = videoView.width;
            viewHeight = videoView.height;

            //View Location
            val point = IntArray(2)
            videoView.post {
                videoView.getLocationOnScreen(point) // or getLocationInWindow(point)
                viewPositionX = point[0]
                viewPositionY = point[1]
            }

        }
    });
}

funziona perfettamente per me:

 protected override void OnElementPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        base.OnElementPropertyChanged(sender, e);
        CTEditor ctEdit = Element as CTEditor;
        if (ctEdit == null) return;           
        if (e.PropertyName == "Text")
        {
            double xHeight = Element.Height;
            double aHaight = Control.Height;
            double height;                
            Control.Measure(LayoutParams.MatchParent,LayoutParams.WrapContent);
            height = Control.MeasuredHeight;
            height = xHeight / aHaight * height;
            if (Element.HeightRequest != height)
                Element.HeightRequest = height;
        }
    }