obtendo a densidade da tela programaticamente no android?

516

Como obter a densidade de tela programaticamente no android?

Quero dizer: Como encontrar o dpi da tela do dispositivo atual?

android dpi screen-density Praveen
fonte
9
Muitas respostas se referem getDisplayMetrics().xdpi, que deve retornar o dpi real do dispositivo. Observe que esse valor não é definido corretamente de maneira consistente entre os dispositivos pelos fabricantes, portanto você não pode usá-los . Triste, mas verdadeiro: as informações sobre dpi reais não estão disponíveis . Fonte: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
sulai 5/15
2
getResources().getDisplayMetrics().xdpie getResources().getDisplayMetrics().ydpifornecerá densidades horizontais e verticais reais , que na maioria dos casos são diferentes.
Egamega

Respostas:

526

Você pode obter informações sobre a exibição na estrutura DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Embora o Android não use um mapeamento de pixel direto, ele usa vários valores quantificados de Density Independent Pixel e, em seguida, é dimensionado para o tamanho real da tela. Assim, a metrics.densityDpipropriedade será uma das DENSITY_xxxconstantes ( 120, 160, 213, 240, 320, 480ou 640dpi).

Se você precisar da densidade real de pixels em LCD (talvez para um aplicativo OpenGL), poderá obtê-la nas propriedades metrics.xdpie metrics.ydpipara densidade horizontal e vertical, respectivamente.

Se você estiver direcionando os Níveis da API anteriores a 4. A metrics.densitypropriedade é um fator de escala de ponto flutuante da densidade de referência (160 dpi). O mesmo valor agora fornecido por metrics.densityDpipode ser calculado

int densityDpi = (int)(metrics.density * 160f);
joshperry
fonte
42
Concedido este post é de mais de dois anos atrás, mas esta é a primeira coisa que aparece no Google para esta pesquisa, portanto, para quem acha isso, você não precisa mais se multiplicar por 160.
roboguy12
5
Já não desde que versão?
TacB0sS
Atualizei a resposta para corresponder às revisões mais recentes da API que as pessoas possam estar usando.
Joshperry #
6
Nota: Você pode querer esta API mais recente: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); foi adicionada oficialmente na API 17, mas fiquei surpreso ao descobrir que ela funcionava corretamente mesmo em um dispositivo 4.0 que eu tentei.
benkc
2
.. há também getResources () getDisplayMetrics () densityDpi
amorenew
367

Isso também funciona:

 getResources().getDisplayMetrics().density;

Isso lhe dará:

0,75 - ldpi

1.0 - mdpi

1.5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

insira a descrição da imagem aqui

ref: densidade

insira a descrição da imagem aqui

ref 2

Blundell
fonte
10
+1 Isso funciona quando você não tem acesso direto a WindowManager(por exemplo, dentro de um carregador). Basta multiplicá-lo por 160
Michał K
2
O nível 16 da API adicionou xxdpi, que é traduzido aqui para 3.0.
QED
3
isso dará 1,3312501 para tvdpi. Para mais informações sobre tvdpiver aqui
Dori
2
Relatórios 1.3 do Nexus 7, por que suporte isso deve aparecer?
Neil
1
@selbie, é provável que seu telefone esteja puxando e dimensionando os recursos de maior qualidade, pois está relatando a meio caminho entre duas densidades definidas.
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;
}

Isso funcionará no nível 4 da API e superior.

Mitul Nakum
fonte
Como você entregaria dispositivos como o Nexus 7, que informa o densityDpi como 213?
Neil
tem cheque mão if-else entre valor de densidade como, se (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
Mitul Nakum
1
OU se (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} else if (metrics.densityDpi <DisplayMetrics DENSITY_MEDIUM.) {} .....
Mitul Nakum
1
Neil, 213 é chamado de TV DPI, existe uma densidade de métricas de exibição nomeada para esse DENSITY_TV.
Andrew S
63

A resposta de Blundell como método auxiliar estático:

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
fonte
e a densidade de tvdpi. Eu acho que é 1,33
Anoop
@AnoopssGolden Não é realmente padrão, então você pode adicioná-lo se quiser, mas não acho que a resposta deva incluir. Nos documentos do Android: "Este não é considerado um grupo de densidade" primário ". Ele se destina principalmente a televisões e a maioria dos aplicativos não precisa dele".
Qwertzguy
Mas o dispositivo nexus 7 pertence ao grupo de densidade tvdpi.
Anoop
1
Eu sei que isso é um pouco antigo, mas apenas para adicionar; O MDPI pode funcionar para a maioria das coisas em um Nexus 7, mas como estou tentando agora, as imagens que aparecem como MDPI não são grandes o suficiente. Estou tendo que definir o TVDPI e pedir um tamanho de imagem maior do meu servidor. Pode não ser muito usado, mas isso não significa que o MDPI capte tudo.
RED_ 13/08/14
3
Hey @Andrew S, o uso de elses não altera nada na eficiência do código, pois todo se retorna imediatamente. A remoção de chaves é apenas uma questão de estilo e o IMHO o torna mais suscetível a erros ao manter o código.
Qwertzguy 01/07/2015
45

Tente o seguinte:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
Wizist
fonte
5
Eu gosto muito mais disso, pois se baseia no contexto, e não na atividade.
22612 greg7gkb
Acordado, eu posso usar isso a partir de uma Viewmuito mais facilmente (que é onde eu preciso dele!)
Andrew Wyld
37

Para obter 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
fonte
4
dm.densityDpi retorna DENSITY_LOW ou DENSITY_MEDIUM ou DENSITY_HIGH. E o xhdpi? Existe algum DENSITY_XHIGH ou algo assim?
Eugene Chumak
Sim, existe: developer.android.com/reference/android/util/…
caw
34

Aqui estão as constantes de densidade, fonte :

insira a descrição da imagem aqui

Além das densidades padrão, existem 5 intermediárias. Levando em conta esse fato, o código a seguir será um exemplo de trabalho completo:

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 
}

