obtenir la densité d'écran par programme dans Android?

516

Comment obtenir la densité d'écran par programme dans Android?

Je veux dire: comment trouver la résolution d'écran de l'appareil actuel?

android  dpi  screen-density 
— Praveen
source
9
De nombreuses réponses se réfèrent à getDisplayMetrics().xdpi, ce qui est censé renvoyer le vrai dpi de l'appareil. Veuillez noter que cette valeur n'est pas systématiquement définie correctement sur les appareils par les fabricants, vous ne pouvez donc pas les utiliser . Triste mais vrai: les informations sur le vrai dpi ne sont pas disponibles . Source: groups.google.com/d/msg/android-developers/g56jV0Hora0/…
— sulai
2
getResources().getDisplayMetrics().xdpiet getResources().getDisplayMetrics().ydpivous donnera des densités horizontales et verticales réelles , qui sont dans la plupart des cas différentes.
— Ωmega

Réponses:

527

Vous pouvez obtenir des informations sur l'affichage à partir de la structure DisplayMetrics :

DisplayMetrics metrics = getResources().getDisplayMetrics();

Bien qu'Android n'utilise pas de mappage de pixels direct, il utilise une poignée de valeurs de pixels indépendants de densité quantifiés, puis s'adapte à la taille réelle de l'écran. Ainsi , la metrics.densityDpipropriété sera l' une des DENSITY_xxxconstantes ( 120, 160, 213, 240, 320, 480ou 640dpi).

Si vous avez besoin de la densité réelle de pixels lcd (peut-être pour une application OpenGL), vous pouvez l'obtenir à partir des propriétés metrics.xdpiet metrics.ydpipour la densité horizontale et verticale respectivement.

Si vous ciblez des niveaux d'API antérieurs à 4. La metrics.densitypropriété est un facteur d'échelle à virgule flottante de la densité de référence (160 dpi). La même valeur maintenant fournie par metrics.densityDpipeut être calculée

int densityDpi = (int)(metrics.density * 160f);
— joshperry
source
42
Certes, ce message date d'il y a plus de deux ans, mais c'est la première chose qui arrive sur Google pour cette recherche, donc pour quiconque le trouve, vous n'avez plus à multiplier par 160.
— roboguy12
5
Plus depuis quelle version?
— TacB0sS
J'ai mis à jour la réponse pour correspondre aux dernières révisions de l'API que les gens peuvent utiliser.
— joshperry
6
Remarque: Vous souhaiterez peut-être cette nouvelle API à la place: elle a getWindowManager().getDefaultDisplay().getRealMetrics(metrics); été officiellement ajoutée à l'API 17, mais j'ai été surpris de constater qu'elle fonctionnait correctement, même sur un appareil 4.0 que j'ai essayé.
— benkc
2
il y a aussi getResources (). getDisplayMetrics (). densityDpi
— amorenew
367

Cela fonctionne également:

 getResources().getDisplayMetrics().density;

Cela vous donnera:

0,75 - ldpi

1.0 - mdpi

1,5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4.0 - xxxhdpi

entrez la description de l'image ici

ref: densité

entrez la description de l'image ici

ref 2

— Blundell
source
10
+1 Cela fonctionne lorsque vous n'avez pas d'accès direct à WindowManager(par exemple à l'intérieur d'un chargeur). Il suffit de le multiplier par 160
— Michał K
2
L'API niveau 16 a ajouté xxdpi, qui se traduit ici par 3.0.
— QED
3
cela donnera 1,3312501 pour tvdpi. Pour plus d'informations sur tvdpivoir ici
— Dori
2
Nexus 7 rapporte 1.3, pourquoi le support devrait-il entrer?
— Neil
1
@selbie, votre téléphone tire et modifie probablement les ressources de meilleure qualité, car votre téléphone génère des rapports à mi-chemin entre deux densités définies.
— 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;
}

