Détecter les tablettes de 7 et 10 pouces par programmation
Existe-t-il un moyen de rechercher par programme si le périphérique sur lequel l'application est installée est une tablette de 7 pouces ou une tablette de 10 pouces?
Vous pouvez utiliser DisplayMetrics pour obtenir de nombreuses informations sur l'écran sur lequel votre application s'exécute.
Tout d'abord, nous créons un objet métrique DisplayMetrics:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
À partir de là, nous pouvons obtenir les informations nécessaires pour dimensionner l’affichage:
int widthPixels = metrics.widthPixels;
int heightPixels = metrics.heightPixels;
Cela retournera la valeur absolue de la largeur et de la hauteur en pixels, donc 1280x720 pour le Galaxy SIII, le Galaxy Nexus, etc.
Ce n'est généralement pas utile en soi, car lorsque nous travaillons sur des périphériques Android, nous préférons généralement travailler en pixels indépendants de la densité, dip.
Vous obtenez le density de l'écran en utilisant metrics à nouveau, sous la forme d'un facteur d'échelle pour le périphérique, qui est basé sur le Android Design Resources pour mdpi, hdpi etc. 
float scaleFactor = metrics.density;
À partir de ce résultat, nous pouvons calculer la quantité de pixels indépendants de la densité pour une certaine hauteur ou largeur.
float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor
Le résultat obtenu vous aidera à choisir le type d’écran sur lequel vous travaillez en conjonction avec exemples de configuration Android , qui vous donne le dp relatif pour chaque taille d’écran:
- 320dp: un écran de téléphone typique (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc.).
- 480dp: une tablette tweener comme le Streak (480x800 mdpi).
- 600dp: une tablette de 7 ”(600x1024 mdpi).
- 720dp: une tablette de 10 pouces (720x1280 mdpi, 800x1280 mdpi, etc.).
En utilisant les informations ci-dessus, nous savons que si la plus petite largeur du périphérique est supérieure à 600dp, le périphérique est une tablette 7 ", si elle est supérieure à 720dp, le périphérique est une tablette 10".
Nous pouvons travailler sur la plus petite largeur en utilisant la fonction min de Math class, en passant le heightDp et le widthDp pour renvoyer le smallestWidth.
float smallestWidth = Math.min(widthDp, heightDp);
if (smallestWidth > 720) {
//Device is a 10" tablet
}
else if (smallestWidth > 600) {
//Device is a 7" tablet
}
Cependant, cela ne vous donne pas toujours une correspondance exacte, en particulier lorsque vous travaillez avec des tablettes obscures qui pourraient faussement représenter leur densité en tant que hdpi quand ce n'est pas le cas, ou qui pourraient n'être que de 800 x 480 pixels tout en restant sur un écran de 7 " .
En plus de ces méthodes, si vous avez besoin de connaître les dimensions exactes d’un périphérique en pouces, vous pouvez également résoudre ce problème en utilisant la méthode metrics pour connaître le nombre de pixels par pouce de l’écran.
float widthDpi = metrics.xdpi;
float heightDpi = metrics.ydpi;
Vous pouvez utiliser la connaissance du nombre de pixels par pouce d'appareil et du nombre total de pixels pour déterminer le nombre de pouces de l'appareil.
float widthInches = widthPixels / widthDpi;
float heightInches = heightPixels / heightDpi;
Cela renverra la hauteur et la largeur de l'appareil en pouces. Encore une fois, cela n’aide pas toujours beaucoup à déterminer le type d’appareil, car la taille d’un appareil annoncée est la diagonale, tout ce dont nous disposons est la hauteur et la largeur.
Cependant, nous savons aussi que, compte tenu de la hauteur d’un triangle et de sa largeur, nous pouvons utiliser le théorème de Pythagore pour déterminer la longueur de l’hypoténuse (dans ce cas, la taille de la diagonale de l’écran).
//a² + b² = c²
//The size of the diagonal in inches is equal to the square root of the height in inches squared plus the width in inches squared.
double diagonalInches = Math.sqrt(
(widthInches * widthInches)
+ (heightInches * heightInches));
À partir de là, nous pouvons déterminer si le périphérique est une tablette ou non:
if (diagonalInches >= 10) {
//Device is a 10" tablet
}
else if (diagonalInches >= 7) {
//Device is a 7" tablet
}
Et c'est ainsi que vous calculez le type d'appareil avec lequel vous travaillez.
Rien ne dit 7" Ou 10" Autant que je sache. Il existe environ deux manières d'obtenir les dimensions d'écran utilisées par le système lors du décodage de bitmaps et ainsi de suite. Ils se trouvent tous les deux dans l’objet Resources de l’application se trouvant dans Context.
Le premier est l'objet Configuration qui peut être obtenu par getContext().getResources().getConfiguration(). Dans ce que vous avez:
Configuration#densityDpi - Densité d'écran cible à laquelle correspond le qualificateur de ressource de densité.
Configuration#screenHeightDp - La hauteur actuelle de l'espace d'écran disponible, en unités dp, correspondant au qualificateur de ressource de hauteur d'écran.
Configuration#screenWidthDp - La largeur actuelle de l'espace d'écran disponible, en unités dp, correspondant au qualificateur de ressource de largeur d'écran.
Configuration#smallestScreenWidthDp - La plus petite taille d'écran qu'une application verra en fonctionnement normal, correspondant au qualificateur de ressource de plus petite largeur d'écran.
Avec cela, vous pouvez très bien utiliser les instructions à l'écran pour déterminer si votre appareil extrait des dossiers de ressources spécialisés respectifs (hdpi, xhdpi, large, xlarge, etc.).
Rappelez-vous, voici quelques-uns des seaux:
- xgrands écrans font au moins 960dpx 720dp
- les grands écrans font au moins 640dpx 480dp
- les écrans normaux font au moins 470dx x 320dp
les petits écrans font au moins 426dpx 320dp
320dp: un écran de téléphone typique (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc.).
- 480dp: une tablette tweener comme le Streak (480x800 mdpi).
- 600dp: une tablette de 7 ”(600x1024 mdpi).
- 720dp: une tablette de 10 pouces (720x1280 mdpi, 800x1280 mdpi, etc.).
Le second est l’objet DisplayMetrics obtenu par getContext().getResources().getDisplayMetrics(). En ce que vous avez:
DisplayMetrics#density - La densité logique de l'affichage.
DisplayMetrics#densityDpi - La densité de l'écran exprimée en points par pouce.
DisplayMetrics#heightPixels - La hauteur absolue de l'affichage en pixels.
DisplayMetrics#widthPixels - La largeur absolue de l'affichage en pixels.
DisplayMetrics#xdpi - Les pixels physiques exacts par pouce de l'écran dans la dimension X.
DisplayMetrics#ydpi - Les pixels physiques exacts par pouce de l'écran dans la dimension Y.
C'est pratique si vous avez besoin d'un nombre de pixels exact de l'écran plutôt que de la densité. Cependant, il est important de noter qu'il s'agit de tous pixels de l'écran. Pas seulement ceux disponibles pour vous.
placez cette méthode dans onResume () et pouvez vérifier.
public double tabletSize() {
double size = 0;
try {
// Compute screen size
DisplayMetrics dm = context.getResources().getDisplayMetrics();
float screenWidth = dm.widthPixels / dm.xdpi;
float screenHeight = dm.heightPixels / dm.ydpi;
size = Math.sqrt(Math.pow(screenWidth, 2) +
Math.pow(screenHeight, 2));
} catch(Throwable t) {
}
return size;
}
généralement les comprimés commencent après la taille de 6 pouces.
Ce qui précède ne fonctionne pas toujours lors de la commutation portrait/paysage.
Si vous ciblez l'API de niveau 13 ou supérieur, procédez comme décrit ci-dessus - utilisez Configuration.smallestScreenWidthDp, puis testez-le en conséquence:
resources.getConfiguration().smallestScreenWidthDp
Sinon, si vous pouvez vous le permettre, utilisez la méthode suivante, qui est une approche très précise pour détecter une résolution de 600dp (comme 6 ") par rapport à 720dp (comme 10") en laissant le système vous dire:
1) Ajoutez à layout-sw600dp et layout-sw720dp (et éventuellement son paysage) une vue invisible avec le bon identifiant, par exemple:
Pour 720, sur layout-sw720dp:
<View Android:id="@+id/sw720" Android:layout_width="0dp" Android:layout_height="0dp" Android:visibility="gone"/>
Pour 600, sur layout-sw600dp:
<View Android:id="@+id/sw600" Android:layout_width="0dp" Android:layout_height="0dp" Android:visibility="gone"/>
2) Ensuite, sur le code, par exemple, Activity, testez en conséquence:
private void showFragment() {
View v600 = (View) findViewById(R.id.sw600);
View v720 = (View) findViewById(R.id.sw720);
if (v600 != null || v720 !=null)
albumFrag = AlbumGridViewFragment.newInstance(albumRefresh);
else
albumFrag = AlbumListViewFragment.newInstance(albumRefresh);
getSupportFragmentManager()
.beginTransaction()
.replace(R.id.view_container, albumFrag)
.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
.commit();
}
Excellente information, exactement ce que je cherchais! Cependant, après avoir essayé cela, j’ai constaté que lorsqu’on utilisait les mesures mentionnées ici, les rapports Nexus 7 (modèle 2012) avaient des dimensions de 1280x736. J'ai aussi un Motorola Xoom sous Jelly Bean et il rapporte de manière incorrecte une résolution de 1280x752. Je suis tombé sur ce post ici qui le confirme. Fondamentalement, dans ICS/JB, les calculs utilisant les métriques mentionnées ci-dessus semblent exclure les dimensions de la barre de navigation. Quelques recherches supplémentaires m'ont amené à réponse de Frank Nguyen ici qui utilise différentes méthodes qui vous donneront les dimensions brutes (ou réelles) de l'écran. Mes tests initiaux ont montré que le code suivant de Frank rapporte correctement les dimensions du Nexus 7 (runnin JB modèle 2012) et de mon Motorola Xoom exécutant JB:
int width = 0, height = 0;
final DisplayMetrics metrics = new DisplayMetrics();
Display display = getWindowManager().getDefaultDisplay();
Method mGetRawH = null, mGetRawW = null;
try {
// For JellyBeans and onward
if (Android.os.Build.VERSION.SDK_INT >= Android.os.Build.VERSION_CODES.JELLY_BEAN) {
display.getRealMetrics(metrics);
width = metrics.widthPixels;
height = metrics.heightPixels;
} else {
mGetRawH = Display.class.getMethod("getRawHeight");
mGetRawW = Display.class.getMethod("getRawWidth");
try {
width = (Integer) mGetRawW.invoke(display);
height = (Integer) mGetRawH.invoke(display);
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} catch (NoSuchMethodException e3) {
e3.printStackTrace();
}
J'ai deux Android appareil avec la même résolution
Périphérique1 -> résolution 480x800 diagonale - 4,7 pouces
Périphérique 2 -> résolution 480x800 diagonale - 4 pouces
Il donne à la fois la taille de l'écran en diagonale -> 5.8
la solution à votre problème est ..
DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width=dm.widthPixels;
int height=dm.heightPixels;
int dens=dm.densityDpi;
double wi=(double)width/(double)dens;
double hi=(double)height/(double)dens;
double x = Math.pow(wi,2);
double y = Math.pow(hi,2);
double screenInches = Math.sqrt(x+y);
voir détails ici ..
Vous pouvez utiliser la méthode ci-dessous pour obtenir la taille de l'écran en pouces. Sur cette base, vous pouvez simplement vérifier quelle tablette ou quel téléphone est l'appareil.
private static double checkDimension(Context context) {
WindowManager windowManager = ((Activity)context).getWindowManager();
Display display = windowManager.getDefaultDisplay();
DisplayMetrics displayMetrics = new DisplayMetrics();
display.getMetrics(displayMetrics);
// since SDK_INT = 1;
int mWidthPixels = displayMetrics.widthPixels;
int mHeightPixels = displayMetrics.heightPixels;
// includes window decorations (statusbar bar/menu bar)
try
{
Point realSize = new Point();
Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize);
mWidthPixels = realSize.x;
mHeightPixels = realSize.y;
}
catch (Exception ignored) {}
DisplayMetrics dm = new DisplayMetrics();
windowManager.getDefaultDisplay().getMetrics(dm);
double x = Math.pow(mWidthPixels/dm.xdpi,2);
double y = Math.pow(mHeightPixels/dm.ydpi,2);
double screenInches = Math.sqrt(x+y);
Log.d("debug","Screen inches : " + screenInches);
return screenInches;
}
Ainsi, Android indique tailles d’écran se divise en quatre tailles généralisées: petit , normal , grand et xlarge .
Alors que le Android documentation indique que les groupes de taille sont obsolètes
... ces groupes de taille sont déconseillés au profit d'une nouvelle technique de gestion des tailles d'écran basée sur la largeur d'écran disponible. Si vous développez pour Android 3.2 et versions supérieures, consultez la section [Déclaration des dispositions de tablette pour Android 3.2] (hdpi (haute)) ~ 240 dpi)) pour plus d'informations.
Généralement, le qualificateur de taille large spécifie une tablette de 7 ". Et un qualificateur de taille de xlarge spécifie une tablette de 10 ":
La bonne chose à propos du déclenchement sur le qualificatif de taille, est que vous pouvez garantir que vos actifs et votre code sont en accord sur l’actif à utiliser ou le chemin de code à activer.
Pour récupérer le qualificateur de taille dans le code, effectuez les appels suivants:
int sizeLarge = SCREENLAYOUT_SIZE_LARGE // For 7" tablet
boolean is7InchTablet = context.getResources().getConfiguration()
.isLayoutSizeAtLeast(sizeLarge);
int sizeXLarge = SCREENLAYOUT_SIZE_XLARGE // For 10" tablet
boolean is10InchTablet = context.getResources().getConfiguration()
.isLayoutSizeAtLeast(sizeXLarge);
Je stockais une valeur dans dossier de valeurs qui me donne l'écran est de 7 pouces ou 10 inc, mais nous pouvons le faire pour tout appareil utilisant le dossier de valeurs.
comme créer un dossier de valeurs différentes pour deux appareils différents. Mais cette chose dépend de l'exigence.
Autrement:
Créez 2 autres dossiers: values-large + values-xlarge
Mettez:
<string name="screentype">LARGE</string>dans le dossier values-large (strings.xml)Mettez:
<string name="screentype">XLARGE</string>dans le dossier values-xlarge (strings.xml)Dans du code:
String mType = getString (R.string.screentype);
if (mType! = null && mType.equals ("LARGE") {
// de 4 ~ 7 pouces
} else if (mType! = null && mType.equals ("XLARGE") {
// de 7 ~ 10 pouces
}
Vous devrez faire un peu de calcul en utilisant les données fournies par la classe DisplayMetrics .
Vous avez heightPixel et widthPixels (la résolution de l'écran en pixels)
Vous avez besoin de la diagonale car la "taille d'écran" décrit toujours la longueur de la diagonale. Vous pouvez obtenir la diagonale de l'écran en pixel (avec pythagore)
diagonalPixel = √ (heightPixel² + widthPixels²)
vous pouvez ensuite convertir la valeur en pixels en pouces grâce à la valeur DensitéDPI:
inchDiag = diagonalPixel/densitéDPI.
J'espère que je n'ai pas commis d'erreur ici, sachez que les valeurs que vous obtenez de la classe DisplayMetrics sont données par le constructeur, il apparaît (dans de très rares cas) qu'elles ne sont pas bien définies en fonction du matériau physique ...
Cela vous donnera la taille de l'écran physique mais ce n'est probablement pas la meilleure façon de gérer plusieurs mises en page. Plus sur ce sujet
Voila! ???? C'est tout ce dont vous aurez besoin pour distinguer les tablettes des téléphones
1. Fonction d'assistance pour obtenir la largeur de l'écran:
private float getScreenWidth() {
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}
2. Fonction permettant de déterminer si un appareil est une tablette
boolean isTablet() {
return getScreenWidth() >= 600;
}
3. Enfin, si vous souhaitez effectuer différentes opérations pour différentes tailles d’appareils:
boolean is7InchTablet() {
return getScreenWidth() >= 600 && getScreenWidth() < 720;
}
boolean is10InchTablet() {
return getScreenWidth() >= 720;
}