Comment déterminer la catégorie de taille d'écran de l'appareil (petit, normal, grand, xlarge) à l'aide du code?

308

Existe-t-il un moyen de déterminer la catégorie de taille d'écran de l'appareil actuel, telle que petite, normale, grande, xlarge?

Pas la densité, mais la taille de l'écran.

android  screen  android-screen-support 
— vieux
source

Réponses:

420

Vous pouvez utiliser le Configuration.screenLayoutbitmask.

Exemple:

if ((getResources().getConfiguration().screenLayout & 
    Configuration.SCREENLAYOUT_SIZE_MASK) == 
        Configuration.SCREENLAYOUT_SIZE_LARGE) {
    // on a large screen device ...

}
— Jeff Gilfelt
source
31
Pour obtenir une détection x-large, assurez-vous d'utiliser la cible android-3.0 dans votre projet. Ou utilisez la valeur statique 4 pour x-large.
— Peterdk
5
Certains appareils peuvent avoir une taille non définie de l'écran, il peut donc être utile de vérifier également avec Configuration.SCREENLAYOUT_SIZE_UNDEFINED.
— valerybodak
Pourriez-vous utiliser> = pour obtenir des écrans plus grands ou plus grands?
— Andrew S
150

Le code ci-dessous étoffe la réponse ci-dessus, affichant la taille de l' écran sous forme de Toast.

//Determine screen size
if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
    Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
    Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG).show();
}
else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
    Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Screen size is neither large, normal or small", Toast.LENGTH_LONG).show();
}

Ce code ci-dessous affiche la densité de l' écran sous forme de pain grillé.

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density == DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else if (density == DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density), Toast.LENGTH_LONG).show();
}
— Mel
source
Le toast est agréable à préparer.
— MinceMan
quelqu'un peut-il confirmer extra-large?
— Nathan H
68

Réponse de Jeff Gilfelt en tant que méthode d'assistance statique:

private static String getSizeName(Context context) {
    int screenLayout = context.getResources().getConfiguration().screenLayout;
    screenLayout &= Configuration.SCREENLAYOUT_SIZE_MASK;

    switch (screenLayout) {
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        return "small";
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        return "normal";
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        return "large";
    case 4: // Configuration.SCREENLAYOUT_SIZE_XLARGE is API >= 9
        return "xlarge";
    default:
        return "undefined";
    }
}
— qwertzguy
source
12 
private String getDeviceDensity() {
    int density = mContext.getResources().getDisplayMetrics().densityDpi;
    switch (density)
    {
        case DisplayMetrics.DENSITY_MEDIUM:
            return "MDPI";
        case DisplayMetrics.DENSITY_HIGH:
            return "HDPI";
        case DisplayMetrics.DENSITY_LOW:
            return "LDPI";
        case DisplayMetrics.DENSITY_XHIGH:
            return "XHDPI";
        case DisplayMetrics.DENSITY_TV:
            return "TV";
        case DisplayMetrics.DENSITY_XXHIGH:
            return "XXHDPI";
        case DisplayMetrics.DENSITY_XXXHIGH:
            return "XXXHDPI";
        default:
            return "Unknown";
    }
}
— Pawan Maheshwari
source
1
Cela obtient la densité de l'écran. La question spécifie "Pas la densité, mais la taille de l'écran".
— Subaru Tashiro
11

Merci pour les réponses ci-dessus, cela m'a beaucoup aidé :-) Mais pour ceux (comme moi) obligés de continuer à prendre en charge Android 1.5, nous pouvons utiliser la réflexion java pour une compatibilité descendante:

