Déterminer la taille d'une vue Android lors de l'exécution

J'essaie d'appliquer une animation à une vue dans mon application Android après la création de mon activité. Pour ce faire, je dois déterminer la taille actuelle de la vue, puis configurer une animation à l'échelle de la taille actuelle à la nouvelle taille. Cette partie doit être effectuée au moment de l'exécution, car la vue est mise à l'échelle à différentes tailles en fonction de l'entrée de l'utilisateur. Ma mise en page est définie en XML.

Cela semble être une tâche facile, et il y a beaucoup de questions SO à ce sujet, mais aucune n'a résolu mon problème, évidemment. Alors peut-être que je manque quelque chose d'évident. Je saisis mon point de vue en:

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

Cela fonctionne très bien, mais lors de l' appel getWidth(), getHeight(), getMeasuredWidth(), getLayoutParams().width, etc., ils ont tous le retour 0. J'ai également essayé d' appeler manuellement measure()sur la vue suivie d'un appel à getMeasuredWidth(), mais cela n'a aucun effet.

J'ai essayé d'appeler ces méthodes et d'inspecter l'objet dans le débogueur dans mon activité onCreate()et dans onPostCreate(). Comment puis-je déterminer les dimensions exactes de cette vue au moment de l'exécution?

Utilisez le ViewTreeObserver sur la vue pour attendre la première mise en page. Ce n'est qu'après la première mise en page que getWidth () / getHeight () / getMeasuredWidth () / getMeasuredHeight () fonctionnera.

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

Il existe en fait plusieurs solutions, selon le scénario:

1. La méthode sûre fonctionnera juste avant de dessiner la vue, une fois la phase de mise en page terminée:

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

Exemple d'utilisation:

    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. Dans certains cas, il suffit de mesurer manuellement la taille de la vue:

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

Si vous connaissez la taille du conteneur:

    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. si vous avez une vue personnalisée que vous avez étendue, vous pouvez obtenir sa taille sur la méthode "onMeasure", mais je pense que cela ne fonctionne bien que dans certains cas:

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. Si vous écrivez en Kotlin, vous pouvez utiliser la fonction suivante, qui en coulisse fonctionne exactement comme runJustBeforeBeingDrawncelle que j'ai écrite:

   view.doOnPreDraw { actionToBeTriggered() }

   Notez que vous devez ajouter ceci à gradle (trouvé via ici ):

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

Appelez-vous getWidth()avant que la vue ne soit réellement présentée à l'écran?

Une erreur courante commise par les nouveaux développeurs Android est d'utiliser la largeur et la hauteur d'une vue à l'intérieur de son constructeur. Lorsqu'un constructeur de vue est appelé, Android ne sait pas encore quelle sera la taille de la vue, donc les tailles sont définies sur zéro. Les tailles réelles sont calculées pendant la phase de mise en page, qui se produit après la construction mais avant que quoi que ce soit ne soit dessiné. Vous pouvez utiliser la onSizeChanged()méthode pour être notifié des valeurs lorsqu'elles sont connues, ou vous pouvez utiliser les méthodes getWidth()et getHeight()plus tard, comme dans la onDraw()méthode.

Sur la base des conseils de @ mbaird, j'ai trouvé une solution viable en sous-classant la ImageViewclasse et en la remplaçant onLayout(). J'ai ensuite créé une interface d'observateur que mon activité a implémentée et passé une référence à elle-même à la classe, ce qui lui a permis de dire à l'activité quand elle avait réellement fini de dimensionner.

Je ne suis pas convaincu à 100% que ce soit la meilleure solution (d'où je ne marque pas encore cette réponse comme correcte), mais cela fonctionne et selon la documentation, c'est la première fois que l'on peut trouver la taille réelle d'une vue.

Voici le code pour obtenir la mise en page via le remplacement d'une vue si l'API <11 (l'API 11 inclut la fonctionnalité 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);
}

Vous pouvez vérifier cette question . Vous pouvez utiliser le Viewde » post () méthode.

Utilisez le code ci-dessous, cela donne la taille de la vue.

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

Cela fonctionne pour moi dans mon 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);

J'étais aussi perdu getMeasuredWidth()et getMeasuredHeight() getHeight()et getWidth()pendant longtemps .......... plus tard, j'ai trouvé que onSizeChanged()la meilleure façon de faire cela est d' obtenir la largeur et la hauteur de la vue ........ vous pouvez dynamiquement obtenez votre largeur ACTUELLE et votre hauteur ACTUELLE de votre vue en remplaçant la onSizeChanged(méthode).

pourrait vouloir jeter un oeil à ceci qui a un extrait de code élaboré. Nouvel article de blog: comment obtenir les dimensions de largeur et de hauteur d'un customView (étend la vue) dans Android http://syedrakibalhasan.blogspot.com/2011/02/how-to-get-width-and-height-dimensions.html

Vous pouvez obtenir à la fois la position et la dimension de la vue à l'écran

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

        }
    });
}

fonctionne parfaitement pour moi:

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