Dynamicznie tworzę wszystkie elementy mojego projektu na Androida. Próbuję uzyskać szerokość i wysokość przycisku, aby móc go obrócić. Próbuję tylko nauczyć się, jak pracować z językiem Androida. Zwraca jednak 0.

Przeprowadziłem badania i zauważyłem, że należy to zrobić gdzieś indziej niż w onCreate()metodzie. Gdyby ktoś mógł podać mi przykład, jak to zrobić, byłoby świetnie.

Oto mój obecny kod:

package com.animation;

import android.app.Activity;
import android.os.Bundle;
import android.view.animation.Animation;
import android.view.animation.LinearInterpolator;
import android.view.animation.RotateAnimation;
import android.widget.Button;
import android.widget.LinearLayout;

public class AnimateScreen extends Activity {


//Called when the activity is first created.
@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    LinearLayout ll = new LinearLayout(this);

    LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
    layoutParams.setMargins(30, 20, 30, 0);

    Button bt = new Button(this);
    bt.setText(String.valueOf(bt.getWidth()));

    RotateAnimation ra = new RotateAnimation(0,360,bt.getWidth() / 2,bt.getHeight() / 2);
    ra.setDuration(3000L);
    ra.setRepeatMode(Animation.RESTART);
    ra.setRepeatCount(Animation.INFINITE);
    ra.setInterpolator(new LinearInterpolator());

    bt.startAnimation(ra);

    ll.addView(bt,layoutParams);

    setContentView(ll);
}

Każda pomoc jest mile widziana.

Dzwonisz getWidth()za wcześnie. Interfejs użytkownika nie został jeszcze dopasowany i rozmieszczony na ekranie.

Wątpię, czy chcesz robić to, co robisz - animowane widżety nie zmieniają ich klikalnych obszarów, więc przycisk nadal będzie reagował na kliknięcia w pierwotnej orientacji, niezależnie od tego, jak się obrócił.

To powiedziawszy, możesz użyć zasobu wymiaru, aby zdefiniować rozmiar przycisku, a następnie odwołać się do tego zasobu wymiaru z pliku układu i kodu źródłowego, aby uniknąć tego problemu.

Podstawowym problemem jest to, że trzeba czekać na fazę rysowania dla rzeczywistych pomiarów (szczególnie z wartościami dynamicznymi, takimi jak wrap_contentlub match_parent), ale zazwyczaj ta faza nie została jeszcze ukończona onResume(). Potrzebujesz obejścia, aby poczekać na tę fazę. Istnieją różne możliwe rozwiązania tego:

1. Słuchaj zdarzeń losowania / układu: ViewTreeObserver

ViewTreeObserver zostaje zwolniony dla różnych zdarzeń rysowania. Zwykle OnGlobalLayoutListenerjest to, co chcesz uzyskać pomiar, więc kod w detektorze zostanie wywołany po fazie układu, więc pomiary są gotowe:

view.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
                view.getHeight(); //height is ready
            }
        });

Uwaga: Detektor zostanie natychmiast usunięty, ponieważ w przeciwnym razie będzie uruchamiany przy każdym zdarzeniu układu. Jeśli musisz obsługiwać aplikacje SDK Lvl <16, użyj tego do wyrejestrowania nasłuchującego:

public void removeGlobalOnLayoutListener (ViewTreeObserver.OnGlobalLayoutListener victim)

2. Dodaj plik wykonywalny do kolejki układu: View.post ()

Niezbyt dobrze znane i moje ulubione rozwiązanie. Zasadniczo po prostu użyj metody postu View z własnym runnable. To w zasadzie umieszcza kod w kolejce po takcie widoku, układzie itp., Jak stwierdził Romain Guy :

Kolejka zdarzeń interfejsu użytkownika będzie przetwarzać zdarzenia w kolejności. Po wywołaniu metody setContentView () kolejka zdarzeń będzie zawierać komunikat z prośbą o przekazanie, więc wszystko, co opublikujesz w kolejce, nastąpi po przejściu układu

