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?

android  dpi  screen-density 
— Praveen
fonte
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);
— joshperry
fonte
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

— Blundell
fonte
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.

— Mitul Nakum
fonte
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";
}
— qwertzguy
fonte
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;
— Wizist
fonte
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;
— Jere.Jones
fonte
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,
— caw
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;
}
— Ayaz Alifov
fonte
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
}
— San
fonte
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!

— Marek Halmo
fonte
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
— 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 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);
— Nome da visualizzare
fonte
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

— Avinash Verma
fonte
7

Questo dovrebbe funzionare.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
— Robby Pond
fonte
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";
    }
}
— Jared Rummler
fonte
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.

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

— Silambarasan Poonguti
fonte
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
— Jan Málek
fonte
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à .

— Wirling
fonte
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.