Cela fonctionnera au niveau 4 et supérieur de l'API.

— Mitul Nakum
source
Comment utiliseriez-vous des appareils comme le Nexus 7 qui rapportent la densité Dpi à 213?
— Neil
avoir une vérification de la main if-else entre les valeurs de densité comme, if (metrics.densityDpi> DisplayMetrics.DENSITY_LOW && metrics.densityDpi <DisplayMetrics.DENSITY_MEDIUM)
— Mitul Nakum
1
OU si (metrics.densityDpi <DisplayMetrics.DENSITY_LOW) {} else if (metrics.densityDpi <DisplayMetrics. DENSITY_MEDIUM) {} .....
— Mitul Nakum
1
Neil, 213 est appelé TV DPI, il existe une densité de métriques d'affichage nommée pour cette DENSITY_TV.
— Andrew S
63

La réponse de Blundell comme méthode d'aide statique:

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
source
qu'en est-il de la densité tvdpi. Je suppose qu'il est 1,33
— Anoop
@AnoopssGolden Ce n'est pas vraiment standard, vous pouvez donc l'ajouter si vous le souhaitez, mais je ne pense pas que la réponse devrait l'inclure. De la documentation Android: "Ce n'est pas considéré comme un groupe de densité" principal ". Il est principalement destiné aux téléviseurs et la plupart des applications ne devraient pas en avoir besoin".
— qwertzguy
Mais le périphérique nexus 7 appartient au groupe de densité tvdpi.
— Anoop
1
Je sais que c'est un peu vieux mais juste pour ajouter; MDPI peut fonctionner pour la plupart des choses sur un Nexus 7 mais comme j'essaye maintenant, les images qui descendent comme MDPI ne sont pas assez grandes. Je dois définir TVDPI, puis demander une taille d'image plus grande à mon serveur. Il n'est peut-être pas beaucoup utilisé, mais cela ne signifie pas que MDPI récupérera tout.
— RED_
3
Hé @Andrew S, l'utilisation d'elses ne change rien à l'efficacité du code puisque chaque if revient immédiatement. La suppression des accolades est une question de style uniquement et à mon humble avis, il est plus sujet aux erreurs lors de la maintenance du code.
— qwertzguy
45

Essaye ça:

DisplayMetrics dm = context.getResources().getDisplayMetrics();
int densityDpi = dm.densityDpi;
— Wizist
source
5
J'aime beaucoup mieux cela car cela dépend du contexte plutôt que de l'activité.
— greg7gkb
D'accord, je peux l'utiliser Viewbeaucoup plus facilement (c'est là que j'en ai besoin!)
— Andrew Wyld
37

Pour obtenir des 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
source
4
dm.densityDpi renvoie DENSITY_LOW ou DENSITY_MEDIUM ou DENSITY_HIGH. Et xhdpi? Y a-t-il quelque DENSITY_XHIGH ou plus?
— Eugene Chumak
— caw
34

Voici les constantes de densité, source :

entrez la description de l'image ici

Il existe, en plus des densités standard, 5 intermédiaires. Compte tenu de ce fait, le code suivant sera un exemple de travail complet:

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 
}

Alternativement, vous pouvez trouver des constantes de densité en utilisant 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
source
29

La réponse suivante est une petite amélioration basée sur la réponse 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
source
1
Ce code pourrait faire avec certains Elses, et les esperluettes et les conditions après lui sont redondantes.
— Andrew S
1
@Andrew, merci pour la correction. J'ai modifié la réponse en conséquence.
— San
2
@San Vous n'avez pas besoin du && dans aucune de ces conditions, tant que vous avez toujours vérifié> = le sinon si se terminera pour la première condition qui est vraie.
— dbenson
3
Cela ne renvoie pas un résultat correct pour moi avec mon Nexus 5X (un appareil google par défaut btw). La densité de l'appareil est xxhdpi et la double densité renvoyée est d'environ 2,6.
— Tobliug
20