Przykład:

final View view=//smth;
...
view.post(new Runnable() {
            @Override
            public void run() {
                view.getHeight(); //height is ready
            }
        });

Przewaga nad ViewTreeObserver:

• Twój kod jest wykonywany tylko raz i nie musisz wyłączać Obserwatora po wykonaniu, co może być kłopotliwe
• mniej pełna składnia

Bibliografia:

• https://stackoverflow.com/a/3602144/774398
• https://stackoverflow.com/a/3948036/774398

3. Nadpisz metodę ViewLayout

Jest to praktyczne tylko w niektórych sytuacjach, gdy logikę można zamknąć w samym widoku, w przeciwnym razie jest to dość pełna i nieporęczna składnia.

view = new View(this) {
    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        super.onLayout(changed, l, t, r, b);
        view.getHeight(); //height is ready
    }
};

Pamiętaj też, że onLayout będzie wywoływany wiele razy, więc zastanów się, co robisz w metodzie, lub wyłącz swój kod po raz pierwszy

4. Sprawdź, czy przeszedł fazę układu

Jeśli masz kod, który wykonuje się wiele razy podczas tworzenia interfejsu użytkownika, możesz użyć następującej metody wsparcia v4 lib:

View viewYouNeedHeightFrom = ...
...
if(ViewCompat.isLaidOut(viewYouNeedHeightFrom)) {
   viewYouNeedHeightFrom.getHeight();
}

Zwraca wartość true, jeśli widok przeszedł przez co najmniej jeden układ od czasu ostatniego przyłączenia lub odłączenia od okna.

Dodatkowo: uzyskiwanie statycznie zdefiniowanych pomiarów

Jeśli wystarczy uzyskać statycznie zdefiniowaną wysokość / szerokość, możesz to zrobić za pomocą:

• View.getMeasuredWidth()
• View.getMeasuredHeigth()

Pamiętaj jednak, że po rysowaniu może się ona różnić od rzeczywistej szerokości / wysokości. Jawadok doskonale opisuje różnicę:

Rozmiar widoku jest wyrażany za pomocą szerokości i wysokości. Widok faktycznie zawiera dwie pary wartości szerokości i wysokości.

Pierwsza para jest znana jako zmierzona szerokość i zmierzona wysokość. Wymiary te określają, jak duży widok ma być w swoim obiekcie nadrzędnym (zobacz Układ, aby uzyskać więcej informacji.) Zmierzone wymiary można uzyskać, wywołując getMeasuredWidth () i getMeasuredHeight ().

Druga para jest po prostu znana jako szerokość i wysokość, lub czasami szerokość i wysokość rysunku. Wymiary te określają rzeczywisty rozmiar widoku na ekranie, w czasie rysowania i po układzie. Wartości te mogą, ale nie muszą, różnić się od zmierzonej szerokości i wysokości. Szerokość i wysokość można uzyskać, wywołując getWidth () i getHeight ().

Możemy użyć

@Override
 public void onWindowFocusChanged(boolean hasFocus) {
  super.onWindowFocusChanged(hasFocus);
  //Here you can get the size!
 }

Użyłem tego rozwiązania, które moim zdaniem jest lepsze niż onWindowFocusChanged (). Jeśli otworzysz DialogFragment, a następnie obrócisz telefon, onWindowFocusChanged zostanie wywołany tylko wtedy, gdy użytkownik zamknie okno dialogowe):

    yourView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

        @Override
        public void onGlobalLayout() {
            // Ensure you call it only once :
            yourView.getViewTreeObserver().removeGlobalOnLayoutListener(this);

            // Here you can get the size :)
        }
    });

Edycja: ponieważ removeGlobalOnLayoutListener jest przestarzałe, powinieneś teraz:

