android programatik olarak ekran yoğunluğu almak?


516

Android'de programsal olarak ekran yoğunluğu nasıl alınır?

Demek istediğim: Mevcut cihazın ekran dpi'sini nasıl bulabilirim?


9
Birçok cevap getDisplayMetrics().xdpi, cihazın gerçek dpi'sini döndürmesi gerektiği anlamına gelir . Lütfen bu değerin, üreticiler tarafından cihazlarda tutarlı bir şekilde doğru ayarlanmadığına dikkat edin, bu nedenle bunları kullanamazsınız . Üzücü ama gerçek: gerçek dpi hakkında bilgi mevcut değil . Kaynak: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
sulai

2
getResources().getDisplayMetrics().xdpive çoğu durumda farklı olan gerçek yatay ve dikey yoğunluklarıgetResources().getDisplayMetrics().ydpi verecektir .
Ωmega

Yanıtlar:


526

Ekran hakkında DisplayMetrics yapısından bilgi alabilirsiniz :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Android doğrudan piksel eşleme kullanmasa da, bir avuç niceliklendirilmiş Yoğunluktan Bağımsız Piksel değeri kullanır ve ardından gerçek ekran boyutuna ölçeklenir. Yani metrics.densityDpimülkiyet biri olacak DENSITY_xxxsabitleri ( 120, 160, 213, 240, 320, 480veya 640dpi).

Gerçek lcd piksel yoğunluğuna ihtiyacınız varsa (belki bir OpenGL uygulaması için) sırasıyla yatay ve dikey yoğunluk özelliklerinden metrics.xdpive metrics.ydpiözelliklerinden alabilirsiniz .

4'ten önceki API Düzeylerini hedefliyorsanız metrics.density, özellik referans yoğunluğundan (160dpi) bir kayan nokta ölçeklendirme faktörüdür. Şimdi sağladığı aynı değer metrics.densityDpihesaplanabilir

int densityDpi = (int)(metrics.density * 160f);

42
Bu yayının iki yıldan uzun bir süre önce verildiğini, ancak bu arama için Google'da gelen ilk şey budur, bu yüzden bunu bulan herkes için artık 160 ile çarpmanız gerekmez.
roboguy12

5
Artık hangi versiyondan beri yok?
TacB0sS

Cevabı, kullanıcıların kullanıyor olabileceği en son API düzeltmelerine uyacak şekilde güncelledik.
joshperry

6
Not: Bunun yerine bu yeni API'yi isteyebilirsiniz: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); Bu, API 17'ye resmen eklendi, ancak denediğim 4.0 cihazında bile doğru çalıştığını bulmak beni şaşırttı.
benkc

2
densityDpi
amorenew 8 Ocak'ta

367

Bu da işe yarar:

 getResources().getDisplayMetrics().density;

Bu size:

0.75 - ldpi

1.0 - mdpi

1.5 - hdpi

2,0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

resim açıklamasını buraya girin

ref: yoğunluk

resim açıklamasını buraya girin

ref 2


10
+1 Bu, doğrudan erişiminiz olmadığında çalışır WindowManager(örneğin, bir Yükleyicinin içinde). Sadece 160 ile çarpın
Michał K

2
API Seviye 16, xxdpi'yi ekledi.
QED

3
bu için 1.3312501 verecektir tvdpi. Daha fazla bilgi için burayatvdpi bakın
Dori

2
Nexus 7 rapor 1.3, neden parantez girmeli?
Neil

1
@selbie, telefonunuz iki tanımlı yoğunluğun yarısını bildirdiği için muhtemelen daha yüksek kaliteli kaynakları çekiyor ve ölçekliyor.
Sakiboy

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

switch(metrics.densityDpi) {
     case DisplayMetrics.DENSITY_LOW:
         break;

     case DisplayMetrics.DENSITY_MEDIUM:
         break;

     case DisplayMetrics.DENSITY_HIGH:
         break;
}

Bu, API seviye 4 ve üstü için çalışır.


DensityDpi'yi 213 olarak bildiren Nexus 7 gibi cihazları nasıl teslim edersiniz?
Neil

yoğunluk değeri arasında if gibi başka bir kontrole sahipseniz (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
Mitul Nakum

1
VEYA if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} else if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
Mitul Nakum

1
Neil, 213'e TV DPI denir, bu DENSITY_TV için adlandırılmış bir görüntüleme metrikleri yoğunluğu vardır.
Andrew S

63

Statik bir yardımcı yöntem olarak Blundell'in cevabı:

