получить плотность экрана программно в Android?

516

Как получить плотность экрана программно в Android?

Я имею в виду: Как найти разрешение экрана текущего устройства?

android dpi screen-density Praveen
источник
9
Отвечают многие ответы getDisplayMetrics().xdpi, которые должны возвращать реальное dpi устройства. Обратите внимание, что это значение не всегда корректно устанавливается на разных устройствах изготовителями, поэтому вы просто не сможете их использовать . Печально, но факт: информация о реальных точках на дюйм недоступна . Источник: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
Сулай
2
getResources().getDisplayMetrics().xdpiи getResources().getDisplayMetrics().ydpiдаст вам фактические горизонтальные и вертикальные плотности , которые в большинстве случаев различны.
Ωmega

Ответы:

527

Вы можете получить информацию на дисплее из структуры DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Хотя Android не использует прямое сопоставление пикселей, он использует несколько квантованных значений, независимых от плотности пикселей, а затем масштабируется до фактического размера экрана. Таким образом, metrics.densityDpiсвойство будет одним из DENSITY_xxxконстант ( 120, 160, 213, 240, 320, 480или 640точек на дюйм).

Если вам нужна фактическая плотность ОК - пиксельный (возможно для приложения OpenGL) , вы можете получить его от metrics.xdpiи metrics.ydpiсвойств для горизонтальной и вертикальной плотности соответственно.

Если вы ориентируетесь API уровней раньше , чем 4. metrics.densityСвойство с плавающей точкой коэффициент масштабирования от исходной плотности (160dpi). То же значение, предоставленное теперь, metrics.densityDpiможет быть рассчитано

int densityDpi = (int)(metrics.density * 160f);
joshperry
источник
42
Конечно, это сообщение более двух лет назад, но это первое, что появляется в Google для этого поиска, поэтому для любого, кто найдет это, вам больше не нужно умножать на 160.
roboguy12
5
Больше не с какой версии?
TacB0sS
Я обновил ответ, чтобы соответствовать последним версиям API, которые могут использовать люди.
Joshperry
6
Примечание. Возможно, вы захотите использовать этот более новый API: он getWindowManager().getDefaultDisplay().getRealMetrics(metrics); был официально добавлен в API 17, но я с удивлением обнаружил, что он работает правильно даже на устройстве 4.0, которое я пробовал.
benkc
2
есть также getResources (). getDisplayMetrics (). densityDpi
amorenew
367

Это также работает:

 getResources().getDisplayMetrics().density;

Это даст вам:

0,75 - лдпи

1,0 - т / д

1,5 - HDMI

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

введите описание изображения здесь

ref: плотность

введите описание изображения здесь

ссылка 2

Бландел
источник
10
+1 Это работает, когда у вас нет прямого доступа WindowManager(например, внутри загрузчика). Просто умножьте это на 160
Михал К
2
Уровень API 16 добавил xxdpi, что переводится здесь как 3.0.
QED
3
это даст 1.3312501 для tvdpi. Для получения дополнительной информации tvdpiсм. Здесь
Дори
2
Nexus 7 сообщает 1.3, почему скобка должна войти?
Нейл
1
@selbie, ваш телефон, вероятно, тянет и масштабирует ресурсы более высокого качества, поскольку ваш телефон сообщает о половине между двумя заданными значениями плотности.
Сакибой
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;
}

Это будет работать на уровне API 4 и выше.

Митул Накум
источник
Как бы вы передали такие устройства, как Nexus 7, который сообщает плотность Dpi как 213?
Нейл
есть ручная проверка if-else значения плотности, например if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
Mitul Nakum,
1
ИЛИ if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} еще if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
Митул Накум
1
Нил, 213 называется TV DPI, для этого DENSITY_TV существует именованная плотность метрик дисплея.
Андрей С
63

Ответ Бланделла как статический вспомогательный метод:

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
источник
как насчет плотности ТВДПИ. Я думаю, что это 1,33
Anoop
@AnoopssGolden Это не совсем стандартно, так что вы можете добавить его, если хотите, но я не думаю, что ответ должен включать его. Из документации для Android: «Это не считается« основной »группой плотности. Она в основном предназначена для телевизоров, и большинству приложений она не нужна».
qwertzguy
Но устройство Nexus 7 относится к группе плотности ТВДПИ.
Anoop
1
Я знаю, что это немного устарело, но просто добавлю; MDPI может работать для большинства вещей на Nexus 7, но, как я сейчас пытаюсь, образы, представленные как MDPI, недостаточно велики. Мне нужно определить TVDPI, а затем попросить большего размера изображения с моего сервера. Это может не использоваться много, но это не означает, что MDPI подберет все.
RED_
3
Привет @ Andrew S, использование elses ничего не меняет в эффективности кода, так как каждый if возвращается немедленно. Удаление скобок - это вопрос только стиля, и IMHO делает его более подверженным ошибкам при обслуживании кода.
qwertzguy
45

