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

Es gibt nichts, was 7" Oder 10" AFAIK sagt. Es gibt ungefähr zwei Möglichkeiten, um Bildschirmabmessungen zu erhalten, die das System beim Dekodieren von Bitmaps und so weiter verwendet. Sie befinden sich beide im Resources -Objekt der Anwendung, das sich im Context befindet.

Das erste ist das Objekt Configuration , das mit getContext().getResources().getConfiguration() abgerufen werden kann. Darin haben Sie:

Configuration#densityDpi - Die Zielbildschirmdichte, die entsprechend dem Dichteressourcenqualifikator gerendert wird.

Configuration#screenHeightDp - Die aktuelle Höhe des verfügbaren Bildschirmbereichs in dp-Einheiten, die dem Ressourcenqualifikator für die Bildschirmhöhe entspricht.

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 Normalbetrieb sieht, entsprechend dem Ressourcenqualifikator für die kleinste Bildschirmbreite.

Auf diese Weise können Sie im Wesentlichen anhand der Bildschirmrichtlinien herausfinden, ob Ihr Gerät aus den entsprechenden speziellen Ressourcenordnern (hdpi, xhdpi, large, xlarge usw.).

Denken Sie daran, dies sind einige der Eimer:

• xGroße Bildschirme haben eine Auflösung von mindestens 960 dpi x 720 dpi
• große Bildschirme haben eine Auflösung von mindestens 640 x 480 dpi
• normale Bildschirme sind mindestens 470dp x 320dp

• kleine Bildschirme haben eine Auflösung von mindestens 426 dpi x 320 dpi

• 320dp: Ein typischer Telefonbildschirm (240 x 320 ldpi, 320 x 480 mdpi, 480 x 800 hdpi usw.).

• 480dp: ein Tweener-Tablet wie das Streak (480x800 mdpi).
• 600 dpi: ein 7-Zoll-Tablet (600 x 1024 mdpi).
• 720dp: ein 10-Zoll-Tablet (720 x 1280 mdpi, 800 x 1280 mdpi usw.).

Mehr Infos

Das zweite ist das Objekt DisplayMetrics , das von getContext().getResources().getDisplayMetrics() erhalten wird. Darin haben Sie:

DisplayMetrics#density - Die logische Dichte der Anzeige.

DisplayMetrics#densityDpi - Die Bildschirmdichte in Punkten pro Zoll.

DisplayMetrics#heightPixels - Die absolute Höhe der Anzeige in Pixel.

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

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

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

Dies ist praktisch, wenn Sie eine genaue Pixelanzahl des Bildschirms anstelle der 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.

platzieren Sie diese Methode in onResume () und können überprüfen.

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.

Das Obige funktioniert nicht immer beim Umschalten zwischen Hoch- und Querformat.

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

resources.getConfiguration().smallestScreenWidthDp

Wenn Sie sich dies leisten können, verwenden Sie andernfalls die folgende Methode, die eine sehr genaue Methode zum Erkennen von 600dp (wie 6 ") im Vergleich zu 720dp (wie 10") darstellt, indem Sie sich vom System mitteilen 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:

<View Android:id="@+id/sw720" Android:layout_width="0dp" Android:layout_height="0dp" Android:visibility="gone"/>

Für 600 auf layout-sw600dp:

<View Android:id="@+id/sw600" Android:layout_width="0dp" Android:layout_height="0dp" Android:visibility="gone"/>

2) Testen Sie dann auf dem Code, zum Beispiel der Aktivität, 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();
}

Tolle Informationen, genau das, wonach ich gesucht habe! Nachdem ich dies ausprobiert hatte, stellte ich jedoch fest, dass das Nexus 7 (Modell 2012) bei Verwendung der hier genannten Messdaten Abmessungen von 1280 x 736 aufweist. Ich habe auch ein Motorola Xoom mit Jelly Bean und es meldet fälschlicherweise eine Auflösung von 1280x752. Ich bin auf diesen Beitrag gestoßen hier das bestätigt dies. Grundsätzlich scheinen in ICS/JB die Berechnungen unter Verwendung der oben genannten Metriken die Abmessungen der Navigationsleiste auszuschließen. Weitere Nachforschungen führten mich zu Frank Nguyens Antwort hier , das verschiedene Methoden verwendet, um die rohen (oder realen) Pixeldimensionen des Bildschirms zu ermitteln. Meine ersten Tests haben gezeigt, dass der folgende Code von Frank die Abmessungen auf dem Nexus 7 (2012 Model Runnin JB) und meinem Motorola Xoom mit JB korrekt angibt:

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

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

