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?
Réponses
Trop de publicités?
Vous pouvez utiliser l' DisplayMetrics pour obtenir tout un tas d'informations sur l'écran de votre application est en cours d'exécution sur.
Tout d'abord, nous créons un DisplayMetrics des métriques de l'objet:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
À partir de cela, nous pouvons obtenir l'information requise pour la taille de l'écran:
int widthPixels = metrics.widthPixels;
int heightPixels = metrics.heightPixels;
Ce sera le retour de la valeur absolue de la largeur et la hauteur en pixels, de sorte 1280x720 pour le Galaxy SIII, Galaxy Nexus, etc.
Ce n'est pas utile sur son propre, comme lorsque nous travaillons sur les appareils Android, en général, nous préférons travailler dans la densité de pixels indépendants, dip.
Vous obtenez l' density de l'écran à l'aide d' metrics , sous la forme d'un facteur d'échelle pour l'appareil, qui est basé sur l' Android de Conception de Ressources pour l' mdpi, hdpi etc.
float scaleFactor = metrics.density;
À partir de ce résultat, nous pouvons calculer le montant de la densité de pixels indépendants il y a une certaine hauteur ou de largeur.
float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor
Le résultat que vous obtenez à partir de ce vous aidera à décider sur quel type d'écran sur lequel vous travaillez en collaboration avec l' Android exemples de Configuration, qui vous donnent la relative dp pour chaque taille de l'écran:
- 320dp: typique de l'écran du téléphone (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).
- 480dp: un tweener tablette comme la Streak (480x800 mdpi).
- 600dp: une tablette 7" (600x1024 mdpi).
- 720dp: une tablette 10" (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, le dispositif est une tablette 7", si il est plus grand que 720dp, l'appareil est d'une tablette 10".
Nous pouvons travailler sur la plus petite largeur à l'aide de l' min fonction Math classe, de passage dans l' heightDp et de la widthDp de retour à l' 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, ce n'est pas toujours vous donner une correspondance exacte, surtout lorsque l'on travaille avec d'obscurs comprimés qui pourraient être déformée de leur densité hdpi quand il n'est pas, ou qui pourrait n'être que de 800 x 480 pixels, mais tout de même sur un écran 7".
En plus de ces méthodes, si jamais vous avez besoin de connaître les dimensions exactes d'un appareil en pouces, vous pouvez travailler aussi, à l'aide de l' metrics méthode pour déterminer le nombre de pixels par pouce de l'écran.
float widthDpi = metrics.xdpi;
float heightDpi = metrics.ydpi;
Vous pouvez utiliser les connaissances de déterminer le nombre de pixels dans chaque pouce de l'appareil et la quantité de pixels au total, à combien de pouces de l'appareil.
float widthInches = widthPixels / widthDpi;
float heightInches = heightPixels / heightDpi;
Ce sera le retour de la hauteur et la largeur de l'appareil (en pouces). Ce nouveau n'est pas toujours utile pour déterminer quel type de dispositif, il est, comme annoncé, de la taille d'un appareil est la diagonale, tout ce que nous avons est la hauteur et la largeur.
Cependant, nous savons aussi que, compte tenu de la hauteur d'un triangle et la largeur, on peut 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 cela, nous pouvons travailler si l'appareil est d'un comprimé ou pas:
if (diagonalInches >= 10) {
//Device is a 10" tablet
}
else if (diagonalInches >= 7) {
//Device is a 7" tablet
}
Et c'est comment calculer ce genre d'appareil que vous utilisez.
DeeV
Points
16141
Il n'y a rien qui dit 7" ou 10" autant que je sache. Il y a environ deux façons d'obtenir les dimensions de l'écran qui utilise le système lors du décodage d'images et autres joyeusetés. Ils sont à la fois dans l'application, Resources objet trouvé dans l' Context.
La première est l' Configuration objet qui peut être obtenu en getContext().getResources().getConfiguration(). Dans ce que vous avez:
Configuration#densityDpi - De l'objectif de densité de l'écran en cours de rendu, correspondant à la densité de ressources de qualification.
Configuration#screenHeightDp - De la hauteur de l'espace disponible à l'écran en dp unités, correspondant à la hauteur de l'écran de ressources de qualification.
Configuration#screenWidthDp - Largeur de l'espace disponible à l'écran en dp unités, correspondant à la largeur de l'écran de ressources de qualification.
Configuration#smallestScreenWidthDp - La plus petite taille de l'écran d'une application permettra de voir en fonctionnement normal, correspondant à la plus petite largeur de l'écran de ressources de qualification.
Avec cela, vous pouvez très bien utiliser l'écran des lignes directrices pour déterminer si votre appareil est en tirant à partir de la ressource spécialisée dossiers (hdpi, xhdpi, large, xlarge, etc.).
Rappelez-vous, ce sont quelques-uns des seaux:
- xlarge écrans sont au moins 960dp x 720dp
- les grands écrans sont au moins 640dp x 480dp
- écrans normaux sont au moins 470dp x 320dp
les petits écrans sont au moins 426dp x 320dp
320dp: typique de l'écran du téléphone (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, etc).
- 480dp: un tweener tablette comme la Streak (480x800 mdpi).
- 600dp: une tablette 7" (600x1024 mdpi).
- 720dp: une tablette 10" (720x1280 mdpi, 800x1280 mdpi, etc).
La deuxième est l' DisplayMetrics objet obtenu par getContext().getResources().getDisplayMetrics(). En ce que vous avez:
DisplayMetrics#density - La logique de la densité de l'écran.
DisplayMetrics#densityDpi - La densité de l'écran exprimée en points par pouce.
DisplayMetrics#heightPixels - La hauteur absolue de l'écran en pixels.
DisplayMetrics#widthPixels - La grande largeur de l'écran en pixels.
DisplayMetrics#xdpi - La physique exact de pixels par pouce de l'écran dans la dimension X.
DisplayMetrics#ydpi - La physique exact de pixels par pouce de l'écran dans l'axe de la dimension.
C'est pratique si vous avez besoin exact du nombre de pixels de l'écran plutôt que de la densité. Cependant, il est important de noter que c'est tout l'écran de pixels. Pas seulement celles qui sont disponibles pour vous.
PiyushMishra
Points
2258
CEO
Points
101
Le ci-dessus ne fonctionne pas toujours lors de la commutation portrait vs paysage.
Si vous ciblez les API de niveau 13+, il est facile, comme décrit ci-dessus, l'utilisation de Configuration.smallestScreenWidthDp, puis de tester en conséquence:
resources.getConfiguration().smallestScreenWidthDp
Sinon, si vous pouvez vous permettre cela, utilisez la méthode suivante qui est une très grande précision d'approche pour détecter les 600dp (6") vs 720dp (10") en laissant le système vous dire:
1) Ajouter à disposition-sw600dp et la mise en page-sw720dp (et le cas échéant son paysage) invisible vue avec un nom approprié, par exemple:
Pour 720, sur la mise en page-sw720dp:
<View android:id="@+id/sw720" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>
De 600, sur la mise en page-sw600dp:
<View android:id="@+id/sw600" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>
2) Puis sur le code, par exemple, l'Activité, le test 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();
}
Jason
Points
566
La grande information, juste ce que je cherchais! Cependant, après avoir essayé ce que j'ai trouvé que lors de l'utilisation, les paramètres mentionnés ici la Nexus 7 (modèle 2012) rapports ayant des dimensions 1280x736. J'ai aussi une Xoom Motorola sous Jelly Bean et il signale de manière incorrecte une résolution de 1280x752. Je suis tombé sur ce post ici qui confirme ce. Pour l'essentiel, dans ICS/JB les calculs en utilisant les paramètres mentionnés ci-dessus semblent exclure les dimensions de la Barre de Navigation. Un peu plus de recherche m'a conduit à Frank Nguyen réponse ici qui utilise différentes méthodes qui vous donnera les premières (ou réel) dimensions en pixels de l'écran. Mon premier test a montré que le code suivant à partir de Frank correctement des rapports sur les dimensions sur la Nexus 7 (2012 modèle runnin JB) et mon Motorola Xoom l'exécution de 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();
}
