Android projemdeki tüm öğeleri dinamik olarak oluşturuyorum. Bir düğmenin genişliğini ve yüksekliğini almaya çalışıyorum, böylece düğmeyi etrafında döndürebilirim. Ben sadece android diliyle çalışmayı öğrenmeye çalışıyorum. Ancak 0 döndürür.

Biraz araştırma yaptım ve onCreate()yöntemden başka bir yerde yapılması gerektiğini gördüm . Birisi bana bunun nasıl yapılacağına dair bir örnek verebilirse, bu harika olurdu.

İşte benim geçerli 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);
}

Herhangi bir yardım takdir.

Aradığınız getWidth()çok erken. Kullanıcı arayüzü henüz boyutlandırılmadı ve ekranda gösterilmedi.

Yaptığınız şeyi yapmak istediğinizden şüpheliyim - yine de - animasyonlu widget'lar tıklanabilir alanlarını değiştirmez ve bu nedenle düğme, nasıl döndürüldüğüne bakılmaksızın orijinal yönündeki tıklamalara yanıt verir.

Bununla birlikte , düğme boyutunu tanımlamak için bir boyut kaynağı kullanabilir, ardından bu sorunu önlemek için bu boyut kaynağına mizanpaj dosyanızdan ve kaynak kodunuzdan başvurabilirsiniz .

Temel sorun, gerçek ölçümler için çizim aşamasını beklemeniz gerektiğidir (özellikle wrap_contentveya gibi dinamik değerlerle match_parent), ancak genellikle bu aşama tamamlanmamıştır onResume(). Bu nedenle bu aşamayı beklemek için bir geçici çözüme ihtiyacınız var. Bunun farklı olası çözümleri vardır:

1. Çizim / Mizanpaj Etkinliklerini Dinleyin: ViewTreeObserver

Farklı çizim etkinlikleri için bir ViewTreeObserver tetiklenir. Genellikle OnGlobalLayoutListenerölçümü almak için istediğiniz şeydir, bu yüzden dinleyicideki kod düzen aşamasından sonra çağrılır, böylece ölçümler hazırdır:

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

Not: Dinleyici hemen kaldırılacaktır, aksi takdirde her düzen olayında tetiklenecektir. SDK Lvl <16 uygulamalarını desteklemeniz gerekiyorsa, dinleyicinin kaydını silmek için bunu kullanın:

public void removeGlobalOnLayoutListener (ViewTreeObserver.OnGlobalLayoutListener victim)

2. Düzen kuyruğuna bir runnable ekleyin: View.post ()

Çok iyi bilinmeyen ve en sevdiğim çözüm. Temel olarak, Görünüm'ün yayın yöntemini kendi runnable'ınızla kullanın. Bu temelde kodunuzu kuyruklar sonra da belirttiği gibi vb görünümün ölçü, düzen, Romain Guy :

UI olay kuyruğu olayları sırayla işler. SetContentView () çağrıldıktan sonra, olay kuyruğunda geçiş izni isteyen bir ileti bulunur, bu nedenle kuyruğa gönderdiğiniz her şey mizanpaj geçişinden sonra gerçekleşir

Misal:

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

Avantajı ViewTreeObserver:

• kodunuz yalnızca bir kez yürütülür ve bir güçlük olabilen yürütme işleminden sonra Gözlemciyi devre dışı bırakmanız gerekmez
• daha az ayrıntılı sözdizimi

Referanslar:

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

3. Görünümlerin onLayout Yönteminin Üzerine Yaz

Bu sadece mantığın görünümde kapsüllenebileceği belirli durumlarda pratiktir, aksi takdirde bu oldukça ayrıntılı ve hantal bir sözdizimidir.

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

Ayrıca, onLayout'un birçok kez çağrılacağını unutmayın, bu nedenle yöntemde ne yaptığınızı düşünün veya ilk kez kodunuzu devre dışı bırakın

4. Düzen aşamasından geçip geçmediğini kontrol edin

Kullanıcı arabirimini oluştururken birden çok kez yürütülen kodunuz varsa, aşağıdaki destek v4 lib yöntemini kullanabilirsiniz:

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

Görünüm, bir pencereye en son eklendiğinden veya pencereden ayrıldığından beri en az bir mizanpajdan geçtiğinde true değerini döndürür.

Ek: Statik olarak tanımlanmış ölçümler alma

Sadece statik olarak tanımlanmış yükseklik / genişlik elde etmek yeterliyse, bunu aşağıdakilerle yapabilirsiniz:

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

Ancak, bunun çizimden sonra gerçek genişlik / yükseklikten farklı olabileceğini unutmayın. Javadoc farkı mükemmel bir şekilde anlatıyor:

Bir görünümün boyutu, genişlik ve yükseklik ile ifade edilir. Bir görünüm aslında iki çift genişlik ve yükseklik değerine sahiptir.