private static String getDensityName(Context context) {
    float density = context.getResources().getDisplayMetrics().density;
    if (density >= 4.0) {
        return "xxxhdpi";
    }
    if (density >= 3.0) {
        return "xxhdpi";
    }
    if (density >= 2.0) {
        return "xhdpi";
    }
    if (density >= 1.5) {
        return "hdpi";
    }
    if (density >= 1.0) {
        return "mdpi";
    }
    return "ldpi";
}

tvdpi yoğunluğu hakkında. Sanırım 1,33
Anoop

@AnoopssGolden Gerçekten standart değil, bu yüzden isterseniz ekleyebilirsiniz, ancak cevabın bunu içermesi gerektiğini düşünmüyorum. Android belgelerinden: "Bu bir" birincil "yoğunluk grubu olarak kabul edilmez. Çoğunlukla televizyonlar için tasarlanmıştır ve çoğu uygulama buna ihtiyaç duymaz".
qwertzguy

Ancak nexus 7 cihazı tvdpi yoğunluk grubuna aittir.
Anoop

1
Bu biraz eski ama sadece eklemek için biliyorum; MDPI, bir Nexus 7'deki çoğu şey için işe yarayabilir, ancak şu anda denediğim gibi, MDPI olarak gelen görüntüler yeterince büyük değil. TVDPI'yi tanımlamak ve daha sonra sunucumdan daha büyük bir görüntü boyutu istemek zorundayım. Çok fazla kullanılmayabilir, ancak bu MDPI'nın her şeyi alacağı anlamına gelmez.
RED_

3
Hey @Andrew S, elses kullanmak kodun verimliliğini değiştirmez, çünkü her if hemen geri döner. Parantezleri kaldırmak yalnızca bir stil meselesidir ve IMHO, kodu korurken daha fazla hataya neden olur.
qwertzguy

45

Bunu dene:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;

5
Bunu, aktiviteden ziyade bağlama bağlı olduğu için daha çok seviyorum.
greg7gkb

Kabul ediyorum, bunu Viewçok daha kolay bir şekilde kullanabilirim (ki ihtiyacım olan yer bu!)
Andrew Wyld

37

Dpi almak için:

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

// will either be DENSITY_LOW, DENSITY_MEDIUM or DENSITY_HIGH
int dpiClassification = dm.densityDpi;

// these will return the actual dpi horizontally and vertically
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

4
dm.densityDpi, DENSITY_LOW veya DENSITY_MEDIUM veya DENSITY_HIGH döndürür. Xhdpi ne olacak? DENSITY_XHIGH veya benzeri var mı?
Eugene Chumak


34

İşte yoğunluk sabitleri, kaynak :

resim açıklamasını buraya girin

Standart yoğunluklara ek olarak 5 Ara madde de vardır. Bu gerçeği göz önünde bulundurarak, aşağıdaki kod tam bir çalışma örneği olacaktır:

float density = getResources().getDisplayMetrics().density;

if (density == 0.75f)
{
    // LDPI
}
else if (density >= 1.0f && density < 1.5f)
{
    // MDPI
}
else if (density == 1.5f)
{
    // HDPI
}
else if (density > 1.5f && density <= 2.0f)
{
    // XHDPI
}
else if (density > 2.0f && density <= 3.0f)
{
    // XXHDPI
}
else
{
    // XXXHDPI 
}

Alternatif olarak, aşağıdakileri kullanarak yoğunluk sabitlerini bulabilirsiniz densityDpi:

int densityDpi = getResources().getDisplayMetrics().densityDpi;

switch (densityDpi)
{
    case DisplayMetrics.DENSITY_LOW:
        // LDPI
        break;

    case DisplayMetrics.DENSITY_MEDIUM:
        // MDPI
        break;

    case DisplayMetrics.DENSITY_TV:
    case DisplayMetrics.DENSITY_HIGH:
        // HDPI
        break;

    case DisplayMetrics.DENSITY_XHIGH:
    case DisplayMetrics.DENSITY_280:
        // XHDPI
        break;

    case DisplayMetrics.DENSITY_XXHIGH:
    case DisplayMetrics.DENSITY_360:
    case DisplayMetrics.DENSITY_400:
    case DisplayMetrics.DENSITY_420:
        // XXHDPI
        break;

    case DisplayMetrics.DENSITY_XXXHIGH:
    case DisplayMetrics.DENSITY_560:
        // XXXHDPI
        break;
}

29

Aşağıdaki cevap qwertzguy'un cevabına dayanan küçük bir gelişmedir.

