39 Soru: Ekran boyutlarını piksel cinsinden alın

tarafından oluşturulan soru Sun, Jul 3, 2016 12:00 AM

Bazı özel öğeler oluşturdum ve bunları programlı olarak sağ üst köşeye (üst kenardan n piksel ve sağ kenardan m piksel) yerleştirmek istiyorum. Bu nedenle, ekran genişliğini ve ekran yüksekliğini almam ve sonra konumunu ayarlamam gerekiyor:

 
int px = screenWidth - m;
int py = screenHeight - n;

Ana Faaliyet’te screenWidth ve screenHeight’u nasıl alabilirim?

    
1776
  1. px yerine dp kullanın. çünkü düzeninizi diğer cihazlarla bozacak ..
    2014-04-24 06: 13: 33Z
  2. getResources (). getDisplayMetrics (). ekran ölçeklendirmesi için hesaplanacak yoğunlukla çarpmayı unutmayın.
    2014-06-16 12: 53: 23Z
  3. Bu, en çok oy alan cevabın her zaman en iyi olmadığını kanıtlar (&çok sayıda kişi rep için yanıtları tekrarlar). GetSize ve kullanımdan kaldırılan getWidth /getHeight combo (hataları yok sayarak) yerine, Balaji.K getMetrics'u deneyin. Nik'in cevabındaki yorumu bile getDisplayMetrics'u sistem /durum çubuğu boyutunu göz önüne aldığını açıklıyor. Ayrıca, jmaculate ve EXACT değerine sahip olduğunun açıklandığı şekilde yoğunluğu da kullanabilirsiniz. DisplayMetrics dm = getResources().getDisplayMetrics(); float fwidth = dm.density * dm.widthPixels; Android v2.2'de (API 8) ve v4.0'da iyi sonuçlar ve hata /uyarı yok .
    2014-09-02 10: 32: 11Z
  4. DisplayMetrics displaymetrics = new DisplayMetrics (); . GetWindowManager () getDefaultDisplay () getMetrics (displaymetrics.); int height = displaymetrics.heightPixels; int width = displaymetrics.widthPixels;
    2015-05-01 05: 30: 15Z
  5. DisplayMetrics'i elde etmenin başka bir yolu: Resources.getSystem().getDisplayMetrics(). Onları almak için Context’a ihtiyacınız olmayacak.
    2019-02-08 08: 56: 01Z
30 Yanıtlar                              30                         

Ekran boyutlarını piksel cinsinden görmek istiyorsanız getSize :

 
Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

Activity’da değilseniz, varsayılan Display’u WINDOW_SERVICE’dan alabilirsiniz:

 
WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
Display display = wm.getDefaultDisplay();

