Erkennen Sie 7-Zoll- und 10-Zoll-Tablets programmgesteuert

Gibt es eine Möglichkeit, programmgesteuert zu finden, ob das Gerät, auf dem die App installiert ist, ein 7-Zoll-Tablet oder ein 10-Zoll-Tablet ist?

Sie können DisplayMetrics , um eine ganze Reihe von Informationen über den Bildschirm zu erhalten, auf dem Ihre App läuft.

Zuerst erstellen wir ein DisplayMetrics :

 DisplayMetrics metrics = new DisplayMetrics(); getWindowManager().getDefaultDisplay().getMetrics(metrics); 

Daraus können wir die Informationen erhalten, die zur Größenanpassung des Displays benötigt werden:

 int widthPixels = metrics.widthPixels; int heightPixels = metrics.heightPixels; 

Dies ergibt den absoluten Wert der Breite und der Höhe in Pixeln, also 1280×720 für das Galaxy SIII, das Galaxy Nexus etc.

Dies ist in der Regel nicht hilfreich, da wir bei der Arbeit mit Android-Geräten normalerweise dichteunabhängige Pixel verwenden.

Sie erhalten die density des Bildschirms wieder mit metrics in Form eines Skalierungsfaktors für das Gerät, der auf den Android Design Resources für mdpi , hdpi usw. hdpi . DPI-Skalen

 float scaleFactor = metrics.density; 

Aus diesem Ergebnis können wir die Menge der dichteunabhängigen Pixel für eine bestimmte Höhe oder Breite berechnen.

 float widthDp = widthPixels / scaleFactor float heightDp = heightPixels / scaleFactor 

Das Ergebnis, das Sie daraus erhalten, hilft Ihnen bei der Entscheidung, mit welchem ​​Bildschirmtyp Sie arbeiten, in Verbindung mit den Android-Konfigurationsbeispielen , die Ihnen den relativen dpi für jede Bildschirmgröße geben:

  • 320dp: ein typischer Telefonbildschirm (240×320 dpi, 320×480 dpi, 480×800 hdpi, usw.).
  • 480dp: eine Tweener-Tablette wie die Streak (480×800 mdpi).
  • 600 dp: ein 7 “-Tablet (600 × 1024 mdpi).
  • 720dp: ein 10 “-Tablet (720×1280 mdpi, 800×1280 mdpi, usw.).

Unter Verwendung der obigen Informationen wissen wir, dass, wenn die kleinste Breite des Geräts größer als 600 dpi ist, das Gerät ein 7-Zoll-Tablet ist, wenn es größer als 720 dpi ist, ist das Gerät ein 10-Zoll-Tablet.

