webentwicklung-frage-antwort-db.com.de

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

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

90
Rookie

Mit dem DisplayMetrics können Sie eine ganze Reihe von Informationen über den Bildschirm abrufen, auf dem Ihre App ausgeführt wird.

Zuerst erstellen wir ein DisplayMetrics Metrikobjekt:

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

Daraus können wir die Informationen abrufen, die für die Größe der Anzeige erforderlich sind:

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

Dies gibt den absoluten Wert der Breite und der Höhe in Pixel zurück, also 1280 x 720 für das Galaxy SIII, das Galaxy Nexus usw.

Dies ist normalerweise für sich genommen nicht hilfreich, da wir bei der Arbeit an Geräten mit Android) normalerweise dichteunabhängige Pixel bevorzugen (dip).

Sie erhalten das density des Bildschirms erneut mit metrics in Form eines Skalierungsfaktors für das Gerät, der auf dem Android Design Resources für basiert mdpi, hdpi etc. DPI scales

float scaleFactor = metrics.density;

Aus diesem Ergebnis können wir die Anzahl 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 erhalten, hilft Ihnen bei der Entscheidung, mit welcher Art von Bildschirm Sie in Verbindung mit Android-Konfigurationsbeispiele arbeiten, und gibt Ihnen den relativen dp für jede Bildschirmgröße an:

  • 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.).

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

Wir können die kleinste Breite mit der min -Funktion der Math -Klasse berechnen, indem wir die heightDp und die widthDp übergeben, um die smallestWidth.

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 wenn Sie mit undurchsichtigen Tablets arbeiten, bei denen die Dichte möglicherweise falsch als hdpi angegeben wird oder die nur 800 x 480 Pixel betragen und sich dennoch auf einem 7-Zoll-Bildschirm befinden .

Wenn Sie zusätzlich zu diesen Methoden die genauen Abmessungen eines Geräts in Zoll kennen müssen, können Sie dies auch mit der metrics -Methode für die Anzahl der Pixel pro Zoll des Bildschirms berechnen.

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

Sie können das Wissen über die Anzahl der Pixel in jedem Zoll des Geräts und die Gesamtanzahl der Pixel verwenden, um die Anzahl der Zoll des Geräts zu ermitteln.

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

Dies gibt die Höhe und Breite des Geräts in Zoll zurück. Dies ist wiederum nicht immer hilfreich, um festzustellen, um welchen Gerätetyp es sich handelt, da die angezeigte Größe eines Geräts die Diagonale ist. Wir haben nur die Höhe und die Breite.

Wir wissen jedoch auch, dass wir angesichts 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 Bildschirmdiagonale).

//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 ableiten, 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 welcher Art von Gerät Sie arbeiten.

230
Sean O'Toole

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.

32
DeeV

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.

13
PiyushMishra

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

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

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 ..

3
Xar E Ahmer

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

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:

enter image description here

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

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.

2
sharma_kunal

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

    }

1
Frank Nguyen

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

1
Guian

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