Bir parçasıysanız ve bunu tamamlamak istiyorsanız, sadece Activity.WindowManager (Xamarin.Android içinde) veya getActivity (). getWindowManager () (java'da) kullanın.

getSize tanıtılmadan önce (API 13 düzeyinde), şu anda kullanımdan kaldırılan getWidth ve getHeight yöntemlerini kullanabilirsiniz:

 
Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

Ancak tanımladığınız kullanım durumunda, mizanpajdaki bir kenar boşluğu /dolgusu daha uygun görünüyor.

Başka bir yol şudur: DisplayMetrics

  

Boyutu, yoğunluğu ve yazı tipi ölçeklendirmesi gibi bir ekran hakkında genel bilgileri tanımlayan bir yapı. DisplayMetrics üyelerine erişmek için şuna benzer bir nesne başlat:

 
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

widthPixels'u bilgi almak için kullanabiliriz:

  

"Ekranın mutlak genişliği piksel cinsinden."

Örnek:

 
Log.d("ApplicationTagName", "Display width in px is " + metrics.widthPixels);
    
3420
2018-10-30 10: 28: 03Z
  1. 2010-11-20 04: 18: 00Z
  2. getWidth () veya getSize ()? Uygulamamın API < 13 yanı sıra API > 13 üzerinde çalışmasına ihtiyacım olursa ne kullanırdım?
    2012-04-01 05: 29: 20Z
  3. deneyin {display.getSize (size); genişlik = size.x; yükseklik = size.y; } catch (NoSuchMethodError e) {width = display.getWidth (); height = display.getHeight (); }
    2012-05-12 11: 41: 31Z
  4. Böyle bir çek için neden try/catch kullanmak istediğinizi anlamıyorum? Neden if (android.os.Build.VERSION.SDK_INT >= 13)'u hiç atılmış istisna olmadan kullanmıyorsunuz? Normal bir uygulamada try/catch'u kötü uygulama olarak düşünüyorum.
    2012-11-28 15: 41: 05Z
  5. gezinme çubuğu ve /veya bildirim çubuğu hariç ekran boyutunu almak istiyorsanız
    2013-05-12 23: 24: 57Z

Tek yönlü:

 
Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();
int height = display.getHeight();

Kullanımdan kaldırıldı ve bunun yerine aşağıdaki kodu denemelisiniz. İlk iki kod satırı size DisplayMetrics objeyi verir. Bu nesneler heightPixels, widthPixels gibi alanları içerir.

 
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

int height = metrics.heightPixels;
int width = metrics.widthPixels;
    
360
2019-05-22 18: 29: 11Z
  1. Metriklerin (genişlik, yükseklik) cihazın dönüşüne bağlı olarak değiştiğini unutmayın.
    2011-11-28 02: 17: 53Z
  2. Metrikler ekranın boyutunu döndürür, ancak HoneyComb ve üzeri, etkinliğiniz, sistem çubuğu nedeniyle döndürülenlerden daha az alana sahip olur.
    2011-12-29 11: 12: 10Z
  3. @ Guy sizin uygulamanıza bağlı. Durum çubuğunu gizleyebilirsiniz: requestWindowFeature (Window.FEATURE_NO_TITLE); getWindow (). setFlags (WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);;
    2012-03-28 11: 00: 27Z
  4. Bu şekilde de var: getContext (). getResources (). getDisplayMetrics (). widthPixels
    2012-07-11 05: 32: 47Z
  5. final float scale = getResources (). getDisplayMetrics (). density; int genişlik = (int) (metrik. genişlik piksel * ölçek + 0,5f); - Bu şekilde yaparken cihaz yoğunluğunu hesaba katmanız gerekir.
    2014-02-20 04: 45: 27Z

Sorunuza cevap vermeyebilir, ancak bir View'ın boyutuna ihtiyacınız varsa ancak düzeniniz kullanılmadığında kodunuzun çalıştırıldığını bilmek yararlı olabilir (bu soruya geldiğimde kendim arıyordum). henüz ortaya kondu (örneğin onCreate()'da) ViewTreeObserver.OnGlobalLayoutListener ile View.getViewTreeObserver().addOnGlobalLayoutListener() kurabilir ve görünümün boyutuna ihtiyaç duyan ilgili kodu oraya koyabilirsiniz. Mizanpajın düzenlenmesi sırasında dinleyicinin geri araması aranacaktır.

    
114
2011-04-06 21: 23: 00Z
  1. veya sadece view.post yazın
    2013-09-19 09: 27: 31Z
  2. hızlı uygulama için bir karar :) özü. github.com/doridori/9208247
    2014-02-25 12: 55: 48Z
  3. view.post olsa da çalışması garanti edilmez. Bu sadece bir geçici çözümdür.
    2014-02-25 14: 31: 05Z
  4. @ marsbear, nerede View.post()'un çalışmasının garanti edilmediğini söylüyor? Merak ediyorum çünkü ayrıca V almak için bu yönteme güveniyorum.iew düzeninden sonra boyutu ve güvenilmez olduğunu bilmiyordum.
    2014-03-22 00: 20: 16Z
  5. @ Turbo Diyorum ki: p Daha önce bu geçici çözümü kullandık ve güvenilmez olduğu ortaya çıktı. Bu geçici çözüm, başlangıçta düzenlemenin, başlatma ile aynı UIThread dönüşünde yapıldığı varsayımına dayanır. Bu nedenle, kodunuzu bir sonraki kullanıcı arayüzünden post () aracılığıyla çevirmeden önce çalışacak ve iyi olacak şekilde zamanlayabilirsiniz. Düzenlemenin belirli şartlar altında daha uzun sürebileceği ve yayınlanan kod çalıştırıldığında görünümün hala düzenlenmediği ortaya çıktı. Şimdi ne yapacağım ViewTreeObserver'ı onCreate'a eklemek ve ilk onLayout'tan sonra kaldırmak. İlk onLayout'taki eşyalarınızı başlatın.
    2014-03-28 15: 30: 21Z