En fait, si vous voulez avoir le vrai dpi d'affichage, la réponse se situe quelque part entre les deux si vous recherchez des mesures d'affichage:

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

densitéDpi * 160 vous donnera les valeurs / suggestion quelle densité vous devez utiliser

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

comme spécifié dans les articles précédents

mais dm.xdpine vous donnera pas toujours VRAI dpi de l'affichage donné: Exemple:

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

alors peut-être que le vrai dpi de l'écran devrait être Densité * xdpi .. mais je ne sais pas si c'est la bonne façon de le faire!

— Marek Halmo
source
1
L'utilisation de Density * xdpi fonctionne parfaitement jusqu'à présent sur toutes mes applications sur Google Play pour les 6 derniers mois
— Marek Halmo
Multiplier la densité * xdpi n'est pas logique, ce qui est plus clair maintenant qu'il y a plus de périphériques à densité plus élevée - la densité et xdpi augmentent à la fois, donc les multiplier équivaudrait à doubler l'augmentation. Je dirais que Samsung ace 2 était une erreur du vendeur. La spécification Android est que xdpi et ydpi sont les vraies densités de pixels - ne multipliez rien.
— ToolmakerSteve
17

Cela devrait vous aider dans votre activité ...

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

}

PRODUCTION : 

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

Si vous souhaitez récupérer la densité d'un service, cela fonctionne comme ceci:

WindowManager wm = (WindowManager) this.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
wm.getDefaultDisplay().getMetrics(metrics);
— Afficher un nom
source
Celui-ci m'a aidé quand je n'avais pas de windowManager
— silentsudo
8

Vous devriez essayer ceci. Juste ajouté une méthode qui trouvera et montrera le toast. C'est dans quelle catégorie l'appareil tombe.

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

Cela devrait fonctionner.

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width = dm.widthPixels; //320
int height = dm.heightPixels; //480
— Robby Pond
source
4
La taille en pixels de l'affichage n'est pas la densité.
— joshperry
1
Il s'agit de pixels indépendants de la densité et non des pixels. Et ce 320 que vous voyez est 320dip pas 320px. Le calcul de px est différent voir ce stackoverflow.com/questions/6840904/…
— Lukap
7

Encore une autre réponse:

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

Une autre façon d'obtenir la densité chargée par l'appareil:

Créez des valuesdossiers pour chaque densité

  • valeurs (mdpi par défaut)
  • valeurs-hdpi
  • valeurs-xhdpi
  • valeurs-xxhdpi
  • valeurs-xxxhdpi

Ajoutez une ressource de chaîne dans leurs ressources respectives 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 -->

Ensuite, obtenez simplement la ressource de chaîne et vous avez votre densité:

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

Si la densité est supérieure à XXXHDPI, elle sera par défaut XXXHDPIou si elle est inférieure à HDPIcelle par défautMDPI

Valeurs R.strings.screen_density

J'ai laissé de côté LDPI, car pour mon cas d'utilisation, ce n'est pas nécessaire.

— Pierre
source
Je pense que c'est la bonne façon d'obtenir la densité. Parce que j'utilise la densité getResources (). GetDisplayMetrics ()., La densité changerait si je modifiais la taille d'affichage dans le paramètre.
— Fantasy Fang
1

Essaye ça...

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

Vous pouvez appeler par println("density: ${determineScreenDensityCode()}") et la sortie seraSystem.out: density: xxxhdpi

— Silambarasan Poonguti
source
0

J'utilise le code suivant pour accéder à DPI à partir de modules (pas besoin d'avoir accès à un objet contextuel):

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

Dans Android, vous pouvez obtenir la densité d'écran comme ceci:

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

Et à Kotlin comme ceci:

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
}

Assurez-vous de vérifier régulièrement si de nouvelles densités sont ajoutées .

— Tourbillonnant
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.