double density = getResources().getDisplayMetrics().density;
if (density >= 4.0) {
   //"xxxhdpi";
}
else if (density >= 3.0 && density < 4.0) {
   //xxhdpi
}
else if (density >= 2.0) {
   //xhdpi
}
else if (density >= 1.5 && density < 2.0) {
   //hdpi
}
else if (density >= 1.0 && density < 1.5) {
   //mdpi
}

1
Bu kod, bazı başkaları ve işaretleri ve koşulları gereksiz olduktan sonra yapabilirdi.
Andrew S

1
@Andrew, düzeltme için teşekkürler. Cevabı buna göre düzenledim.
San

2
@San Bu koşulların hiçbirinde && 'ye ihtiyaç duymazsınız, sürekli olarak = = için kontrol ettiğiniz sürece, doğru olan ilk koşul için sonlanırsa.
dbenson

3
Bu, Nexus 5X (varsayılan bir google cihazı btw) ile benim için doğru bir sonuç vermiyor. Cihaz yoğunluğu xxhdpi'dir ve döndürülen çift yoğunluk yaklaşık 2.6'dır.
Tobliug

20

Gerçek ekran dpi'sine sahip olmak istiyorsanız, ekran metriklerini sorgularsanız yanıt aralarında bir yerdedir:

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int dpiClassification = dm.densityDpi;
float xDpi = dm.xdpi;
float yDpi = dm.ydpi;

densityDpi * 160, kullanmanız gereken yoğunluğu / değeri verecektir

0.75 - ldpi - 120 dpi
1.0 - mdpi - 160 dpi
1.5 - hdpi - 240 dpi
2.0 - xhdpi - 320 dpi
3.0 - xxhdpi - 480 dpi
4.0 - xxxhdpi - 640 dpi

önceki yazılarda belirtildiği gibi

ancak dm.xdpiher zaman verilen ekranın GERÇEK dpi'sini vermez : Örnek:

Device: Sony ericsson xperia mini pro (SK17i)
Density: 1.0 (e.g. suggests you use 160dpi resources)
xdpi: 193.5238
Real device ppi is arround 193ppi


Device: samsung GT-I8160 (Samsung ace 2)
Density 1.5 (e.g. suggests you use 240dpi resources)
xdpi 160.42105
Real device ppi is arround 246ppi

belki ekran gerçek dpi Yoğunluk * xdpi .. olmalı ama bunun doğru yolu olup olmadığından emin değilim!


1
Yoğunluk Kullanımı * xdpi, son 6 aydır google play'deki tüm uygulamalarımda şu ana kadar mükemmel çalışıyor
Marek Halmo

Yoğunluk * xdpi'nin çarpılması mantıklı değildir, bu da daha yüksek yoğunluklu cihazlar olduğu için daha açıktır - hem Yoğunluk hem de xdpi artışı, bu nedenle çoğalmak artışı iki katına çıkarır. Samsung ace 2'nin satıcı tarafından bir hata olduğunu söyleyebilirim. Android özelliği, xdpi ve ydpi'nin gerçek piksel yoğunluklarıdır - hiçbir şeyle çarpmayın.
ToolmakerSteve

17

Bu, aktivitenize yardımcı olacaktır ...

void printSecreenInfo(){

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

    Log.i(TAG, "density :" +  metrics.density);

    // density interms of dpi
    Log.i(TAG, "D density :" +  metrics.densityDpi);

    // horizontal pixel resolution
    Log.i(TAG, "width pix :" +  metrics.widthPixels);

     // actual horizontal dpi
    Log.i(TAG, "xdpi :" +  metrics.xdpi);

    // actual vertical dpi
    Log.i(TAG, "ydpi :" +  metrics.ydpi);

}

ÇIKTI :

I/test( 1044): density :1.0

I/test( 1044): D density :160

I/test( 1044): width pix :800

I/test( 1044): xdpi :160.0

I/test( 1044): ydpi :160.42105

13
public static String getDensity(Context context) {
    String r;
    DisplayMetrics metrics = new DisplayMetrics();

    if (!(context instanceof Activity)) {
        r = "hdpi";
    } else {
        Activity activity = (Activity) context;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        if (metrics.densityDpi <= DisplayMetrics.DENSITY_LOW) {
            r = "ldpi";
        } else if (metrics.densityDpi <= DisplayMetrics.DENSITY_MEDIUM) {
            r = "mdpi";
        } else {
            r = "hdpi";
        }
    }

    return r;
}

11

Yoğunluğu bir Hizmetten almak istiyorsanız şu şekilde çalışır:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);

Ben hiçbir WindowManager varken Bu seferki bana yardımcı oldu
silentsudo

8

Bunu Denemelisin. Sadece Tost'u bulacak ve gösterecek bir yöntem eklendi. Cihazın Hangi Kategoriye Düştüğü.