(2012 cevabı, eski olabilir) Honeycomb öncesi destek vermek istiyorsanız, API 13'ten önce geriye dönük uyumluluk koymanız gerekir. Şunun gibi bir şey:

 
int measuredWidth = 0;
int measuredHeight = 0;
WindowManager w = getWindowManager();

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    Point size = new Point();
    w.getDefaultDisplay().getSize(size);
    measuredWidth = size.x;
    measuredHeight = size.y;
} else {
    Display d = w.getDefaultDisplay();
    measuredWidth = d.getWidth();
    measuredHeight = d.getHeight();
}

Elbette kullanımdan kaldırılmış yöntemler en son SDK'lardan çıkarılacak, ancak Android 2.1, 2.2 ve 2.3'e sahip olan kullanıcılarımızın çoğuna güvenmeye devam ederken, geriye kalan şey bu.

    
104
2015-06-22 22: 47: 22Z
  1. Evet, bu 2012'ye geri döndü.
    2015-06-22 22: 46: 04Z
  2. Üzgünüm, ne demek istediğimi netleştirmeme izin verin. API’nin 6/22/2015 tarihinden itibaren 2015-06-23 04: 24: 09Z

Tüm olası "çözümleri" başarısızlıkla denedim ve Elliott Hughes'un "Dalvik Explorer" uygulamasının herhangi bir Android cihaz /işletim sistemi sürümünde her zaman doğru boyutu gösterdiğini fark ettim. Burada bulunabilecek açık kaynaklı projesine baktım: https://code.google.com/p/enh/

