programowo uzyskać gęstość ekranu w Androidzie?

516

Jak uzyskać gęstość ekranu programowo w Androidzie?

Mam na myśli: jak znaleźć rozdzielczość ekranu bieżącego urządzenia?

android dpi screen-density Praveen
źródło
9
Wiele odpowiedzi odnosi się do tego getDisplayMetrics().xdpi, co ma zwrócić rzeczywistą rozdzielczość urządzenia. Należy pamiętać, że ta wartość nie jest konsekwentnie ustawiana poprawnie na różnych urządzeniach przez producentów, więc po prostu nie można ich używać . Smutne, ale prawdziwe: informacje o rzeczywistej rozdzielczości nie są dostępne . Źródło: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
sulai
2
getResources().getDisplayMetrics().xdpii getResources().getDisplayMetrics().ydpizapewni rzeczywiste gęstości poziome i pionowe , które w większości przypadków są różne.
Ωmega

Odpowiedzi:

526

Możesz uzyskać informacje na temat wyświetlania z struktury DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Chociaż system Android nie korzysta z bezpośredniego mapowania pikseli, wykorzystuje garść skwantyzowanych wartości pikseli niezależnych od gęstości, a następnie skaluje do rzeczywistego rozmiaru ekranu. Więc metrics.densityDpinieruchomość będzie jednym z tych DENSITY_xxxstałych ( 120, 160, 213, 240, 320, 480lub 640dpi).

Jeśli potrzebujesz rzeczywistą gęstość pikseli LCD (być może dla aplikacji OpenGL) można dostać go od metrics.xdpii metrics.ydpiwłaściwościach gęstości poziomym i pionowym odpowiednio.

Jeśli celujesz w poziomy API wcześniejsze niż 4. metrics.densityWłaściwość jest zmiennoprzecinkowym współczynnikiem skalowania z gęstości odniesienia (160dpi). Tę samą podaną teraz wartość metrics.densityDpimożna obliczyć

int densityDpi = (int)(metrics.density * 160f);
joshperry
źródło
42
Przyznaję, że ten post pochodzi sprzed ponad dwóch lat, ale jest to pierwsza rzecz, która pojawia się w Google podczas tego wyszukiwania, więc dla każdego, kto to znajdzie, nie musisz już pomnożyć przez 160.
roboguy12,
5
Już nie od której wersji?
TacB0sS,
Zaktualizowałem odpowiedź, aby pasowała do najnowszych wersji API, z których ludzie mogą korzystać.
joshperry
6
Uwaga: Zamiast tego możesz chcieć tego nowszego interfejsu API: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); został on oficjalnie dodany w interfejsie API 17, ale zdziwiłem się, że działał poprawnie nawet na urządzeniu 4.0, którego wypróbowałem.
benkc
2
istnieje również getResources (). getDisplayMetrics (). gęstośćDpi
amorenew
367

Działa to również:

 getResources().getDisplayMetrics().density;

To da ci:

0,75 - ldpi

1.0 - mdpi

1,5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

wprowadź opis zdjęcia tutaj

ref: gęstość

wprowadź opis zdjęcia tutaj

ref 2

Blundell
źródło
10
+1 Działa, gdy nie masz bezpośredniego dostępu do WindowManager(np. Wewnątrz modułu ładującego). Wystarczy pomnożyć przez 160
Michał K,
2
Interfejs API poziomu 16 dodał xxdpi, co przekłada się tutaj na 3.0.
QED,
3
da to 1,3312501 dla tvdpi. Aby uzyskać więcej informacji, tvdpizobacz tutaj
Dori,
2
Nexus 7 zgłasza 1.3, dlaczego nawias powinien się w to włączyć?
Neil
1
@selbie, Twój telefon prawdopodobnie ciągnie i skaluje zasoby o wyższej jakości, ponieważ telefon zgłasza połowę między dwiema określonymi gęstościami.
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;
}

Działa to na poziomie API 4 i wyższym.