@SuppressLint("NewApi")
@SuppressWarnings("deprecation")
@Override
public void onGlobalLayout() {

    // Ensure you call it only once :
    if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
        yourView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
    }
    else {
        yourView.getViewTreeObserver().removeGlobalOnLayoutListener(this);
    }

    // Here you can get the size :)
}

Jak stwierdza Ian w tym wątku dla programistów Androida :

W każdym razie umowa polega na tym, że układ zawartości okna ma miejsce po zbudowaniu wszystkich elementów i dodaniu ich do widoków nadrzędnych. Tak musi być, ponieważ dopóki nie dowiesz się, jakie składniki zawiera Widok i co one zawierają, itd., Nie ma rozsądnego sposobu na jego rozłożenie.

Podsumowując, jeśli wywołasz getWidth () itp. W konstruktorze, zwróci zero. Procedura polega na utworzeniu wszystkich elementów widoku w konstruktorze, a następnie odczekaniu na wywołanie metody onSizeChanged () w widoku - wtedy po raz pierwszy dowiesz się, jaki jest Twój rzeczywisty rozmiar, a więc wtedy ustawisz rozmiary elementów GUI.

Pamiętaj też, że onSizeChanged () jest czasami wywoływany z parametrami zerowymi - sprawdź w tym przypadku i wróć natychmiast (aby nie otrzymać podziału przez zero podczas obliczania układu itp.). Jakiś czas później zostanie wywołany z rzeczywistymi wartościami.

Jeśli chcesz uzyskać szerokość jakiegoś widżetu, zanim zostanie on wyświetlony na ekranie, możesz użyć getMeasuredWidth () lub getMeasuredHeight ().

myImage.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
int width = myImage.getMeasuredWidth();
int height = myImage.getMeasuredHeight();

Wolałbym używać OnPreDrawListener()zamiast addOnGlobalLayoutListener(), ponieważ nazywa się to nieco wcześniej niż inni słuchacze.

    view.getViewTreeObserver().addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener()
    {
        @Override
        public boolean onPreDraw()
        {
            if (view.getViewTreeObserver().isAlive())
                view.getViewTreeObserver().removeOnPreDrawListener(this);

            // put your code here
            return true;
        }
    });

Rozszerzenie Kotlin do obserwacji globalnego układu i wykonywania określonego zadania, gdy wysokość jest dynamicznie gotowa.

Stosowanie:

view.height { Log.i("Info", "Here is your height:" + it) }

Realizacja:

fun <T : View> T.height(function: (Int) -> Unit) {
    if (height == 0)
        viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                viewTreeObserver.removeOnGlobalLayoutListener(this)
                function(height)
            }
        })
    else function(height)
}

AndroidX ma wiele funkcji rozszerzenia, które pomagają w tego rodzaju pracy wewnątrz androidx.core.view

W tym celu musisz użyć Kotlina.

Ten, który najlepiej tu pasuje, to doOnLayout:

Wykonuje podaną akcję, gdy ten widok jest ułożony. Jeśli widok został ułożony i nie zażądał układu, akcja zostanie wykonana natychmiast, w przeciwnym razie akcja zostanie wykonana po następnym ułożeniu widoku.

Akcja zostanie wywołana tylko raz na następnym układzie, a następnie usunięta.

W twoim przykładzie:

bt.doOnLayout {
    val ra = RotateAnimation(0,360,it.width / 2,it.height / 2)
    // more code
}

Zależność: androidx.core:core-ktx:1.0.0

Jedna wkładka, jeśli używasz RxJava i RxBindings . Podobne podejście bez płyty kotłowej. To także rozwiązuje problem hakowania, aby ukryć ostrzeżenia, jak w odpowiedzi Tima Autina .

RxView.layoutChanges(yourView).take(1)
      .subscribe(aVoid -> {
           // width and height have been calculated here
      });

To jest to. Nie musisz rezygnować z subskrypcji, nawet jeśli nigdy nie dzwonisz.

