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

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

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

Sí, hay: developer.android.com/reference/android/util/…

caw

34

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

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

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

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

Respuestas: