Existe-t-il un moyen de savoir par programme si l'appareil sur lequel l'application est installée est une tablette de 7 pouces ou une tablette de 10 pouces?
Existe-t-il un moyen de savoir par programme si l'appareil sur lequel l'application est installée est une tablette de 7 pouces ou une tablette de 10 pouces?
Réponses:
Vous pouvez utiliser le DisplayMetrics
pour obtenir de nombreuses informations sur l'écran sur lequel votre application s'exécute.
Tout d'abord, nous créons un DisplayMetrics
objet métrique:
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;
Celui-ci renverra la valeur absolue de la largeur et de la hauteur en pixels, donc 1280x720 pour le Galaxy SIII, le Galaxy Nexus etc.
Cela n'est généralement pas utile en soi, car lorsque nous travaillons sur des appareils Android, nous préférons généralement travailler dans des pixels indépendants de la densité, dip.
Vous obtenez density
à metrics
nouveau l' utilisation de l'écran , sous la forme d'un facteur d'échelle pour l'appareil, basé sur les ressources de conception Android 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 que vous en tirez vous aidera à décider du type d'écran sur lequel vous travaillez en conjonction avec les exemples de configuration Android , qui vous donnent 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 la Streak (480x800 mdpi).
- 600 ppp: une tablette de 7 pouces (600 x 1 024 mdpi).
- 720dp: une tablette 10 pouces (720x1280 mdpi, 800x1280 mdpi, etc.).
En utilisant les informations ci-dessus, nous savons que si la plus petite largeur de l'appareil est supérieure à 600dp, l'appareil est une tablette de 7 ", si elle est supérieure à 720dp, l'appareil est une tablette de 10".
Nous pouvons calculer la plus petite largeur en utilisant la min
fonction de Math
classe, 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 déformer leur densité en hdpi alors que ce n'est pas le cas, ou qui pourraient ne faire que 800 x 480 pixels tout en restant sur un écran de 7 pouces .
En plus de ces méthodes, si vous avez besoin de connaître les dimensions exactes d'un appareil en pouces, vous pouvez également le calculer en utilisant la metrics
méthode du 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 dans chaque pouce de l'appareil et de la quantité de pixels au total pour calculer 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, ce n'est pas toujours très utile pour déterminer de quel type d'appareil il s'agit, car la taille annoncée d'un appareil est la diagonale, tout ce que nous avons est la hauteur et la largeur.
Cependant, on sait aussi que compte tenu de la hauteur d'un triangle et de la largeur, on peut utiliser le théorème de Pythagore pour calculer 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 l'appareil 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.
if (smallestWidth > 600) { /* 7" */ } else if (smallestWidth > 720) { /* 10" */ }
est imparfaite: la tablette 10 "est reconnue comme 7". J'ai pris la liberté de résoudre ce problème.
resources.getConfiguration().smallestScreenWidthDp
de DeeV qui est la seule méthode qui donne la même valeur en portrait et en paysage sur mon Nexus 7 (600dp). Il a été ajouté au niveau d'API 13.
Il n'y a rien qui dit 7"
ou 10"
AFAIK. Il existe à peu près deux façons d'obtenir les dimensions de l'écran que le système utilise lors du décodage des bitmaps, etc. Ils se trouvent tous les deux dans l' Resources
objet de l'application dans le fichier Context
.
Le premier est l' Configuration
objet qui peut être obtenu par getContext().getResources().getConfiguration()
. Vous y trouverez:
Configuration#densityDpi
- La densité de l'écran cible en cours de rendu, correspondant au qualificatif de ressource de densité.
Configuration#screenHeightDp
- La hauteur actuelle de l'espace d'écran disponible, en unités dp, correspondant au qualificatif de ressource de hauteur d'écran.
Configuration#screenWidthDp
- La largeur actuelle de l'espace d'écran disponible, en unités dp, correspondant au qualificatif de ressource de largeur d'écran.
Configuration#smallestScreenWidthDp
- La plus petite taille d'écran qu'une application verra en fonctionnement normal, correspondant au plus petit qualificatif de ressources de largeur d'écran.
Avec cela, vous pouvez très bien utiliser les directives à l'écran pour savoir si votre appareil tire à partir des dossiers de ressources spécialisées respectives ( hdpi
, xhdpi
, large
, xlarge
, etc.).
N'oubliez pas que voici quelques-uns des seaux:
les petits écrans mesurent au moins 426dp x 320dp
320dp: un écran de téléphone typique (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc.).
Le second est l' DisplayMetrics
objet obtenu par getContext().getResources().getDisplayMetrics()
. En cela, 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.
Ceci est pratique si vous avez besoin d'un nombre exact de pixels de l'écran plutôt que d'une densité. Cependant, il est important de noter que ce sont tous les pixels de l'écran. Pas seulement ceux dont vous disposez.
smallestScreenWidthDp
. Contrairement aux autres solutions, il donne la même valeur sur mon Nexus 7 (600dp) quelle que soit l'orientation . En prime, c'est aussi le code le plus simple!
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 une taille de 6 pouces.
Ce qui précède ne fonctionne pas toujours lors du passage du portrait au paysage.
Si vous ciblez le niveau d'API 13+, c'est facile comme décrit ci-dessus - utilisez Configuration.smallestScreenWidthDp, puis testez 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 600dp (comme 6 ") contre 720dp (comme 10") en laissant le système vous dire:
1) Ajoutez à layout-sw600dp et layout-sw720dp (et si applicable son paysage) une vue invisible avec l'ID approprié, 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, l'activité, 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 lors de l'utilisation des métriques mentionnées ici, le Nexus 7 (modèle 2012) rapportait des dimensions de 1280x736. J'ai aussi un Motorola Xoom exécutant Jelly Bean et il signale à tort une résolution de 1280x752. Je suis tombé sur ce post ici qui le confirme. Fondamentalement, dans ICS / JB, les calculs utilisant les mesures mentionnées ci-dessus semblent exclure les dimensions de la barre de navigation. D'autres recherches m'ont conduit à la réponse de Frank Nguyen ici qui utilise différentes méthodes qui vous donneront les dimensions brutes (ou réelles) des pixels de l'écran. Mes premiers tests ont montré que le code suivant de Frank correclty indique les dimensions du Nexus 7 (modèle 2012 runnin JB) 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 appareils Android avec la même résolution
Device1 -> résolution 480x800 diagonale de l'écran -> 4,7 pouces
Device2 -> résolution 480x800 diagonale de l'écran -> 4,0 pouces
Il donne à la fois la taille de l'écran diagonale de l'appareil -> 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 les détails ici ..
La façon dont Android spécifie les tailles d'écran passe par quatre tailles généralisées: petite , normale , grande et xlarge .
Alors que la documentation Android indique que les groupes de tailles sont obsolètes
... ces groupes de tailles sont déconseillés au profit d'une nouvelle technique de gestion des tailles d'écran en fonction de la largeur d'écran disponible. Si vous développez pour Android 3.2 et versions ultérieures, consultez [Déclaration des dispositions de tablette pour Android 3.2] (hdpi (élevé) ~ 240 dpi) pour plus d'informations.
En général, le qualificatif de taille large spécifie une tablette de 7 pouces. Et un qualificateur de taille xlarge indique une tablette de 10 pouces:
La bonne chose à propos du déclenchement sur le qualificatif de taille, c'est que vous pouvez garantir que vos actifs et votre code sont en accord sur l'actif à utiliser ou le chemin du code à activer.
Pour récupérer le qualificatif 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);
Vous pouvez utiliser la méthode ci-dessous pour obtenir la taille de l'écran en pouces, en fonction de cela, vous pouvez simplement vérifier la tablette ou le téléphone de 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;
}
Je stockais une valeur dans le dossier des valeurs qui me donne un écran 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-2 pour différents périphériques-2. Mais cela dépend de l'exigence.
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 d'écran en pixels)
Vous avez besoin de la diagonale car la «taille de l'écran en pouces» décrit toujours la longueur de la diagonale. Vous pouvez obtenir la diagonale de l'écran en pixels (en utilisant pythagore)
diagonalPixel = √ (hauteurPixel² + largeurPixels²)
alors vous pouvez convertir la valeur du pixel en pouces grâce à la valeur densitéDPI:
inchDiag = diagonalPixel / densitéDPI.
J'espère ne pas avoir fait d'erreur ici, sachez que les valeurs que vous obtenez de la classe DisplayMetrics sont données par le constructeur, il semble (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 physique de l'écran, mais ce n'est probablement pas la meilleure façon de gérer plusieurs mises en page. En savoir plus sur ces sujets
Autrement:
Créez 2 autres dossiers: values-large + values-xlarge
Mettre: <string name="screentype">LARGE</string>
dans le dossier values-large (strings.xml)
Mettre: <string name="screentype">XLARGE</string>
dans le dossier values-xlarge (strings.xml)
Dans du code:
Chaîne 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
}
1. Fonction d'aide 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;
}
Voici quelques extensions kotlin utiles:
fun DisplayMetrics.isTablet(): Boolean {
return screenWith() >= 600
}
fun DisplayMetrics.is7InchTablet(): Boolean {
return screenWith() >= 600 && screenWith() < 720
}
fun DisplayMetrics.is10InchTablet(): Boolean {
return screenWith() >= 720
}
fun DisplayMetrics.screenWith(): Float {
return widthPixels.coerceAtMost(heightPixels) / density
}
Resources
de Context
: resources.displayMetrics.isTablet()
ou à partir de WindowManager
laquelle stocké dans Activity
: val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
displayMetrics.isTablet()