Dzieje się tak, ponieważ widok potrzebuje więcej czasu na zawyżenie. Więc zamiast dzwonić view.widthi view.heightw głównym wątku, powinieneś użyć, view.post { ... }aby upewnić się, że twój viewzostał już napompowany. W Kotlinie:

view.post{width}
view.post{height}

W Javie można również zadzwonić getWidth()i getHeight()metod w Runnablei przekazać Runnabledo view.post()metody.

view.post(new Runnable() {
        @Override
        public void run() {
            view.getWidth(); 
            view.getHeight();
        }
    });

Wysokość i szerokość wynoszą zero, ponieważ widok nie został utworzony do momentu, gdy zażądasz jego wysokości i szerokości. Jednym z najprostszych rozwiązań jest

view.post(new Runnable() {
        @Override
        public void run() {
            view.getHeight(); //height is ready
            view.getWidth(); //width is ready
        }
    });

Ta metoda jest dobra w porównaniu do innych metod, ponieważ jest krótka i rześka.

Może to pomaga komuś:

Utwórz funkcję rozszerzenia dla klasy View

nazwa pliku: ViewExt.kt

fun View.afterLayout(what: () -> Unit) {
    if(isLaidOut) {
        what.invoke()
    } else {
        viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
            override fun onGlobalLayout() {
                viewTreeObserver.removeOnGlobalLayoutListener(this)
                what.invoke()
            }
        })
    }
}

Można go następnie użyć w dowolnym widoku z:

view.afterLayout {
    do something with view.height
}

Odpowiedź z postjest nieprawidłowa, ponieważ rozmiar może nie zostać ponownie obliczony.
Inną ważną rzeczą jest to, że widok i wszyscy jego przodkowie muszą być widoczni . Do tego używam nieruchomości View.isShown.

Oto moja funkcja kotlin, którą można umieścić gdzieś w utils:

fun View.onInitialized(onInit: () -> Unit) {
    viewTreeObserver.addOnGlobalLayoutListener(object : OnGlobalLayoutListener {
        override fun onGlobalLayout() {
            if (isShown) {
                viewTreeObserver.removeOnGlobalLayoutListener(this)
                onInit()
            }
        }
    })
}

A użycie to:

myView.onInitialized {
    Log.d(TAG, "width is: " + myView.width)
}

Jeśli używasz Kotlin

  leftPanel.viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {

            override fun onGlobalLayout() {

                if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
                    leftPanel.viewTreeObserver.removeOnGlobalLayoutListener(this)
                }
                else {
                    leftPanel.viewTreeObserver.removeGlobalOnLayoutListener(this)
                }

                // Here you can get the size :)
                leftThreshold = leftPanel.width
            }
        })

Brak wyświetleń zwraca 0 jako wysokość, jeśli aplikacja działa w tle. Ten mój kod (1oo% działa)

fun View.postWithTreeObserver(postJob: (View, Int, Int) -> Unit) {
    viewTreeObserver.addOnGlobalLayoutListener(object : ViewTreeObserver.OnGlobalLayoutListener {
        override fun onGlobalLayout() {
            val widthSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
            val heightSpec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
            measure(widthSpec, heightSpec)
            postJob(this@postWithTreeObserver, measuredWidth, measuredHeight)
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
                @Suppress("DEPRECATION")
                viewTreeObserver.removeGlobalOnLayoutListener(this)
            } else {
                viewTreeObserver.removeOnGlobalLayoutListener(this)
            }
        }
    })
}

Musimy poczekać, aż widok zostanie narysowany. W tym celu użyj OnPreDrawListener. Przykład Kotlina:

val preDrawListener = object : ViewTreeObserver.OnPreDrawListener {

                override fun onPreDraw(): Boolean {
                    view.viewTreeObserver.removeOnPreDrawListener(this)

                    // code which requires view size parameters

                    return true
                }
            }

            view.viewTreeObserver.addOnPreDrawListener(preDrawListener)