Mitul Nakum
źródło
Jak podasz urządzenia takie jak Nexus 7, które zgłaszają gęstość Dpi jako 213?
Neil
sprawdzaj ręcznie jeśli-inaczej między wartością gęstości, np. if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
Mitul Nakum
1
LUB if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} else if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
Mitul Nakum
1
Neil, 213 nazywa się TV DPI, dla tego DENSITY_TV istnieje nazwana gęstość wskaźników wyświetlania.
Andrew S
63

Odpowiedź Blundella jako metody statycznego pomocnika:

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";
}
qwertzguy
źródło
co z gęstością tvdpi. Chyba 1,33
Anoop
@AnoopssGolden Nie jest to naprawdę standard, więc możesz go dodać, jeśli chcesz, ale nie sądzę, że odpowiedź powinna go zawierać. Z dokumentów systemu Android: „Nie jest to uważane za„ podstawową ”grupę gęstości. Jest przeznaczone głównie dla telewizorów i większość aplikacji nie powinna jej potrzebować”.
qwertzguy
Ale urządzenie Nexus 7 należy do grupy gęstości tvdpi.
Anoop
1
Wiem, że to trochę stare, ale tylko dodać; MDPI może działać dla większości rzeczy na Nexusie 7, ale kiedy próbuję teraz, obrazy schodzące jako MDPI nie są wystarczająco duże. Muszę zdefiniować TVDPI, a następnie poprosić o większy rozmiar obrazu z mojego serwera. Nie można go często używać, ale to nie znaczy, że MDPI wszystko odbierze.
RED_
3
Hej @Andrew S, użycie elses nic nie zmienia wydajności kodu, ponieważ każdy if natychmiast wraca. Usunięcie nawiasów jest tylko kwestią stylu, a IMHO czyni go bardziej podatnym na błędy podczas obsługi kodu.
qwertzguy
45

Spróbuj tego:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
Wizist
źródło
5
Podoba mi się to znacznie bardziej, ponieważ opiera się raczej na kontekście niż na aktywności.
greg7gkb,
Zgadzam się, że mogę korzystać z tego Viewznacznie łatwiej (tam, gdzie jest to potrzebne!)
Andrew Wyld
37

Aby uzyskać dpi:

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;
Jere.Jones
źródło
4
dm.densityDpi zwraca DENSITY_LOW lub DENSITY_MEDIUM lub DENSITY_HIGH. Co z xhdpi? Czy jest jakieś DENSITY_XHIGH?
Eugene Chumak
Tak, jest: developer.android.com/reference/android/util/…
caw
34

Oto stałe gęstości, źródło :

wprowadź opis zdjęcia tutaj

Oprócz standardowych gęstości istnieje 5 pośrednich. Biorąc pod uwagę ten fakt, poniższy kod będzie kompletnym działającym przykładem:

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 
}

Alternatywnie można znaleźć stałe gęstości za pomocą 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;
}
Ayaz Alifov
źródło
29

Poniższa odpowiedź jest niewielkim ulepszeniem opartym na odpowiedzi qwertzguy. 

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
}
San
źródło
1
Ten kod może zrobić z niektórymi innymi, a znaki handlowe i warunki po nim są zbędne.
Andrew S
1
@Andrew, dzięki za korektę. Odpowiednio zredagowałem odpowiedź.
San
2
@San Nie potrzebujesz && w żadnym z tych warunków, o ile konsekwentnie sprawdzasz, czy> = else if zostanie zakończone dla pierwszego warunku, który jest prawdziwy.
dbenson
3
To nie zwraca poprawnego wyniku dla mojego Nexusa 5X (domyślne urządzenie google btw). Gęstość urządzenia wynosi xxhdpi, a zwracana podwójna gęstość wynosi około 2,6.
Tobliug,
20

Faktycznie, jeśli chcesz mieć rzeczywistą rozdzielczość ekranu, odpowiedź znajduje się gdzieś pomiędzy, jeśli pytasz o parametry wyświetlania:

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