Попробуй это:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
Wizist
источник
5
Мне это нравится намного лучше, так как это зависит от контекста, а не от активности.
greg7gkb
Согласен, я могу использовать это Viewгораздо проще (именно там мне это нужно!)
Эндрю Уайлд
37

Чтобы получить точек на дюйм:

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
источник
4
dm.densityDpi возвращает либо DENSITY_LOW, либо DENSITY_MEDIUM, либо DENSITY_HIGH. Что насчет xhdpi? Есть ли DENSITY_XHIGH или около того?
Евгений Чумак
Да, есть: developer.android.com/reference/android/util/…
caw
34

Вот константы плотности, источник :

введите описание изображения здесь

Кроме стандартных плотностей, есть 5 промежуточных. Принимая во внимание этот факт, следующий код будет полным рабочим примером:

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 
}

Кроме того, вы можете найти константы плотности, используя 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

Следующий ответ - небольшое улучшение, основанное на ответе 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
}
Сан -
источник
1
Этот код может быть с некоторыми другими, и амперсанды и условия после него являются избыточными.
Андрей С
1
@ Андрей, спасибо за исправление. Я отредактировал ответ соответственно.
San
2
@San Вам не нужно && ни в одном из этих условий, если вы постоянно проверяли наличие> = else, если прекратит работу для первого условия, которое истинно.
Дбенсон
3
Это не возвращает правильный результат для меня с моим Nexus 5X (кстати, устройство Google по умолчанию). Плотность устройства равна xxhdpi, а возвращаемая двойная плотность составляет около 2,6.
Тоблюг
20

На самом деле, если вы хотите иметь реальное значение dpi, ответ будет где-то посередине, если вы запрашиваете метрики отображения:

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

densityDpi * 160 даст вам значения / рекомендации, какую плотность вы должны использовать

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

как указано в предыдущих сообщениях

но dm.xdpiне всегда дает вам РЕАЛЬНОЕ dpi данного дисплея: Пример:

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

так что, возможно, реальное dpi дисплея должно быть Density * xdpi .. но я не уверен, что это правильный способ!

Марек Халмо
источник
1
Использование плотности * До сих пор xdpi отлично работал на всех моих приложениях в Google Play за последние 6 месяцев
Marek Halmo
Умножение плотности * xdpi не логично, и теперь стало понятнее, когда стало больше устройств с более высокой плотностью - и плотность, и xdpi увеличились, поэтому их умножение увеличило бы двойной счет. Я бы сказал, что Samsung ace 2 был ошибкой производителя. Спецификация Android заключается в том, что xdpi и ydpi - это истинная плотность пикселей - не умножайте ни на что.
ToolmakerSteve
17

Это должно помочь в вашей деятельности ...

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

}

ВЫВОД : 

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

Если вы хотите получить плотность из службы, она работает следующим образом:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
Показать имя
источник
Это помогло мне, когда у меня не было оконного менеджера
silentsudo
8

Вы должны попробовать это. Только что добавили метод, который найдет и покажет тост. То, в какую категорию попадает устройство.

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

Это должно работать.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
Робби Понд
источник
4
Размер в пикселях дисплея не является плотностью.
Джошперри
1
Это независимые от плотности пиксели, а не пиксели. И то, что вы видите, это 320dip, а не 320px. Вычисление px отличается, смотрите этот stackoverflow.com/questions/6840904/…
Lukap
7

Еще один ответ:

/**
* @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

Еще один способ получить плотность загрузки устройства:

Создавайте valuesпапки для каждой плотности

  • значения (по умолчанию mdpi)
  • Значения-ИПЧР
  • Значения-xhdpi
  • Значения-xxhdpi
  • Значения-xxxhdpi

Добавьте строковый ресурс в их соответствующие 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 -->

Тогда просто получите строковый ресурс, и вы получите свою плотность:

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

Если плотность больше, чем XXXHDPIона будет по умолчанию XXXHDPIили если она ниже, чем HDPIона будет по умолчаниюMDPI

Значения R.strings.screen_density

Я не учел LDPI, потому что для моего варианта использования это не нужно.

пьер
источник
Я думаю, что это правильный способ получить плотность. Поскольку я использую плотность getResources (). GetDisplayMetrics (). Плотность будет изменяться, если я изменю размер экрана в настройках.
Fantasy Fang
1

Попробуй это...

В котлине

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

Вы можете позвонить по println("density: ${determineScreenDensityCode()}") и выход будетSystem.out: density: xxxhdpi

Силамбарасан Пунгути
источник
0

Я использую следующий код для доступа к DPI из модулей (нет необходимости иметь доступ к объекту контекста):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2
Ян Малек
источник
0

В Android вы можете получить плотность экрана следующим образом:

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

А в Котлине так:

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
}

Обязательно регулярно проверяйте, добавляются ли новые плотности .

Wirling
источник