public static int differentDensityAndScreenSize(Context context) {
  int value = 20;
  String str = "";
  if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "small-ldpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "small-mdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "small-hdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "small-xhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "small-xxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "small-xxxhdpi";
    value = 20;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "small-tvdpi";
    value = 20;
    break;
   default:
    str = "small-unknown";
    value = 20;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "normal-ldpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "normal-mdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "normal-hdpi";
    value = 82;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "normal-xhdpi";
    value = 90;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "normal-xxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "normal-xxxhdpi";
    value = 96;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "normal-tvdpi";
    value = 96;
    break;
   default:
    str = "normal-unknown";
    value = 82;
    break;
   }
  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "large-ldpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "large-mdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "large-hdpi";
    value = 78;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "large-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "large-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "large-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "large-tvdpi";
    value = 125;
    break;
   default:
    str = "large-unknown";
    value = 78;
    break;
   }

  } else if ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
   switch (context.getResources().getDisplayMetrics().densityDpi) {
   case DisplayMetrics.DENSITY_LOW:
    str = "xlarge-ldpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_MEDIUM:
    str = "xlarge-mdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_HIGH:
    str = "xlarge-hdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XHIGH:
    str = "xlarge-xhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXHIGH:
    str = "xlarge-xxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_XXXHIGH:
    str = "xlarge-xxxhdpi";
    value = 125;
    break;
   case DisplayMetrics.DENSITY_TV:
    str = "xlarge-tvdpi";
    value = 125;
    break;
   default:
    str = "xlarge-unknown";
    value = 125;
    break;
   }
  }
// The Toast will show the Device falls in Which Categories.
Toast.makeText(MainActivity.this, ""+str, Toast.LENGTH_SHORT).show();

  return value;
 }

http://www.androidwarriors.com/2016/01/how-to-find-different-devices-screen.html


7

Bu çalışmalı.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480

4
Ekranın piksel cinsinden boyutu yoğunluk değildir.
joshperry

1
Bu yoğunluktan bağımsız piksellerdir, piksel değildir. Ve gördüğünüz 320, 320 piksel değil 320dip.
Piksel

7

Yine başka bir cevap:

/**
* @return "ldpi", "mdpi", "hdpi", "xhdpi", "xhdpi", "xxhdpi", "xxxhdpi", "tvdpi", or "unknown".
*/
public static String getDensityBucket(Resources resources) {
    switch (resources.getDisplayMetrics().densityDpi) {
        case DisplayMetrics.DENSITY_LOW:
            return "ldpi";
        case DisplayMetrics.DENSITY_MEDIUM:
            return "mdpi";
        case DisplayMetrics.DENSITY_HIGH:
            return "hdpi";
        case DisplayMetrics.DENSITY_XHIGH:
            return "xhdpi";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "xxhdpi";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "xxxhdpi";
        case DisplayMetrics.DENSITY_TV:
            return "tvdpi";
        default:
            return "unknown";
    }
}

3

Yoğunluğun cihaz tarafından yüklenmesinin başka bir yolu:

valuesHer yoğunluk için klasör oluşturma

  • değerleri (varsayılan mdpi)
  • değerler hdpi
  • değerler xhdpi
  • değerler xxhdpi
  • değerler xxxhdpi

İlgili bir dize kaynağı ekleyin strings.xml:

<string name="screen_density">MDPI</string>    <!-- ..\res\values\strings.xml -->
<string name="screen_density">HDPI</string>    <!-- ..\res\values-hdpi\strings.xml -->
<string name="screen_density">XHDPI</string>   <!-- ..\res\values-xhdpi\strings.xml -->
<string name="screen_density">XXHDPI</string>  <!-- ..\res\values-xxhdpi\strings.xml -->
<string name="screen_density">XXXHDPI</string> <!-- ..\res\values-xxxhdpi\strings.xml -->

Sonra dize kaynağını alın ve yoğunluğunuz var:

String screenDensity = getResources().getString(R.string.screen_density);

Yoğunluk daha büyükse XXXHDPI, bu varsayılan yapar XXXHDPIveya düşükse HDPIo varsayılan olacaktırMDPI

R.strings.screen_density değerleri

Dışarıda kaldım LDPI, çünkü kullanım durumum için gerekli değil.


Bence yoğunluğu elde etmenin doğru yolu bu. GetResources (). GetDisplayMetrics (). Yoğunluğunu kullandığım için, ayardaki ekran boyutunu değiştirirsem yoğunluk değişecektir.
Fantezi Fang

1

Bunu dene...

Kotlin'de

