obtener la densidad de la pantalla mediante programación en Android?

516

¿Cómo obtener la densidad de la pantalla mediante programación en Android?

Quiero decir: ¿Cómo encontrar la ppp de pantalla del dispositivo actual?

android  dpi  screen-density 
— Praveen
fuente
99
Muchas respuestas se refieren a getDisplayMetrics().xdpi, que se supone que devuelve el dpi real del dispositivo. Tenga en cuenta que los fabricantes no establecen este valor de forma coherente en todos los dispositivos, por lo que simplemente no puede usarlos . Triste pero cierto: la información sobre ppp reales no está disponible . Fuente: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
— sulai
2
getResources().getDisplayMetrics().xdpiy getResources().getDisplayMetrics().ydpile dará densidades horizontales y verticales reales , que en la mayoría de los casos son diferentes.
— Ωmega

Respuestas:

526

Puede obtener información sobre la pantalla desde la estructura DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Aunque Android no utiliza un mapeo de píxeles directo, utiliza un puñado de valores cuantificados de píxeles independientes de densidad y luego se escala al tamaño real de la pantalla. Por lo que la metrics.densityDpipropiedad será una de las DENSITY_xxxconstantes ( 120, 160, 213, 240, 320, 480o 640dpi).

Si necesita la densidad real de píxeles del lcd (quizás para una aplicación OpenGL), puede obtenerla de las propiedades metrics.xdpiy metrics.ydpipara la densidad horizontal y vertical, respectivamente.

Si está apuntando a niveles de API anteriores a 4. La metrics.densitypropiedad es un factor de escala de coma flotante de la densidad de referencia (160 ppp). Se metrics.densityDpipuede calcular el mismo valor ahora proporcionado por

int densityDpi = (int)(metrics.density * 160f);
— joshperry
fuente
42
De acuerdo, esta publicación es de hace más de dos años, pero esto es lo primero que aparece en Google para esta búsqueda, por lo que para cualquiera que encuentre esto, ya no tiene que multiplicar por 160.
— roboguy12
55
¿Ya no desde qué versión?
— TacB0sS
He actualizado la respuesta para que coincida con las últimas revisiones de API que las personas pueden estar usando.
— joshperry
66
Nota: es posible que desee esta API más nueva: getWindowManager().getDefaultDisplay().getRealMetrics(metrics); se agregó oficialmente en la API 17, pero me sorprendió descubrir que funcionó correctamente incluso en un dispositivo 4.0 que probé.
— benkc
2
también hay getResources (). getDisplayMetrics (). densidadDpi
— amorenew
367

Esto también funciona:

 getResources().getDisplayMetrics().density;

Esto te dará:

0,75 - ldpi

1.0 - mdpi

1.5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

ingrese la descripción de la imagen aquí

ref: densidad

ingrese la descripción de la imagen aquí

ref 2

— Blundell
fuente
10
+1 Esto funciona cuando no tienes acceso directo a WindowManager(por ejemplo, dentro de un cargador). Simplemente multiplíquelo por 160
— Michał K
2
El nivel 16 de API agregó xxdpi, que se traduce aquí a 3.0.
— QED
3
esto dará 1.3312501 para tvdpi. Para obtener más información sobre tvdpiver aquí
— Dori
2
Nexus 7 informa 1.3, ¿por qué debería entrar ese soporte?
— Neil
1
@selbie, es probable que su teléfono esté aprovechando y escalando los recursos de mayor calidad ya que su teléfono está reportando a mitad de camino entre dos 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;
}

Esto funcionará en API nivel 4 y superior.

— Mitul Nakum
fuente
¿Cómo entregaría dispositivos como Nexus 7 que reportan densidadDpi como 213?
— Neil
tener una comprobación manual if-else entre el valor de densidad como if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
— Mitul Nakum
1
O if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} más if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
— Mitul Nakum
1
Neil, 213 se llama TV DPI, hay una densidad de métricas de visualización con nombre para ese DENSITY_TV.
— Andrew S
63

La respuesta 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
fuente
¿Qué pasa con la densidad tvdpi. Supongo que es 1.33
— Anoop
@AnoopssGolden No es realmente estándar, por lo que puede agregarlo si lo desea, pero no creo que la respuesta deba incluirlo. De los documentos de Android: "Esto no se considera un grupo de densidad" primario ". Está destinado principalmente a televisores y la mayoría de las aplicaciones no deberían necesitarlo".
— qwertzguy
Pero el dispositivo nexus 7 pertenece al grupo de densidad tvdpi.
— Anoop
1
Sé que esto es un poco viejo pero solo para agregar; MDPI podría funcionar para la mayoría de las cosas en un Nexus 7, pero como lo estoy intentando ahora, las imágenes que aparecen como MDPI no son lo suficientemente grandes. Tengo que definir TVDPI y luego pedir un tamaño de imagen más grande a mi servidor. Puede que no se use mucho, pero eso no significa que MDPI recogerá todo.
— RED_
3
Hola @ Andrew S, el uso de elses no cambia nada la eficiencia del código, ya que cada if regresa de inmediato. Quitar llaves es solo una cuestión de estilo y, en mi humilde opinión, es más propenso a errores al mantener el código.
— qwertzguy 01 de
45