İşte tüm ilgili kod:

 
WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
try {
    // used when 17 > SDK_INT >= 14; includes window decorations (statusbar bar/menu bar)
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
try {
    // used when SDK_INT >= 17; includes window decorations (statusbar bar/menu bar)
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}

EDIT: biraz iyileştirilmiş sürüm (desteklenmeyen işletim sistemi sürümünde istisnaları kaldırmaktan kaçının):

 
WindowManager w = activity.getWindowManager();
Display d = w.getDefaultDisplay();
DisplayMetrics metrics = new DisplayMetrics();
d.getMetrics(metrics);
// since SDK_INT = 1;
widthPixels = metrics.widthPixels;
heightPixels = metrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
try {
    widthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(d);
    heightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(d);
} catch (Exception ignored) {
}
// includes window decorations (statusbar bar/menu bar)
if (Build.VERSION.SDK_INT >= 17)
try {
    Point realSize = new Point();
    Display.class.getMethod("getRealSize", Point.class).invoke(d, realSize);
    widthPixels = realSize.x;
    heightPixels = realSize.y;
} catch (Exception ignored) {
}
    
65
2013-07-19 06: 30: 31Z
  1. Bu, pencere dekorasyonlarını (durum çubuğu /menü çubuğu) dikkate alan tek yazıdır. benim için harika çalıştı.
    2013-05-31 20: 24: 39Z
  2. Harika, ancak hiçbir zaman iş mantığı yangın istisnası beklememelisiniz. İstisna ateşleme (yakalandığında bile) performans için korkunçtur. Artı, eğer SDK_INT ise > 13. Bunun yerine, Build.VERSION.SDK_INT.
    'e sadece ifs eklemelisiniz.
    2013-06-21 23: 15: 13Z
  3. @ Erik B, katılıyorum. Geliştirilmiş sürüm ekledim. Yine de "SDK 1'den beri" kısmından ayrıldım, sadece denemek /yakalamakta bir şeyler ters giderse (özellikle de yanlış gitmenin imkansız olduğunu düşündüğünüzde Android'de çok kötü şeyler gördüm, bu yüzden onu güvende tutmak istiyorum :)) . Her neyse, bu hesaplamanın yalnızca bir kez yapılması gerektiğinden fazla mouch eksi olmamalıdır (örneğin, değerler bazı statik niteliklerde tutulabilir).
    2013-06-22 16: 41: 28Z
  4. Bu kodun, üretim uygulamalarında kullanım için etkileri olan GPL v3 kapsamında lisanslandığını unutmayın.
    2013-08-12 02: 00: 51Z
  5. GPL ve gelecek Android sürümlerinde bulunmayabilecek çağrı yöntemlerine yansımalarına bağlı olarak. Mhhh
    2015-11-14 15: 41: 26Z

En basit yol:

 
 int screenHeight = getResources().getDisplayMetrics().heightPixels;
 int screenWidth = getResources().getDisplayMetrics().widthPixels; 
    
46
2014-11-26 10: 47: 10Z

Android cihazlar için durum çubuğunun yüksekliğine erişmek için, onu almanın programlı bir yolunu tercih ediyoruz:

Örnek kod

 
int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
if (resId > 0) {
    result = getResources().getDimensionPixelSize(resId);
}

result değişkeni pikseldeki yüksekliği verir.

Hızlı erişim için

Resim tanımını buraya girin

Title bar, Navigation bar ve Content View'un yüksekliği hakkında daha fazla bilgi için lütfen Android Cihaz Ekranı Boyutları'na bakın. .

    
46
2015-11-12 11: 26: 49Z
  1. Sadece ihtiyacım olan şey! getResources().getDisplayMetrics().heightPixels + result gerçek tam ekran yüksekliği verir. Dragan Marjanović'in cevabı da işe yarıyor ama ben çok daha kısa ve daha basit bir çözümü tercih ediyorum.
    2015-11-14 15: 35: 21Z
  2. Bu yaklaşım Android Hatmi tarihi itibariyle eskidir. Durum çubuğu yüksekliği cihazdan veya Android sürümünden değişebilir. Daha iyi kullanmak OnApplyWindowInsetsListener .
    2016-02-21 13: 20: 32Z

Önce görün (örneğin, findViewById()) ve sonra getWidth () .

    
30
2015-11-12 11: 27: 47Z
  1. Bu aslında belgelerin size yapmasını söyleyeceği şeydir ... ama bir görünüm kullanmıyorsanız, bu biraz anlamsız. başka bir şey kullanıyor olabilirsiniz, ör. mglsurfaceview.
    2010-11-20 02: 22: 12Z
  2. , ebeveyn görünümü ekranın boyutu olmadığından daha iyidir. Ancak bunun, sorguladığınız görünümün zaten yerleştirildiği ve genellikle onCreate () içinde olmayacak bir noktada yapıldığından emin olun. Tüm görünümler ölçüldükten sonra çağrılacak olan onWindowFocusChanged (boolean hasFocus) öğesinden özel bir geri arama kullanabilirsiniz, böylece ilgilendiğiniz görünüm için yanlış boyutlar alamazsınız ...
    2011-03-01 13: 02: 44Z

Biri içeriği göndermek, diğeri piksel cinsinden yükseklik ve genişlik almak için iki işleve sahibim:

 
public static int getWidth(Context mContext){
    int width=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        width = size.x;
    }
    else{
        width = display.getWidth();  // Deprecated
    }
    return width;
}

ve

 
public static int getHeight(Context mContext){
    int height=0;
    WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    if(Build.VERSION.SDK_INT>12){
        Point size = new Point();
        display.getSize(size);
        height = size.y;
    }
    else{
        height = display.getHeight();  // Deprecated
    }
    return height;
}
    
26
2014-02-09 15: 46: 32Z
  1. Derleyebilmek için işlev imzasının hemen üstüne @SuppressLint("NewApi") eklemeniz gerekir.
    2013-10-14 15: 09: 02Z
  2. API'lere yapılan ayrı çağrılardan ziyade bir seferde yükseklik ve genişliği elde etmenin daha iyi olacağını düşünüyorum çünkü aksi halde senkronizasyon dışında olabilirler. Kodunuz çalışırken ekran yönlendirmesi değişiyorsa bu olabilir.
    2015-05-26 05: 50: 53Z

XML kullanarak dinamik olarak ölçeklendirme için "android: layout_weight"

adında bir özellik var.

Aşağıdaki örnek, bu konudaki synic yanıtından değiştirildi , ekranın% 75'ini kaplayan bir düğme (ağırlık = .25) ve ekranın kalan% 25'ini (metin = .75) alan bir metin görünümünü gösterir.

 
<LinearLayout android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:orientation="horizontal">

    <Button android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_weight=".25"
        android:text="somebutton">

    <TextView android:layout_width="fill_parent"
        android:layout_height="Wrap_content"
        android:layout_weight=".75">
</LinearLayout>
    
17
2017-05-23 11: 33: 26Z

Bu, görev için kullandığım kod:

 
// `activity` is an instance of Activity class.
Display display = activity.getWindowManager().getDefaultDisplay();
Point screen = new Point();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    display.getSize(screen);
} else {            
    screen.x = display.getWidth();
    screen.y = display.getHeight();
}