gęstośćDpi * 160 poda wartości / sugestie, której gęstości należy użyć

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

jak określono w poprzednich postach

ale dm.xdpinie zawsze zapewnia PRAWDZIWĄ rozdzielczość dpi danego wyświetlacza: Przykład:

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

więc może rzeczywista rozdzielczość wyświetlacza powinna wynosić Gęstość * xdpi .. ale nie jestem pewien, czy jest to właściwy sposób!

Marek Halmo
źródło
1
Korzystanie z Density * xdpi działa jak dotąd we wszystkich moich aplikacjach w Google Play przez ostatnie 6 miesięcy
Marek Halmo
Mnożenie gęstości * xdpi nie jest logiczne, co jest teraz wyraźniejsze, gdy jest więcej urządzeń o wyższej gęstości - zarówno Gęstość, jak i xdpi zwiększają się, więc pomnożenie ich byłoby podwójnym liczeniem wzrostu. Powiedziałbym, że Samsung Ace 2 był błędem producenta. Specyfikacją Androida jest to, że xdpi i ydpi są prawdziwymi gęstościami pikseli - nie mnoż przez nic.
ToolmakerSteve
17

To powinno pomóc w twojej aktywności ...

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

}

WYNIK : 

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
prabhu
źródło
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;
}
Felipe
źródło
11

Jeśli chcesz pobrać gęstość z usługi, działa ona w następujący sposób:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
Wyświetlana nazwa
źródło
Ten pomógł mi, gdy nie miałem menedżera okien
silentsudo
8

Powinieneś tego spróbować. Właśnie dodałem metodę, która znajdzie i pokaż Toast. W tej kategorii mieści się urządzenie.

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

Avinash Verma
źródło
7

To powinno działać.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
Robby Pond
źródło
4
Rozmiar w pikselach wyświetlacza nie jest gęstością.
joshperry
1
To piksele niezależne od gęstości, a nie piksele. I to, że widzisz 320 to 320dip, a nie 320px. Obliczanie px jest inne, patrz stackoverflow.com/questions/6840904/...
Lukap
7

Jeszcze jedna odpowiedź:

/**
* @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";
    }
}
Jared Rummler
źródło
3

Inny sposób na załadowanie gęstości przez urządzenie:

Utwórz valuesfoldery dla każdej gęstości

  • wartości (domyślne mdpi)
  • wartości-hdpi
  • wartości-xhdpi
  • wartości-xxhdpi
  • wartości-xxxhdpi

Dodaj zasób ciągu w odpowiednich 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 -->

Następnie po prostu weź zasób łańcucha, a będziesz mieć swoją gęstość:

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

Jeśli gęstość jest większa niż XXXHDPI, domyślnie będzie ustawiona na XXXHDPIlub jeśli będzie niższa niż HDPIdomyślnie naMDPI

R.strings.screen_density wartości

Pominąłem LDPI, ponieważ w moim przypadku użycia nie jest to konieczne.

Pierre
źródło
Myślę, że to właściwy sposób na uzyskanie gęstości. Ponieważ używam metody getResources (). GetDisplayMetrics ()., Gęstość zmieniłaby się, jeśli zmienię rozmiar wyświetlania w ustawieniach.
Fantasy Fang
1

Spróbuj tego...

W kotlinie

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

Możesz zadzwonić, println("density: ${determineScreenDensityCode()}") a wynik będzieSystem.out: density: xxxhdpi

Silambarasan Poonguti
źródło
0

Korzystam z następującego kodu, aby uzyskać dostęp do DPI z modułów (nie trzeba mieć dostępu do obiektu kontekstu):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2
Jan Málek
źródło
0

W Androidzie możesz uzyskać gęstość ekranu w następujący sposób:

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

A w Kotlinie tak:

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
}

Regularnie sprawdzaj, czy dodawane są nowe gęstości .

Wirować
źródło