fun determineScreenDensityCode(): String {
      return when (resources.displayMetrics.densityDpi) {
         DisplayMetrics.DENSITY_LOW -> "ldpi"
         DisplayMetrics.DENSITY_MEDIUM -> "mdpi"
         DisplayMetrics.DENSITY_HIGH -> "hdpi"
         DisplayMetrics.DENSITY_XHIGH, DisplayMetrics.DENSITY_280 -> "xhdpi"
         DisplayMetrics.DENSITY_XXHIGH, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420 -> "xxhdpi"
         DisplayMetrics.DENSITY_XXXHIGH, DisplayMetrics.DENSITY_560 -> "xxxhdpi"
         else -> "Unknown code ${resources.displayMetrics.densityDpi}"
     }
}

İle arayabilir println("density: ${determineScreenDensityCode()}") ve çıktıSystem.out: density: xxxhdpi


0

Modüller (bir bağlam nesnesine erişimine gerek yok) DPI erişmek için aşağıdaki kodu kullanıyorum:

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2

0

Android'de ekran yoğunluğunu şu şekilde alabilirsiniz:

public static String getScreenDensity(Context context)
{
    String density;
    switch (context.getResources().getDisplayMetrics().densityDpi)
    {
        case DisplayMetrics.DENSITY_LOW:
            density = "LDPI";
            break;
        case DisplayMetrics.DENSITY_140:
            density = "LDPI - MDPI";
            break;
        case DisplayMetrics.DENSITY_MEDIUM:
            density = "MDPI";
            break;
        case DisplayMetrics.DENSITY_180:
        case DisplayMetrics.DENSITY_200:
        case DisplayMetrics.DENSITY_220:
            density = "MDPI - HDPI";
            break;
        case DisplayMetrics.DENSITY_HIGH:
            density = "HDPI";
            break;
        case DisplayMetrics.DENSITY_260:
        case DisplayMetrics.DENSITY_280:
        case DisplayMetrics.DENSITY_300:
            density = "HDPI - XHDPI";
            break;
        case DisplayMetrics.DENSITY_XHIGH:
            density = "XHDPI";
            break;
        case DisplayMetrics.DENSITY_340:
        case DisplayMetrics.DENSITY_360:
        case DisplayMetrics.DENSITY_400:
        case DisplayMetrics.DENSITY_420:
        case DisplayMetrics.DENSITY_440:
            density = "XHDPI - XXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXHIGH:
            density = "XXHDPI";
            break;
        case DisplayMetrics.DENSITY_560:
        case DisplayMetrics.DENSITY_600:
            density = "XXHDPI - XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_XXXHIGH:
            density = "XXXHDPI";
            break;
        case DisplayMetrics.DENSITY_TV:
            density = "TVDPI";
            break;
        default:
            density = "UNKNOWN";
            break;
    }

    return density;
}

Ve Kotlin'de şöyle:

fun getScreenDensity(context: Context): String {
    val density: String
    when (context.resources.displayMetrics.densityDpi) {
        DisplayMetrics.DENSITY_LOW -> density = "LDPI"
        DisplayMetrics.DENSITY_140 -> density = "LDPI - MDPI"
        DisplayMetrics.DENSITY_MEDIUM -> density = "MDPI"
        DisplayMetrics.DENSITY_180, DisplayMetrics.DENSITY_200, DisplayMetrics.DENSITY_220 -> density = "MDPI - HDPI"
        DisplayMetrics.DENSITY_HIGH -> density = "HDPI"
        DisplayMetrics.DENSITY_260, DisplayMetrics.DENSITY_280, DisplayMetrics.DENSITY_300 -> density = "HDPI - XHDPI"
        DisplayMetrics.DENSITY_XHIGH -> density = "XHDPI"
        DisplayMetrics.DENSITY_340, DisplayMetrics.DENSITY_360, DisplayMetrics.DENSITY_400, DisplayMetrics.DENSITY_420, DisplayMetrics.DENSITY_440 -> density =
            "XHDPI - XXHDPI"
        DisplayMetrics.DENSITY_XXHIGH -> density = "XXHDPI"
        DisplayMetrics.DENSITY_560, DisplayMetrics.DENSITY_600 -> density = "XXHDPI - XXXHDPI"
        DisplayMetrics.DENSITY_XXXHIGH -> density = "XXXHDPI"
        DisplayMetrics.DENSITY_TV -> density = "TVDPI"
        else -> density = "UNKNOWN"
    }

    return density
}

Yeni yoğunlukların eklenip eklenmediğini düzenli olarak kontrol ettiğinizden emin olun .

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.