Configuration conf = getResources().getConfiguration();
int screenLayout = 1; // application default behavior
try {
    Field field = conf.getClass().getDeclaredField("screenLayout");
    screenLayout = field.getInt(conf);
} catch (Exception e) {
    // NoSuchFieldException or related stuff
}
// Configuration.SCREENLAYOUT_SIZE_MASK == 15
int screenType = screenLayout & 15;
// Configuration.SCREENLAYOUT_SIZE_SMALL == 1
// Configuration.SCREENLAYOUT_SIZE_NORMAL == 2
// Configuration.SCREENLAYOUT_SIZE_LARGE == 3
// Configuration.SCREENLAYOUT_SIZE_XLARGE == 4
if (screenType == 1) {
    ...
} else if (screenType == 2) {
    ...
} else if (screenType == 3) {
    ...
} else if (screenType == 4) {
    ...
} else { // undefined
    ...
}
— A. Masson
source
2
Vous pouvez cibler la dernière version de la plateforme et référencer les constantes de la Configurationclasse. Ce sont des valeurs finales statiques qui seront alignées au moment de la compilation (c'est-à-dire qu'elles seront remplacées par leurs valeurs réelles), donc votre code ne se cassera pas sur les anciennes versions de la plateforme.
— Karakuri
Bien, je ne le savais pas ... Tu parles d'Android: targetSdkVersion?
— A. Masson
1
Oui, c'est ainsi que vous viseriez une version particulière. La plupart des gens (du moins que j'ai vus) ont réglé leur targetSdkVersiondernière version.
— Karakuri
9

Si vous souhaitez connaître facilement la densité d'écran et la taille d'un appareil Android, vous pouvez utiliser cette application gratuite (sans autorisation requise): https://market.android.com/details?id=com.jotabout.screeninfo

— mmathieum
source
3
Cette question ne concerne pas un appareil spécifique, mais la programmation de plusieurs profils de division (qui est un processus de développement logiciel important lors du développement pour les plates-formes mobiles).
— mtmurdock
1
une bonne application à connaître est disponible sur le marché - il serait également agréable de voir le code que l'application utilise pour trouver ses informations
— Stan Kurdziel
4
@StanKurdziel Le code source est publié sous la licence open-source du MIT et est disponible sur: github.com/mportuesisf/ScreenInfo
— mmathieum
Ce lien est mort maintenant
— Vadim Kotov
5

Besoin de vérifier les écrans xlarge et les densités x..high? Il s'agit du code modifié de la réponse choisie.