Wir können die kleinste Breite mit der min function der Math class heightDp , indem heightDp die heightDp und die widthDp , um die smallestWidth widthDp zurückzugeben.

 float smallestWidth = Math.min(widthDp, heightDp); if (smallestWidth > 720) { //Device is a 10" tablet } else if (smallestWidth > 600) { //Device is a 7" tablet } 

Dies führt jedoch nicht immer zu einer genauen Übereinstimmung, insbesondere bei der Arbeit mit obskuren Tablets, die ihre Dichte als hdpi darstellen könnten, wenn dies nicht der Fall ist, oder die nur 800 x 480 Pixel groß sind und dennoch auf einem 7-Zoll-Bildschirm sind .

Wenn Sie darüber hinaus die genauen Abmessungen eines Geräts in Zoll kennen müssen, können Sie dies auch mithilfe der metrics Methode für die Anzahl der Pixel pro Zoll des Bildschirms tun.

 float widthDpi = metrics.xdpi; float heightDpi = metrics.ydpi; 

Sie können das Wissen verwenden, wie viele Pixel in jedem Zoll des Geräts und die Anzahl der Pixel insgesamt sind, um herauszufinden, wie viele Zoll das Gerät ist.

 float widthInches = widthPixels / widthDpi; float heightInches = heightPixels / heightDpi; 

Dies gibt die Höhe und Breite des Geräts in Zoll zurück. Dies wiederum ist nicht immer hilfreich, um zu bestimmen, um welche Art von Gerät es sich handelt, da die beworbene Größe eines Geräts die Diagonale ist, wir haben nur die Höhe und die Breite.

Wir wissen jedoch auch, dass wir anhand der Höhe eines Dreiecks und der Breite den Satz des Pythagoras verwenden können, um die Länge der Hypotenuse zu berechnen (in diesem Fall die Größe der Bildschirmdiagonalen).

 //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)); 

Daraus können wir herausfinden, ob das Gerät ein Tablet ist oder nicht:

 if (diagonalInches >= 10) { //Device is a 10" tablet } else if (diagonalInches >= 7) { //Device is a 7" tablet } 

Und so berechnen Sie, mit welchem ​​Gerät Sie arbeiten.

Es gibt nichts, was 7" oder 10" AFAIK sagt. Es gibt grob zwei Möglichkeiten, Bildschirmabmessungen zu erhalten, die das System beim Decodieren von Bitmaps und dergleichen verwendet. Sie befinden sich beide im Resources Objekt der Anwendung im Context .

Das erste ist das Configuration Objekt, das von getContext().getResources().getConfiguration() . Darin hast du:

Configuration#densityDpi – Die Zielbildschirmdichte, auf die gerendert wird, entsprechend dem Qualifikationsmerkmal der Dichte-Ressource.

Configuration#screenHeightDp – Die aktuelle Höhe des verfügbaren Bildschirmbereichs in dp-Einheiten entsprechend dem Ressourcenkennzeichen der Bildschirmhöhe.

Configuration#screenWidthDp – Die aktuelle Breite des verfügbaren Bildschirmbereichs in dp-Einheiten, die dem Ressourcenqualifizierer für die Bildschirmbreite entspricht.

Configuration#smallestScreenWidthDp – Die kleinste Bildschirmgröße, die eine Anwendung im normalen Betrieb sehen kann, entspricht dem kleinsten Ressourcenqualifikator für die Bildschirmbreite.

Damit können Sie ziemlich gut die Bildschirmrichtlinien verwenden, um herauszufinden, ob Ihr Gerät aus den entsprechenden spezialisierten Ressourcenordnern ( hdpi , xhdpi , large , xlarge usw.) xlarge .

Denken Sie daran, dies sind einige der Eimer:

  • xlarge Bildschirme sind mindestens 960dp x 720dp
  • große Bildschirme sind mindestens 640dp x 480dp
  • normale Bildschirme sind mindestens 470dp x 320dp
  • kleine Bildschirme sind mindestens 426dp x 320dp

  • 320dp: ein typischer Telefonbildschirm (240×320 dpi, 320×480 dpi, 480×800 hdpi, usw.).

  • 480dp: eine Tweener-Tablette wie die Streak (480×800 mdpi).
  • 600 dp: ein 7 “-Tablet (600 × 1024 mdpi).
  • 720dp: ein 10 “-Tablet (720×1280 mdpi, 800×1280 mdpi, usw.).

Mehr Info

Das zweite ist das DisplayMetrics Objekt, das von getContext().getResources().getDisplayMetrics() . Darin hast du:

DisplayMetrics#density – Die logische Dichte des Displays.

DisplayMetrics#densityDpi – Die Bildschirmdichte ausgedrückt als Punkte pro Zoll.

DisplayMetrics#heightPixels – Die absolute Höhe der Anzeige in Pixeln.

DisplayMetrics#widthPixels – Die absolute Breite der Anzeige in Pixel.

DisplayMetrics#xdpi – Die genauen physikalischen Pixel pro Zoll des Bildschirms in der X-Dimension.

DisplayMetrics#ydpi – Die genauen physikalischen Pixel pro Zoll des Bildschirms in der Y-Dimension.

Dies ist praktisch, wenn Sie die genaue Anzahl der Pixel auf dem Bildschirm und nicht die Dichte benötigen. Es ist jedoch wichtig zu beachten, dass dies alle Pixel des Bildschirms sind. Nicht nur die, die Ihnen zur Verfügung stehen.

Platziere diese Methode in onResume () und überprüfe.

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

in der Regel beginnt Tabletten nach 6 Zoll Größe.

Großartige Informationen, genau das, was ich gesucht habe! Nach dem Ausprobieren stellte ich jedoch fest, dass das Nexus 7 (Modell 2012) mit den hier genannten Metriken die Abmessungen 1280×736 hat. Ich habe auch ein Motorola Xoom läuft Jelly Bean und es meldet fälschlicherweise eine Auflösung von 1280×752. Ich bin hier auf diesen Beitrag gestoßen, der dies bestätigt. Grundsätzlich scheinen in ICS / JB die Berechnungen, die die oben erwähnten Metriken verwenden, die Dimensionen der Navigationsleiste auszuschließen. Etwas mehr Forschung führte mich zu Frank Nguyens Antwort hier , die verschiedene Methoden verwendet, die Ihnen die rohen (oder realen) Pixelmaße des Bildschirms geben. Meine ersten Tests haben gezeigt, dass der folgende Code von Frank correclty die Dimensionen auf dem Nexus 7 (Modell Runnin JB 2012) und meinem Motorola Xoom Running JB meldet:

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

Das oben beschriebene funktioniert nicht immer beim Wechsel zwischen Hoch- und Querformat.

Wenn Sie auf API-Ebene 13+ abzielen, ist es einfach, wie oben beschrieben – verwenden Sie Configuration.smallestScreenWidthDp und testen Sie dann entsprechend:

 resources.getConfiguration().smallestScreenWidthDp 

Andernfalls, wenn Sie dies sich leisten können, verwenden Sie die folgende Methode, die ein sehr genauer Ansatz ist, um 600dp (wie 6 “) im Vergleich zu 720dp (wie 10”) zu erkennen, indem Sie das System Ihnen sagen lassen:

1) Fügen Sie zu Layout-sw600dp und Layout-sw720dp (und ggf. seiner Landschaft) eine unsichtbare Ansicht mit der richtigen ID hinzu, zum Beispiel:

Für 720, auf Layout-sw720dp:

  

Für 600, auf Layout-sw600dp:

  

2) Dann auf den Code, zum Beispiel die Aktivität, testen Sie entsprechend:

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