Gerät1 -> Auflösung 480x800 Bildschirmdiagonale -> 4,7 Zoll

Gerät2 -> Auflösung 480x800 Bildschirmdiagonale -> 4,0 Zoll

Es gibt beiden Geräten eine Bildschirmdiagonale -> 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);

siehe Details hier ..

Mit der folgenden Methode können Sie die Bildschirmgröße in Zoll ermitteln. Auf dieser Grundlage können Sie einfach überprüfen, um welches Tablet oder Telefon es sich handelt.

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 Art und Weise, dass Android spezifiziert Bildschirmgrößen ist durch vier verallgemeinerte Größen: klein , normal , groß und groß .

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

... werden diese Größengruppen zugunsten einer neuen Technik zum Verwalten der Bildschirmgrößen basierend auf der verfügbaren Bildschirmbreite abgelehnt. Wenn Sie für Android 3.2 und höher entwickeln, finden Sie weitere Informationen unter [Tablettlayouts für Android 3.2)] (hdpi (hoch) ~ 240dpi).

Im Allgemeinen gibt das Größenkennzeichen groß ein 7-Zoll-Tablet an. Das Größenkennzeichen x groß spezifiziert ein 10 "Tablet:

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

Führen Sie die folgenden Aufrufe aus, um das Größenqualifikationsmerkmal im Code abzurufen:

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

Ich habe einen Wert in values ​​folder gespeichert, was bedeutet, dass der Bildschirm 7 Zoll oder 10 Zoll groß ist. Wir können dies jedoch für jedes Gerät tun, das values ​​folder verwendet.

erstellen Sie beispielsweise einen Ordner mit zwei unterschiedlichen Werten für zwei unterschiedliche Geräte. Aber diese Sache hängt von der Anforderung ab.

Ein anderer Weg:

• Erstelle 2 weitere Ordner: values-large + values-xlarge

• Stellen: <string name="screentype">LARGE</string> im Ordner "values-large" (strings.xml)

• Stellen: <string name="screentype">XLARGE</string> im Ordner values-xlarge (strings.xml)

• In Code:

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

  if (mType! = null && mType.equals ("LARGE") {

  // von 4 ~ 7 Zoll

  } else if (mType! = null && mType.equals ("XLARGE") {

  // von 7 ~ 10 Zoll

  }

Sie müssen ein wenig rechnen, indem Sie die Daten der DisplayMetrics -Klasse verwenden.

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

Sie benötigen die Diagonale, da die 'Zoll Bildschirmgröße' immer die Diagonallänge beschreibt. Sie können die Bildschirmdiagonale in Pixel erhalten (mit Pythagore)

diagonalPixel = √ (heightPixel² + widthPixel²)

dann können Sie den Pixelwert dank des DensityDPI-Werts in Zoll umrechnen:

inchDiag = diagonalPixel/densityDPI.

Ich hoffe, ich habe hier keine Fehler gemacht. Beachten Sie, dass die Werte, die Sie von der DisplayMetrics-Klasse erhalten, vom Konstruktor angegeben werden. Es scheint (in sehr seltenen Fällen), dass sie nicht gut auf das physikalische Material abgestimmt sind.

Dies gibt Ihnen die physische Bildschirmgröße, ist jedoch wahrscheinlich nicht die bessere Möglichkeit, mehrere Layouts zu verwalten. Mehr zu diesem Thema

Voila! ???? Dies ist alles, was Sie benötigen, um Tablets von Handys zu unterscheiden

1. Hilfsfunktion, um die Bildschirmbreite zu erhalten:

private float getScreenWidth() {
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}

2. Funktion, um herauszufinden, ob ein Gerät ein Tablet ist

boolean isTablet() {
    return getScreenWidth() >= 600;
}

3. Wenn Sie verschiedene Vorgänge für verschiedene Gerätegrößen ausführen möchten, gehen Sie wie folgt vor:

boolean is7InchTablet() {
    return getScreenWidth() >= 600 && getScreenWidth() < 720;
}

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}