Yeterince temiz görünüyor ve henüz amortismanla ilgileniyor.

    
17
2012-12-27 14: 31: 01Z

Bu daha iyi bir çözüm değil mi? DisplayMetrics ihtiyacınız olan her şeyle birlikte gelir ve API 1'den çalışır.

 
public void getScreenInfo(){
    DisplayMetrics metrics = new DisplayMetrics();
    getActivity().getWindowManager().getDefaultDisplay().getMetrics(metrics);

    heightPixels = metrics.heightPixels;
    widthPixels = metrics.widthPixels;
    density = metrics.density;
    densityDpi = metrics.densityDpi;
}

getRealMetrics , ancak bu yalnızca 17+ üzerinde çalışır.

Bir şey mi eksik?

    
17
2013-05-12 20: 16: 20Z
  1. Ekran denetimleri için (tabletlerde veya Nexus aygıtlarında olduğu gibi) alan çıkarılmaz. Ayrıca, hesaplama yapılırken Faaliyetin etkin olup olmamasına bağlı olarak 10 inçlik Tabletimde farklı bir değer (750 - 800) alıyorum.
    2013-10-10 01: 38: 18Z

    Sadece Francesco'nun cevabına ekledim. Penceredeki konumu veya ekrandaki konumu bulmak istiyorsanız, daha uygun olan diğer gözlemci ViewTreeObserver.OnPreDrawListener.html"> ViewTreeObserver.OnPreDrawListener ()

    Bu aynı zamanda, onCreate () saatinde çoğunlukla bilinmeyen bir görünümün diğer özelliklerini bulmak için de kullanılabilir. kaydırılan konum, ölçeklenen konum.

        
    15
    2012-03-16 07: 15: 23Z

    Ekranın genişliğini ve yüksekliğini bulun:

     
    width = getWindowManager().getDefaultDisplay().getWidth();
    height = getWindowManager().getDefaultDisplay().getHeight();
    

    Bunu kullanarak, en son ve en yüksek SDK 13'ü alabiliriz.

     
    // New width and height
    int version = android.os.Build.VERSION.SDK_INT;
    Log.i("", " name == "+ version);
    Display display = getWindowManager().getDefaultDisplay();
    int width;
    if (version >= 13) {
        Point size = new Point();
        display.getSize(size);
        width = size.x;
        Log.i("width", "if =>" +width);
    }
    else {
        width = display.getWidth();
        Log.i("width", "else =>" +width);
    }
    
        
    15
    2014-02-10 03: 38: 40Z

    Etkinlik’te aşağıdaki kodu kullanma.

     
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    int height = metrics.heightPixels;
    int wwidth = metrics.widthPixels;
    
        
    14
    2012-03-19 14: 58: 56Z
     
    DisplayMetrics dimension = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(dimension);
    int w = dimension.widthPixels;
    int h = dimension.heightPixels;
    
        
    14
    2014-02-10 03: 45: 19Z

    Bunu hile yaptım buldum.

     
    Rect dim = new Rect();
    getWindowVisibleDisplayFrame(dim);
    
        
    11
    2012-01-06 19: 35: 27Z
    1. Harika ama kaynak kodda bu yöntemle ilgili korkutucu bir şey var: bu yorumu
      2012-07-19 08: 48: 24Z

    Activity’da değil, View’da (veya kapsamınızdaki View türünde bir değişkenin varsa), WINDOW_SERVICE’u kullanmanız gerekmediğini söylemeniz gerekir. Ardından en az iki yol kullanabilirsiniz.

    İlk:

     
    DisplayMetrics dm = yourView.getContext().getResources().getDisplayMetrics();
    

    İkincisi:

     
    DisplayMetrics dm = new DisplayMetrics();
    yourView.getDisplay().getMetrics(dm);
    

    Burada çağırdığımız tüm bu yöntemler kullanımdan kaldırılmış değil.

        
    11
    2013-03-16 02: 21: 42Z
     
    public class AndroidScreenActivity extends Activity {
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);
    
            DisplayMetrics dm = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(dm);
            String str_ScreenSize = "The Android Screen is: "
                                       + dm.widthPixels
                                       + " x "
                                       + dm.heightPixels;
    
            TextView mScreenSize = (TextView) findViewById(R.id.strScreenSize);
            mScreenSize.setText(str_ScreenSize);
        }
    }
    
        
    11
    2014-02-10 03: 40: 46Z

    Ekran boyutlarını almak için ekran ölçümlerini kullanın

     
    DisplayMetrics displayMetrics = new DisplayMetrics();
    if (context != null) 
          WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
          Display defaultDisplay = windowManager.getDefaultDisplay();
          defaultDisplay.getRealMetrics(displayMetrics);
        }
    

    Yüksekliği ve genişliği piksel cinsinden alın

     
    int width  =displayMetrics.widthPixels;
    int height =displayMetrics.heightPixels;
    
        
    9
    2017-11-21 10: 33: 08Z

    Ekran boyutlarını gerçek piksel cinsinden istediği için bu OP için bir cevap değildir. Boyutları "aygıttan bağımsız pikseller" de istedim ve yanıtları buradan bir araya getirdim https://stackoverflow.com/a/17880012 /253938 ve burayı https://stackoverflow.com/a/6656774/253938 :

     
        DisplayMetrics displayMetrics = Resources.getSystem().getDisplayMetrics();
        int dpHeight = (int)(displayMetrics.heightPixels / displayMetrics.density + 0.5);
        int dpWidth = (int)(displayMetrics.widthPixels / displayMetrics.density + 0.5);
    
        
    8
    2017-05-23 12: 02: 56Z

    Bunu, TryMetrics'i (API 1) kullanarak denemek /yakalamak dağınıklığı önlemek için yapmanın itiraz edilmemiş bir yolu vardır:

     
     // initialize the DisplayMetrics object
     DisplayMetrics deviceDisplayMetrics = new DisplayMetrics();
    
     // populate the DisplayMetrics object with the display characteristics
     getWindowManager().getDefaultDisplay().getMetrics(deviceDisplayMetrics);
    
     // get the width and height
     screenWidth = deviceDisplayMetrics.widthPixels;
     screenHeight = deviceDisplayMetrics.heightPixels;
    
        
    7
    2012-12-19 14: 39: 49Z

    getSize kodunu bu şekilde sarardım:

     
    @SuppressLint("NewApi")
    public static Point getScreenSize(Activity a) {
        Point size = new Point();
        Display d = a.getWindowManager().getDefaultDisplay();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            d.getSize(size);
        } else {
            size.x = d.getWidth();
            size.y = d.getHeight();
        }
        return size;
    }
    
        
    7
    2013-04-21 13: 42: 35Z
    1. Bu, Android 4.0 (API 14) çalışan bir emülatörde çöküyor.
      2014-09-05 18: 31: 31Z

    Aşağıdakileri kullanarak yükseklik boyutunu alabilirsiniz:

     
    getResources().getDisplayMetrics().heightPixels;
    

    ve genişlik boyutunu kullanarak

     
    getResources().getDisplayMetrics().widthPixels; 
    
        
    7
    2017-10-09 14: 09: 44Z

    Durum Çubuğu ve İşlem Çubuğu olmadan da ( kullanılabilir ekran boyutu arayanlar için (ayrıca Swapnil'in yanıtı sayesinde):

     
    DisplayMetrics dm = getResources().getDisplayMetrics();
    float screen_w = dm.widthPixels;
    float screen_h = dm.heightPixels;
    
    int resId = getResources().getIdentifier("status_bar_height", "dimen", "android");
    if (resId > 0) {
        screen_h -= getResources().getDimensionPixelSize(resId);
    }
    
    TypedValue typedValue = new TypedValue();
    if(getTheme().resolveAttribute(android.R.attr.actionBarSize, typedValue, true)){
        screen_h -= getResources().getDimensionPixelSize(typedValue.resourceId);
    }
    
        
    5
    2013-09-09 09: 02: 51Z

    Önce XML dosyasını yükleyin ve sonra şu kodu yazın:

     
    setContentView(R.layout.main);      
    Display display = getWindowManager().getDefaultDisplay();
    final int width = (display.getWidth());
    final int height = (display.getHeight());
    

    Ekran çözünürlüğünüze göre genişliği ve yüksekliği gösterin.

        
    5
    2014-02-09 15: 47: 39Z

    Aşağıdaki yöntemleri izleyin:

     
    public static int getWidthScreen(Context context) {
        return getDisplayMetrics(context).widthPixels;
    }
    
    public static int getHeightScreen(Context context) {
        return getDisplayMetrics(context).heightPixels;
    }
    
    private static DisplayMetrics getDisplayMetrics(Context context) {
        DisplayMetrics displayMetrics = new DisplayMetrics();
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        wm.getDefaultDisplay().getMetrics(displayMetrics);
        return displayMetrics;
    }
    
        
    5
    2016-07-01 19: 52: 58Z
    1. mContext.getResources (). getDisplayMetrics (). widthPixels; ???
      2015-12-16 11: 16: 49Z

    Bir etkinliğin onCreate öğesinde bir düzen için kullanılabilir alanın tam boyutlarını bilmeniz gereken zamanlar vardır. Bazı düşüncelerden sonra, bu şekilde yapmaya çalıştım.

     
    public class MainActivity extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            startActivityForResult(new Intent(this, Measure.class), 1);
            // Return without setting the layout, that will be done in onActivityResult.
        }
    
        @Override
        protected void onActivityResult (int requestCode, int resultCode, Intent data) {
            // Probably can never happen, but just in case.
            if (resultCode == RESULT_CANCELED) {
                finish();
                return;
            }
            int width = data.getIntExtra("Width", -1);
            // Width is now set to the precise available width, and a layout can now be created.            ...
        }
    }
    
    public final class Measure extends Activity {
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
           // Create a LinearLayout with a MeasureFrameLayout in it.
            // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
            LinearLayout linearLayout = new LinearLayout(this);
            LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.MATCH_PARENT);
            MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
            measureFrameLayout.setLayoutParams(matchParent);
            linearLayout.addView(measureFrameLayout);
            this.addContentView(linearLayout, matchParent);
            // measureFrameLayout will now request this second activity to finish, sending back the width.
        }
    
        class MeasureFrameLayout extends FrameLayout {
            boolean finished = false;
            public MeasureFrameLayout(Context context) {
                super(context);
            }
    
            @SuppressLint("DrawAllocation")
            @Override
            protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                super.onMeasure(widthMeasureSpec, heightMeasureSpec);
                if (finished) {
                    return;
                }
                finished = true;
                // Send the width back as the result.
                Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
                Measure.this.setResult(Activity.RESULT_OK, data);
                // Tell this activity to finish, so the result is passed back.
                Measure.this.finish();
            }
        }
    }
    

    Herhangi bir nedenden dolayı Android bildirimine başka bir etkinlik eklemek istemiyorsanız, bunu şu şekilde yapabilirsiniz:

     
    public class MainActivity extends Activity {
        static Activity measuringActivity;
    
        @Override
        protected void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            Bundle extras = getIntent().getExtras();
            if (extras == null) {
                extras = new Bundle();
            }
            int width = extras.getInt("Width", -2);
            if (width == -2) {
                // First time in, just start another copy of this activity.
                extras.putInt("Width", -1);
                startActivityForResult(new Intent(this, MainActivity.class).putExtras(extras), 1);
                // Return without setting the layout, that will be done in onActivityResult.
                return;
            }
            if (width == -1) {
                // Second time in, here is where the measurement takes place.
                // Create a LinearLayout with a MeasureFrameLayout in it.
                // Just putting a subclass of LinearLayout in works fine, but to future proof things, I do it this way.
                LinearLayout linearLayout = new LinearLayout(measuringActivity = this);
                LinearLayout.LayoutParams matchParent = new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
                MeasureFrameLayout measureFrameLayout = new MeasureFrameLayout(this);
                measureFrameLayout.setLayoutParams(matchParent);
                linearLayout.addView(measureFrameLayout);
                this.addContentView(linearLayout, matchParent);
                // measureFrameLayout will now request this second activity to finish, sending back the width.
            }
        }
    
        @Override
        protected void onActivityResult (int requestCode, int resultCode, Intent data) {
            // Probably can never happen, but just in case.
            if (resultCode == RESULT_CANCELED) {
                finish();
                return;
            }
            int width = data.getIntExtra("Width", -3);
            // Width is now set to the precise available width, and a layout can now be created. 
            ...
        }
    
    class MeasureFrameLayout extends FrameLayout {
        boolean finished = false;
        public MeasureFrameLayout(Context context) {
            super(context);
        }
    
        @SuppressLint("DrawAllocation")
        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
            if (finished) {
                return;
            }
            finished = true;
            // Send the width back as the result.
            Intent data = new Intent().putExtra("Width", MeasureSpec.getSize(widthMeasureSpec));
            MainActivity.measuringActivity.setResult(Activity.RESULT_OK, data);
            // Tell the (second) activity to finish.
            MainActivity.measuringActivity.finish();
        }
    }    
    
        
    4
    2013-06-09 10: 08: 13Z
    1. Açıkçası, aynı zamanda paket içindeki yüksekliği de geri alabilirsiniz.
      2013-05-22 12: 21: 34Z

    WindowManagers, Points veya Display'lerin ek yükünü istemiyorsanız, yüksekliği ve genişliği match_parent olarak ayarlanması koşuluyla XML'inizdeki en üstteki View öğesinin height ve width niteliklerini alabilirsiniz. (Bu, düzeniniz tüm ekranı kapladığı sürece geçerlidir.)

    Örneğin, XML'iniz böyle bir şeyle başlarsa:

     
    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:id="@+id/entireLayout"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    

    Ardından findViewById(R.id.entireLayout).getWidth(), ekranın genişliğini ve findViewById(R.id.entireLayout).getHeight(), ekranın yüksekliğini döndürür.

        
    4
    2013-06-26 18: 35: 05Z
    1. Nopes ... 0 döndürür.
      2013-09-20 11: 44: 03Z

    LinearLayout ile, match_parent genişliğine sahip kök görünümü olarak açılış ekranı etkinliğim var & yükseklik. Bu, bu aktivitenin onCreate() yöntemindeki koddur. Bu önlemleri uygulamanın diğer tüm faaliyetlerinde kullanıyorum.

     
    int displayWidth = getRawDisplayWidthPreHoneycomb();
    int rawDisplayHeight = getRawDisplayHeightPreHoneycomb();
    int usableDisplayHeight = rawDisplayHeight - getStatusBarHeight();
    pf.setScreenParameters(displayWidth, usableDisplayHeight);
    
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        LinearLayout myView = (LinearLayout) findViewById(R.id.splash_view);
        myView.addOnLayoutChangeListener(new OnLayoutChangeListener() {
            @Override
            public void onLayoutChange(View v, int left, int top, int right, int bottom, int oldLeft, int oldTop, int oldRight, int oldBottom) {
                if (left == 0 && top == 0 && right == 0 && bottom == 0) {
                    return;
                }
                int displayWidth = Math.min(right, bottom);
                int usableDisplayHeight = Math.max(right, bottom);
                pf.setScreenParameters(displayWidth, usableDisplayHeight);
            }
        });
    }
    

    İşte yukarıda çağırıldığını gördüğünüz yöntemlerin uygulamaları:

     
    private int getRawDisplayWidthPreHoneycomb() {
        WindowManager windowManager = getWindowManager();
        Display display = windowManager.getDefaultDisplay();
        DisplayMetrics displayMetrics = new DisplayMetrics();
        display.getMetrics(displayMetrics);
    
        int widthPixels = displayMetrics.widthPixels;
        int heightPixels = displayMetrics.heightPixels;
    
        return Math.min(widthPixels, heightPixels);
    }
    
    private int getRawDisplayHeightPreHoneycomb() {
        WindowManager w = getWindowManager();
        Display d = w.getDefaultDisplay();
        DisplayMetrics metrics = new DisplayMetrics();
        d.getMetrics(metrics);
    
        int widthPixels = metrics.widthPixels;
        int heightPixels = metrics.heightPixels;
    
        return Math.max(widthPixels, heightPixels);
    }
    
    public int getStatusBarHeight() {
        int statusBarHeight = 0;
    
        int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
        if (resourceId > 0) {
            statusBarHeight = getResources().getDimensionPixelSize(resourceId);
        }
    
        return statusBarHeight;
    }
    

    Bu, tüm API sürümleri ve farklı cihaz türleri (telefonlar ve tabletler) için herhangi bir çubuk türü (durum çubuğu, gezinti çubuğu) hariç kullanılabilir ekranın yüksekliğine ve genişliğine yol açar.

        
    3
    2017-06-20 19: 39: 15Z
kaynak yerleştirildi İşte