İlk çift ölçülen genişlik ve ölçülen yükseklik olarak bilinir. Bu boyutlar, bir görünümün üst öğesi içinde ne kadar büyük olmasını istediğini tanımlar (daha fazla ayrıntı için Düzen'e bakın.) Ölçülen boyutlar, getMeasuredWidth () ve getMeasuredHeight () çağrılarak elde edilebilir.

İkinci çift basitçe genişlik ve yükseklik veya bazen çizim genişliği ve çizim yüksekliği olarak bilinir. Bu boyutlar ekrandaki görünümün, çizim zamanında ve mizanpajdan sonra gerçek boyutunu tanımlar. Bu değerler ölçülen genişlik ve yükseklikten farklı olabilir, ancak zorunlu değildir. Genişlik ve yükseklik getWidth () ve getHeight () çağrılarak elde edilebilir.

Kullanabiliriz

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

Ben onWindowFocusChanged () daha iyi olduğunu düşünüyorum bu çözümü kullandım. Bir DialogFragment'ı açar ve telefonu döndürürseniz, onWindowFocusChanged yalnızca kullanıcı iletişim kutusunu kapattığında çağrılır):

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

Düzenleme: removeGlobalOnLayoutListener kullanımdan kaldırıldığı için şimdi şunları yapmanız gerekir:

@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 :)
}

Ian'ın bu Android Geliştiricileri iş parçacığında belirttiği gibi :

Her neyse, anlaşma, bir pencerenin içeriğinin düzeninin, tüm öğeler oluşturulduktan ve üst görünümlerine eklendikten sonra gerçekleşmesidir . Bu şekilde olmalı, çünkü bir Görünümün hangi bileşenleri içerdiğini ve neleri içerdiğini ve benzeri şeyleri öğrenene kadar, onu yerleştirmenin mantıklı bir yolu yoktur.

Alt satırda, bir kurucuda getWidth () vb. Olarak çağırırsanız, sıfır döndürür. Yordam, yapıcıdaki tüm görünüm öğelerinizi oluşturmak, sonra Görünümünüzün onSizeChanged () yönteminin çağrılmasını beklemektir - bu, gerçek boyutunuzu ilk kez bulduğunuzda, GUI öğelerinizin boyutlarını ayarladığınız zamandır.

Ayrıca onSizeChanged () işlevinin bazen sıfır parametreleriyle çağrıldığına dikkat edin - bu durumu kontrol edin ve hemen geri dönün (böylece düzeninizi hesaplarken sıfıra bölünmezsiniz). Bir süre sonra gerçek değerlerle çağrılır.

Ekranda görüntülenmeden önce bazı widget'ların genişliğini almanız gerekiyorsa, getMeasuredWidth () veya getMeasuredHeight () kullanabilirsiniz.

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

Diğer dinleyicilerden biraz daha erken çağrıldığından OnPreDrawListener()bunun yerine kullanmayı tercih ederim addOnGlobalLayoutListener().

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

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

Global düzende gözlemlemek ve yükseklik dinamik olarak hazır olduğunda belirli bir görevi yerine getirmek için bir Kotlin Uzantısı.

Kullanımı:

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

Uygulama:

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, bu tür işlerde size yardımcı olan birden fazla uzantı işlevine sahiptir. androidx.core.view

Bunun için Kotlin'i kullanmanız gerekir.

Burada en uygun olanı doOnLayout:

Bu görünüm ortaya konulduğunda verilen eylemi gerçekleştirir. Görünüm düzenlenmişse ve bir düzen istenmediyse, eylem hemen gerçekleştirilir, aksi takdirde görünüm bir sonraki düzenlendikten sonra eylem gerçekleştirilir.

Eylem bir sonraki mizanpajda yalnızca bir kez çağrılır ve ardından kaldırılır.

Örneğinizde:

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

Bağımlılık: androidx.core:core-ktx:1.0.0

RxJava & RxBindings kullanıyorsanız bir astar . Isıtıcı plaka olmadan benzer yaklaşım. Bu aynı zamanda, Tim Autin'in cevabındaki gibi uyarıları bastırmak için hack'i de çözer .

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

Budur. Hiç çağrılmasa bile abonelikten çıkmanıza gerek yoktur.

Bunun nedeni, görünümün şişirilmesi için daha fazla zamana ihtiyaç duymasıdır. Bu nedenle, çağırmak view.widthve view.heightana iş parçacığı yerine , zaten şişirilmiş view.post { ... }olduğundan emin olmak için kullanmalısınız view. Kotlin'de:

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

Java'da ayrıca a yöntemlerini arayabilir getWidth()ve to yöntemini iletebilirsiniz .getHeight()RunnableRunnableview.post()

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

Yükseklik ve genişlik sıfırdır, çünkü görünüm yükseklik ve genişlik istediğiniz zamana göre oluşturulmamıştır. En basit çözümlerden biri

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

Bu yöntem, kısa ve net olduğu için diğer yöntemlere kıyasla iyidir.

Belki bu birine yardımcı olur:

View sınıfı için bir uzantı işlevi oluşturma

dosyaadı: 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()
            }
        })
    }
}

Bu daha sonra aşağıdakilerle herhangi bir görünümde kullanılabilir:

view.afterLayout {
    do something with view.height
}

İle cevap postyanlıştır, çünkü boyut yeniden hesaplanmamış olabilir.
Bir diğer önemli şey, görüşün ve tüm atalarının görünür olması gerektiğidir . Bunun için bir özellik kullanıyorum View.isShown.

İşte benim kotlin fonksiyonu, bu utils bir yere yerleştirilebilir:

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

Ve kullanımı:

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

Kotlin kullanıyorsanız

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

Gone görünümleri, uygulama arka planda ise yükseklik olarak 0 değerini döndürür. Bu kodum (% 1oo çalışır)

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

Görünümün çizilmesi için beklememiz gerekiyor. Bu amaçla OnPreDrawListener kullanın. Kotlin örneği:

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)