Question obtenir la densité de l'écran par programme dans Android?


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

Je veux dire: Comment trouver l'écran ppp de l'appareil actuel?


459
2017-07-02 14:17


origine


Réponses:


Vous pouvez obtenir des informations sur l'affichage à partir du DisplayMetrics struct:

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épendantes de densité quantifiées, puis s'adapte à la taille réelle de l'écran. Alors le metrics.densityDpi la propriété sera l'un des DENSITY_xxx les constantes (120, 160, 213, 240, 320, 480 ou 640 dpi).

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

Si vous ciblez les niveaux API avant le 4 metrics.density La propriété est un facteur d'échelle à virgule flottante à partir de la densité de référence (160 dpi). La même valeur maintenant fournie par metrics.densityDpi peut être calculé

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

479
2017-07-02 14:26



Cela fonctionne aussi:

 getResources().getDisplayMetrics().density;

Cela vous donnera:

0,75 - ldpi

1,0 - mdpi

1,5 - hdpi

2.0 - xhdpi

3.0 - xxhdpi

4,0 - xxxhdpi

enter image description here

ref: densité


334
2018-06-08 11:32



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 sur API niveau 4 et supérieur.


139
2018-03-16 09:44



Blundell répondre en tant que méthode d'assistance 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";
}

57
2017-10-08 19:07



Essaye ça:

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

44
2017-10-02 15:09



Pour obtenir ppp:

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;

35
2017-07-02 14:26



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
}

26
2018-06-24 11:42



Voici les constantes de densité, la source:

enter image description here

Il y a, en plus des densités standard, 5 Intermédiaires. Prenant en compte 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 en utilisant le densityDpi méthode:

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

23
2017-10-27 14:00



Réellement si vous voulez avoir le affichage réel en dpi la réponse est quelque part entre 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;

densityDpi * 160 vous donnera les valeurs / suggestions de densité à 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 messages précédents

mais dm.xdpi ne vous donnera pas toujours le REAL dpi d'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

donc peut-être que la vraie dpi de l'affichage devrait être Density * xdpi .. mais je ne suis pas sûr si c'est la bonne façon de faire!


18
2017-10-17 12:08



Cela devrait aider à 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);

}

SORTIE:

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

15
2017-12-10 13:40