Prueba esto:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
— Wizist
fuente
55
Me gusta mucho más, ya que depende del contexto en lugar de la actividad.
— greg7gkb
De acuerdo, puedo usar esto desde Viewmucho más fácilmente (¡que es donde lo necesito!)
— Andrew Wyld
37

Para obtener 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
fuente
44
dm.densityDpi devuelve DENSITY_LOW o DENSITY_MEDIUM o DENSITY_HIGH. ¿Qué hay de xhdpi? ¿Hay alguna DENSITY_XHIGH más o menos?
— Eugene Chumak
— caw
34

Aquí están las constantes de densidad, fuente :

ingrese la descripción de la imagen aquí

Hay, además de las densidades estándar, 5 intermedias. Teniendo en cuenta este hecho, el siguiente código será un ejemplo de trabajo 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 
}

Alternativamente, puede encontrar constantes de densidad usando 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
fuente
29

La siguiente respuesta es una pequeña mejora basada en la respuesta 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
fuente
1
Este código podría funcionar con algunos otros, y los símbolos y condiciones posteriores son redundantes.
— Andrew S
1
@ Andrew, gracias por la corrección. He editado la respuesta en consecuencia.
— San
2
@San No necesita el && en ninguna de esas condiciones, siempre y cuando haya verificado constantemente> = el otro si terminará por la primera condición que sea verdadera.
— dbenson
3
Esto no me devuelve un resultado correcto con mi Nexus 5X (un dispositivo de Google predeterminado, por cierto). La densidad del dispositivo es xxhdpi, y la densidad doble devuelta es de alrededor de 2.6.
— Tobliug
20

En realidad, si desea tener el dpi de visualización real, la respuesta está en algún punto intermedio si consulta las métricas de visualización:

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

densidadDpi * 160 le dará los valores / sugerencia de qué densidad debe 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

como se especifica en publicaciones anteriores

pero dm.xdpino siempre le dará el dpi REAL de la pantalla dada: Ejemplo:

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

así que tal vez el dpi real de la pantalla debería ser Densidad * xdpi ... ¡pero no estoy seguro de si esta es la forma correcta de hacerlo!

— Marek Halmo
fuente
1
Usar Density * xdpi funciona perfectamente hasta ahora en todas mis aplicaciones en Google Play hasta ahora durante los últimos 6 meses
— Marek Halmo
Multiplicar la densidad * xdpi no es lógico, lo que es más claro ahora que hay más dispositivos de mayor densidad, tanto la densidad como el aumento de xdpi, por lo que multiplicarlos sería contar dos veces el aumento. Yo diría que Samsung ace 2 fue un error del vendedor. La especificación de Android es que xdpi e ydpi son las verdaderas densidades de píxeles, no se multipliquen por nada.
— ToolmakerSteve
17

Esto debería ayudar en su actividad ...

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

}

SALIDA 

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

Si desea recuperar la densidad de un Servicio, funciona así:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
— Nombre para mostrar
fuente
Este me ayudó cuando no tenía windowManager
— silencio el
8

Deberías probar esto. Acabo de agregar un método que encontrará y mostrará la tostada. Eso en qué categoría cae el dispositivo.

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

Esto debería funcionar.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
— Estanque Robby
fuente
44
El tamaño en píxeles de la pantalla no es la densidad.
— joshperry
1
Esto es píxeles independientes de la densidad, no los píxeles. Y ese 320 que ves es 320dip, no 320px. El cálculo de px es diferente, vea este stackoverflow.com/questions/6840904/…
— Lukap
7

Otra respuesta más:

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

Otra forma de obtener la densidad cargada por el dispositivo:

Crear valuescarpetas para cada densidad.

  • valores (mdpi predeterminado)
  • valores-hdpi
  • valores-xhdpi
  • valores-xxhdpi
  • valores-xxxhdpi

Agregue un recurso de cadena en sus 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 -->

Luego, simplemente obtenga el recurso de cadena y tendrá su densidad:

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

Si la densidad es mayor que XXXHDPI, su valor predeterminado será XXXHDPIo si es menor de HDPIlo que será predeterminadoMDPI

Valores de R.strings.screen_density

Lo dejé fuera LDPI, porque para mi caso de uso no es necesario.

— Pierre
fuente
Creo que esta es la forma correcta de obtener la densidad. Como uso la densidad getResources (). GetDisplayMetrics ()., La densidad cambiaría si cambio el tamaño de visualización en la configuración.
— Fantasy Fang
1

Prueba esto...

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

Puede llamar println("density: ${determineScreenDensityCode()}") y la salida seráSystem.out: density: xxxhdpi

— Silambarasan Poonguti
fuente
0

Estoy usando el siguiente código para acceder a DPI desde los módulos (no es necesario tener acceso a un objeto de contexto):

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

En Android puedes obtener la densidad de pantalla de esta manera:

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

Y en Kotlin así:

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
}

Asegúrese de verificar regularmente si se agregan nuevas densidades .

— Wirling
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.