ottenere la densità dello schermo a livello di codice in Android?


516

Come ottenere la densità dello schermo a livello di codice in Android?

Voglio dire: come trovare i dpi dello schermo del dispositivo corrente?


9
Molte risposte si riferiscono a getDisplayMetrics().xdpi, che dovrebbe restituire i dpi reali del dispositivo. Si noti che questo valore non è costantemente impostato correttamente su tutti i dispositivi dai produttori, quindi non è possibile utilizzarli . Triste ma vero: le informazioni sui dpi reali non sono disponibili . Fonte: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
sulai

2
getResources().getDisplayMetrics().xdpie getResources().getDisplayMetrics().ydpiti darà densità effettive orizzontali e verticali , che nella maggior parte dei casi sono diverse.
Ωmega

Risposte:


526

Puoi ottenere informazioni sul display dalla struttura DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Sebbene Android non utilizzi una mappatura diretta dei pixel, utilizza una manciata di valori quantizzati di pixel indipendenti dalla densità, quindi si ridimensiona alla dimensione effettiva dello schermo. Così la metrics.densityDpiproprietà sarà una delle DENSITY_xxxcostanti ( 120, 160, 213, 240, 320, 480o 640dpi).

Se hai bisogno dell'effettiva densità di pixel dell'LCD (forse per un'app OpenGL) puoi ottenerlo rispettivamente dalle proprietà metrics.xdpie metrics.ydpiper la densità orizzontale e verticale.

Se si metrics.densityscelgono come target i livelli API precedenti a 4. La proprietà è un fattore di ridimensionamento in virgola mobile rispetto alla densità di riferimento (160 dpi). È metrics.densityDpipossibile calcolare lo stesso valore ora fornito da

int densityDpi = (int)(metrics.density * 160f);

42
Concesso questo post è di oltre due anni fa, ma questa è la prima cosa che viene su Google per questa ricerca, quindi per chiunque lo trovi, non è più necessario moltiplicare per 160.
roboguy12

5
Non più da quale versione?
TacB0sS,

Ho aggiornato la risposta per abbinare le ultime revisioni API che le persone potrebbero utilizzare.
joshperry,

6
Nota: potresti preferire questa API più recente: è getWindowManager().getDefaultDisplay().getRealMetrics(metrics); stata aggiunta ufficialmente in API 17, ma sono rimasto sorpreso di scoprire che ha funzionato correttamente anche su un dispositivo 4.0 che ho provato.
benkc,

2
c'è anche getResources (). getDisplayMetrics (). densityDpi
amorenew

367

Questo funziona anche:

 getResources().getDisplayMetrics().density;

Questo ti darà:

0.75 - ldpi

1.0 - mdpi

1.5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

inserisci qui la descrizione dell'immagine

ref: densità

inserisci qui la descrizione dell'immagine

rif 2


10
+1 Funziona quando non si ha accesso diretto a WindowManager(ad esempio all'interno di un Caricatore). Basta moltiplicarlo per 160
Michał K

2
API Level 16 ha aggiunto xxdpi, che si traduce qui in 3.0.
QED

3
questo darà 1,3312501 per tvdpi. Per maggiori informazioni su tvdpivedere qui
Dori

2
Nexus 7 riporta 1.3, perché mai dovrebbe essere inserito il bracketing?
Neil

1
@selbie, il tuo telefono probabilmente sta estraendo e ridimensionando le risorse di qualità superiore poiché il tuo telefono sta segnalando a metà strada tra due densità definite.
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;
}

Funzionerà a livello di API 4 o superiore.


Come gestiresti dispositivi come Nexus 7 che riporta la densità DPI come 213?
Neil

controlla manualmente if-else tra i valori di densità come, if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
Mitul Nakum

1
OPPURE if (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} altrimenti if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
Mitul Nakum

1
Neil, 213 si chiama TV DPI, esiste una densità di metriche di visualizzazione denominata per quel DENSITY_TV.
Andrew S

63

La risposta di Blundell come metodo di supporto statico:

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

che dire della densità di tvdpi. Immagino sia l'1.33
Anoop,

@AnoopssGolden Non è proprio standard, quindi puoi aggiungerlo se vuoi, ma non credo che la risposta dovrebbe includerlo. Dai documenti Android: "Questo non è considerato un gruppo di densità" primario ". È principalmente destinato ai televisori e la maggior parte delle app non dovrebbe averne bisogno".
qwertzguy,

Ma il dispositivo nexus 7 appartiene al gruppo di densità tvdpi.
Anoop,

1
So che questo è un po 'vecchio ma solo per aggiungere; MDPI potrebbe funzionare per la maggior parte delle cose su un Nexus 7 ma, come sto provando ora, le immagini che scendono come MDPI non sono abbastanza grandi. Devo definire TVDPI e quindi chiedere un'immagine più grande dal mio server. Potrebbe non essere usato molto, ma ciò non significa che MDPI prenderà tutto.
RED_

3
Ehi @Andrew S, l'uso di elses non cambia nulla per l'efficienza del codice poiché ogni se ritorna immediatamente. Rimuovere le parentesi graffe è solo una questione di stile e IMHO rende più soggetto a errori quando si mantiene il codice.
qwertzguy,

45

Prova questo:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;

5
Mi piace molto di più poiché si basa sul contesto piuttosto che sull'attività.
greg7gkb,

D'accordo, posso usarlo Viewmolto più facilmente (che è dove ne ho bisogno!)
Andrew Wyld,

37

Per ottenere 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;

4
dm.densityDpi restituisce DENSITY_LOW o DENSITY_MEDIUM o DENSITY_HIGH. Che dire di xhdpi? C'è qualche DENSITY_XHIGH o giù di lì?
Eugene Chumak,


34

Ecco le costanti di densità, fonte :

inserisci qui la descrizione dell'immagine

Vi sono, oltre alle densità standard, 5 intermedi. Tenendo conto di questo fatto, il seguente codice sarà un esempio funzionante 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 
}