//Determine screen size
if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {     
    Toast.makeText(this, "Large screen",Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {     
    Toast.makeText(this, "Normal sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {     
    Toast.makeText(this, "Small sized screen" , Toast.LENGTH_LONG).show();
} else if ((getResources().getConfiguration().screenLayout &      Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {     
    Toast.makeText(this, "XLarge sized screen" , Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Screen size is neither large, normal or small" , Toast.LENGTH_LONG).show();
}

//Determine density
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
int density = metrics.densityDpi;

if (density==DisplayMetrics.DENSITY_HIGH) {
    Toast.makeText(this, "DENSITY_HIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_MEDIUM) {
    Toast.makeText(this, "DENSITY_MEDIUM... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_LOW) {
    Toast.makeText(this, "DENSITY_LOW... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XHIGH) {
    Toast.makeText(this, "DENSITY_XHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXHIGH) {
    Toast.makeText(this, "DENSITY_XXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else if (density==DisplayMetrics.DENSITY_XXXHIGH) {
    Toast.makeText(this, "DENSITY_XXXHIGH... Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
} else {
    Toast.makeText(this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + String.valueOf(density),  Toast.LENGTH_LONG).show();
}
— Tom McFarlin
source
[Densité] Dans ce cas, vous devez être en activité. Si vous êtes à l'extérieur, utilisez getWindowManager () ce code WindowManager windowManager = (WindowManager) context .getSystemService (Context.WINDOW_SERVICE);
— horkavlna
3

Voici une version Xamarin.Android de la réponse de Tom McFarlin 

        //Determine screen size
        if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeLarge) {
            Toast.MakeText (this, "Large screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeNormal) {
            Toast.MakeText (this, "Normal screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeSmall) {
            Toast.MakeText (this, "Small screen", ToastLength.Short).Show ();
        } else if ((Application.Context.Resources.Configuration.ScreenLayout & ScreenLayout.SizeMask) == ScreenLayout.SizeXlarge) {
            Toast.MakeText (this, "XLarge screen", ToastLength.Short).Show ();
        } else {
            Toast.MakeText (this, "Screen size is neither large, normal or small", ToastLength.Short).Show ();
        }
        //Determine density
        DisplayMetrics metrics = new DisplayMetrics();
        WindowManager.DefaultDisplay.GetMetrics (metrics);
        var density = metrics.DensityDpi;
        if (density == DisplayMetricsDensity.High) {
            Toast.MakeText (this, "DENSITY_HIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Medium) {
            Toast.MakeText (this, "DENSITY_MEDIUM... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Low) {
            Toast.MakeText (this, "DENSITY_LOW... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xhigh) {
            Toast.MakeText (this, "DENSITY_XHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxhigh) {
            Toast.MakeText (this, "DENSITY_XXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else if (density == DisplayMetricsDensity.Xxxhigh) {
            Toast.MakeText (this, "DENSITY_XXXHIGH... Density is " + density, ToastLength.Long).Show ();
        } else {
            Toast.MakeText (this, "Density is neither HIGH, MEDIUM OR LOW.  Density is " + density, ToastLength.Long).Show ();
        }
— ellechino
source
2
Veuillez ne pas simplement vider du code mais expliquer ce que vous avez fait et comment cela aide
— David Medenjak
2

Essayez cette fonction isLayoutSizeAtLeast (int screenSize)

Pour vérifier le petit écran, au moins 320x426 dp et plus getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_SMALL);

Pour vérifier l'écran normal, au moins 320x470 dp et plus getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_NORMAL);

Pour vérifier un grand écran, au moins 480x640 dp et plus getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_LARGE);

Pour vérifier un écran extra large, au moins 720x960 dp et plus getResources (). GetConfiguration (). IsLayoutSizeAtLeast (Configuration.SCREENLAYOUT_SIZE_XLARGE);

— Devendra Vaja
source
Agréable! Cette méthode est également disponible dès le niveau d'API 11!
— Enselic
2

En 2018, si vous avez besoin de la réponse de Jeff dans Kotlin, la voici:

  private fun determineScreenSize(): String {
    // Thanks to https://stackoverflow.com/a/5016350/2563009.
    val screenLayout = resources.configuration.screenLayout
    return when {
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_SMALL -> "Small"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_NORMAL -> "Normal"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_LARGE -> "Large"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_XLARGE -> "Xlarge"
      screenLayout and Configuration.SCREENLAYOUT_SIZE_MASK == Configuration.SCREENLAYOUT_SIZE_UNDEFINED -> "Undefined"
      else -> error("Unknown screenLayout: $screenLayout")
    }
  }
— Thuy Trinh
source
1

Ne pourriez-vous pas faire cela en utilisant une ressource de chaîne et des énumérations? Vous pouvez définir une ressource de chaîne portant le nom de la taille d'écran, telle que SMALL, MEDIUM ou LARGE. Ensuite, vous pouvez utiliser la valeur de la ressource de chaîne pour créer une instance de l'énumération.

  1. Définissez une énumération dans votre code pour les différentes tailles d'écran qui vous intéressent. 

    public Enum ScreenSize {
    SMALL,
    MEDIUM,
    LARGE,;
}

  2. Définissez une ressource de chaîne, par exemple screensize, dont la valeur sera SMALL, MEDIUM ou LARGE. 

    <string name="screensize">MEDIUM</string>
  3. Mettez une copie de screensizedans une ressource de chaîne dans chaque dimension qui vous intéresse.
    Par exemple, <string name="screensize">MEDIUM</string>irait dans values-sw600dp / strings.xml et values-medium / strings.xml et<string name="screensize">LARGE</string> irait dans sw720dp / strings.xml et values-large / strings.xml.
  4. Dans le code, écrivez
    ScreenSize size = ScreenSize.valueOf(getReources().getString(R.string.screensize);
— Prof Mo
source
C'était prometteur ... Cependant, j'ai testé avec 3 appareils et la tablette revient toujours PETITE quand je m'attends à GRAND. Mes fichiers string.xml sont définis dans values-h1024dp, values-h700dp et values-h200dp avec le <string name = "screensize"> xxxxxx </string> correspondant
— A. Masson
1

Copiez et collez ce code dans votre Activityet lorsqu'il sera exécuté, il correspondra à Toastla catégorie de taille d'écran de l'appareil.

int screenSize = getResources().getConfiguration().screenLayout &
        Configuration.SCREENLAYOUT_SIZE_MASK;

String toastMsg;
switch(screenSize) {
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        toastMsg = "Large screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        toastMsg = "Normal screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        toastMsg = "Small screen";
        break;
    default:
        toastMsg = "Screen size is neither large, normal or small";
}
Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();
— Alireza Ghanbarinia
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.