Ich habe zwei Android-Gerät mit der gleichen Auflösung

Device1 -> Auflösung 480×800 Bildschirmdiagonale -> 4,7 Zoll

Device2 -> Auflösung 480×800 Bildschirmdiagonale -> 4,0 Zoll

Es gibt beide Gerätediagonale Bildschirmgröße -> 5.8

Die Lösung für Ihr Problem ist ..

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

Details finden Sie hier ..

Die Art und Weise, auf die Android Bildschirmgrößen vorgibt , erfolgt über vier verallgemeinerte Größen: klein , normal , groß und xgroß .

Während die Android- Dokumentation besagt, dass die Größengruppen veraltet sind

… diese Größengruppen sind zugunsten einer neuen Technik zur Verwaltung von Bildschirmgrößen auf der Grundlage der verfügbaren Bildschirmbreite veraltet. Wenn Sie für Android 3.2 und höher entwickeln, finden Sie unter [Deklarieren von Tablet-Layouts für Android 3.2] (hdpi (hoch) ~ 240dpi) weitere Informationen.

Im Allgemeinen gibt das Größenqualifikationsmerkmal large ein 7 “-Tablet an. Und ein Größenqualifikationsmerkmal von xlarge gibt ein 10″ -Tablet an:

Bildbeschreibung hier eingeben

Das Schöne am Auslösen des Größenqualifikators ist, dass Sie garantieren können, dass Ihre Assets und der Code sich darauf befinden, welches Asset verwendet oder welcher Codepfad aktiviert werden soll.

Um das Größen-Qualifikationsmerkmal im Code abzurufen, führen Sie die folgenden Aufrufe aus:

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

Sie können die folgende Methode verwenden, um die Bildschirmgröße in Zoll zu erhalten, basierend darauf können Sie einfach überprüfen, welches Tablet oder Telefon das Gerät ist.

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

Sie müssen ein wenig Berechnung mit Daten durchführen, die von der DisplayMetrics- class bereitgestellt werden .

Sie haben heightPixel und widthPixels (die Bildschirmauflösung in Pixel)

Sie benötigen die Diagonale, da die “Inch-Bildschirmgröße” immer die diagonale Länge beschreibt. Sie können die Bildschirmdiagonale in Pixel (mit Pythagoras) erhalten

diagonalPixel = √ (HöhePixel² + BreitePixel²)

dann können Sie den Pixelwert dank des Dichte-DPI-Werts in Zoll umwandeln:

inchDiag = DiagonalPixel / DichteDPI.

Ich hoffe, ich habe hier keine Fehler gemacht. Seien Sie sich bewusst, dass die Werte, die Sie von der DisplayMetrics-class erhalten, vom Konstruktor angegeben werden. In sehr seltenen Fällen scheint es, dass sie nicht entsprechend dem physischen Material eingestellt sind …

Dies gibt Ihnen die physische Bildschirmgröße, aber es ist wahrscheinlich nicht die bessere Möglichkeit, mehrere Layouts zu verwalten. Mehr zu diesen Themen

Ein anderer Weg:

  • Erstellen Sie 2 weitere Ordner: values-large + values-xlarge

  • Setzen Sie: LARGE in Werte – großer Ordner (strings.xml)

  • Setzen Sie: XLARGE im Ordner “values-xlarge” (strings.xml)

  • In Code:

    String mType = getString (R.string.screentype);

    if (mType! = null && mType.equals (“GROSS”) {

    // von 4 ~ 7 Zoll

    } sonst if (mType! = null && mType.equals (“XLARGE”) {

    // von 7 ~ 10 Zoll

    }

Ich speicherte einen Wert im Wert-Ordner , der mir 7 Zoll oder 10 Zoll Bildschirm gibt, aber wir können es für jedes Gerät, das Wertordner verwendet, tun.

wie create different-2 values ​​Ordner für verschiedene 2 Geräte. Aber diese Sache hängt von der Anforderung ab.