In alternativa, puoi trovare costanti di densità 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;
}

29

La seguente risposta è un piccolo miglioramento basato sulla risposta di 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
Questo codice potrebbe avere a che fare con alcuni altri, e le e commerciali e le condizioni successive sono ridondanti.
Andrew S

1
@Andrew, grazie per la correzione. Ho modificato la risposta di conseguenza.
San

2
@San Non hai bisogno di && in nessuna di queste condizioni, a patto che tu abbia verificato costantemente> = altrimenti se terminerà per la prima condizione che è vera.
dbenson,

3
Questo non restituisce un risultato corretto per me con il mio Nexus 5X (un dispositivo google predefinito tra l'altro). La densità del dispositivo è xxhdpi e la doppia densità restituita è di circa 2,6.
Tobliug,

20

In realtà, se si desidera avere il dpi di visualizzazione reale, la risposta è nel mezzo se si esegue una query per le metriche di visualizzazione:

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

densityDpi * 160 ti darà i valori / i suggerimenti su quale densità dovresti usare

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

come specificato nei post precedenti

ma dm.xdpinon ti darà sempre i DPI REALI di un determinato display: Esempio:

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

quindi forse i dpi reali del display dovrebbero essere Densità * xdpi .. ma non sono sicuro che questo sia il modo corretto di fare!


1
Utilizzando Density * xdpi funziona perfettamente finora su tutte le mie app su Google Play finora negli ultimi 6 mesi
Marek Halmo,

Moltiplicare la densità * xdpi non è logico, il che è più chiaro ora che ci sono dispositivi a densità più elevata - sia la densità che xdpi aumentano, quindi moltiplicarli sarebbe un doppio conteggio dell'aumento. Direi che Samsung Ace 2 è stato un errore da parte del venditore. Le specifiche di Android sono che xdpi e ydpi sono le densità di pixel reali, non moltiplicarsi per nulla.
ToolmakerSteve

17

Questo dovrebbe aiutarti nella tua attività ...

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

}

PRODUZIONE :

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

Se si desidera recuperare la densità da un servizio, funziona in questo modo:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);

Questo mi ha aiutato quando non avevo WindowManager
silentsudo

8

Dovresti provare questo. Appena aggiunto un metodo che troverà e mostrerà il Toast. Quello in quale categoria rientra il 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


7

Questo dovrebbe funzionare.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480

4
La dimensione in pixel del display non è la densità.
joshperry,

1
Questo è pixel indipendenti dalla densità, non i pixel. E quel 320 che vedi è 320dip non 320px. Il calcolo della px è diverso vedere questo stackoverflow.com/questions/6840904/...
Lukap

7

Ancora un'altra risposta:

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

Un altro modo per ottenere la densità caricata dal dispositivo:

Crea valuescartelle per ogni densità

  • valori (mdpi predefinito)
  • Valori-hdpi
  • Valori-xhdpi
  • Valori-xxhdpi
  • Valori-xxxhdpi

Aggiungi una risorsa stringa nei rispettivi 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 -->

Quindi prendi semplicemente la risorsa stringa e avrai la tua densità:

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

Se la densità è maggiore di XXXHDPI, verrà impostata su predefinita XXXHDPIo se è inferiore a quella HDPIpredefinitaMDPI

Valori di R.strings.screen_density

Ho lasciato fuori LDPI, perché per il mio caso d'uso non è necessario.


Penso che questo sia il modo giusto per ottenere la densità. Poiché utilizzo la densità getResources (). GetDisplayMetrics ()., La densità cambierebbe se modifico le dimensioni di visualizzazione nelle impostazioni.
Fantasy Fang

1

Prova questo...

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

Puoi chiamare println("density: ${determineScreenDensityCode()}") e l'output saràSystem.out: density: xxxhdpi


0

Sto usando il seguente codice per accedere a DPI dai moduli (non è necessario avere accesso a un oggetto di contesto):

(Resources.getSystem().getDisplayMetrics().xdpi
Resources.getSystem().getDisplayMetrics().ydpi)/2

0

In Android puoi ottenere la densità dello schermo in questo modo:

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 a Kotlin in questo modo:

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
}

Assicurati di controllare regolarmente se vengono aggiunte nuove densità .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.