Como alternativa, você pode encontrar constantes de densidade usando o 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
fonte
29

A resposta a seguir é uma pequena melhoria baseada na resposta de 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
fonte
1
Este código pode ter alguns elses e os e comercial e condições após a redundância.
Andrew S
1
@ Andrew, obrigado pela correção. Eu editei a resposta de acordo.
San
2
@ San Não é necessário o && em nenhuma dessas condições, desde que você verifique consistentemente> = the else if terminará na primeira condição verdadeira.
dbenson
3
Isso não retorna um resultado correto para mim com o meu Nexus 5X (um dispositivo do google padrão). A densidade do dispositivo é xxhdpi e a dupla densidade retornada é de cerca de 2,6.
precisa saber é o seguinte
20

Na verdade, se você deseja ter o dpi de exibição real, a resposta está em algum ponto, se você consultar as métricas de exibição:

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

densityDpi * 160 fornecerá os valores / sugestões de qual densidade você deve usar

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

conforme especificado nas postagens anteriores

mas dm.xdpinão fornecerá sempre o dpi REAL de determinada exibição: exemplo:

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

então talvez o dpi real da tela deva ser Densidade * xdpi .. mas não tenho certeza se essa é a maneira correta de fazer!

Marek Halmo
fonte
1
Usando Densidade * xdpi está funcionando perfeitamente até agora em todos os meus aplicativos no jogo google até agora para os últimos 6 meses
Marek Halmo
A multiplicação da densidade * xdpi não é lógica, o que é mais claro agora que existem mais dispositivos de densidade mais alta - a densidade e o xdpi aumentam, portanto, multiplicá-los seria contar o aumento duas vezes. Eu diria que o Samsung ace 2 foi um erro do fornecedor. A especificação do Android é que xdpi e ydpi são as verdadeiras densidades de pixel - não se multiplique por nada.
Home
17

Isso deve ajudar na sua atividade ...

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

}

RESULTADO : 

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
fonte
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
fonte
11

Se você deseja recuperar a densidade de um Serviço, ele funciona assim:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
Nome em Exibição
fonte
Este me ajudou quando eu não tinha de janelas
silentsudo
8

Você deve tentar isso. Acabei de adicionar um método que irá encontrar e mostrar o brinde. Aquele em que categoria o dispositivo cai.

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
fonte
7

Isso deve funcionar.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
Robby Pond
fonte
4
O tamanho em pixels da tela não é a densidade.
joshperry
1
São pixels independentes da densidade, não os pixels. E esse 320 que você vê é 320dip, não 320px. O cálculo px é diferente ver este stackoverflow.com/questions/6840904/...
Lukap
7

Ainda outra resposta:

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

Outra maneira de obter a densidade carregada pelo dispositivo:

Crie valuespastas para cada densidade

  • valores (mdpi padrão)
  • valores-hdpi
  • values-xhdpi
  • values-xxhdpi
  • values-xxxhdpi

Adicione um recurso de string em seus respectivos 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 -->

Em seguida, basta obter o recurso de string e você terá sua densidade:

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

Se a densidade for maior que XXXHDPI, será o padrão XXXHDPIou se for menor do HDPIque o padrão.MDPI

Valores de R.strings.screen_density

Eu deixei de fora LDPI, porque para o meu caso de uso não é necessário.

Pierre
fonte
Eu acho que esse é o caminho certo para obter a densidade. Como eu uso a densidade getResources (). GetDisplayMetrics ()., A densidade mudaria se eu alterar o tamanho da exibição na configuração.
Fantasy Fang
1

Tente isso ...

No kotlin

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

Você pode ligar println("density: ${determineScreenDensityCode()}") e a saída seráSystem.out: density: xxxhdpi

Silambarasan Poonguti
fonte
0

Estou usando o seguinte código para acessar o DPI dos módulos (não é necessário ter acesso a um objeto de contexto):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2
Jan Málek
fonte
0

No Android, você pode obter a densidade da tela assim:

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

E em Kotlin assim:

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
}

Verifique regularmente se novas densidades foram adicionadas .

Wirling
fonte