Gibt es eine Möglichkeit zu überprüfen, ob der Benutzer ein Tablet oder ein Telefon verwendet? Ich habe Probleme mit meiner Neigungsfunktion und meinem neuen Tablet (Transformer).

Wie bereits erwähnt, möchten Sie nicht überprüfen, ob es sich bei dem Gerät um ein Tablet oder ein Telefon handelt, sondern möchten die Funktionen des Geräts kennen.

In den meisten Fällen liegt der Unterschied zwischen einem Tablet und einem Telefon in der Bildschirmgröße, weshalb Sie unterschiedliche Layoutdateien verwenden möchten. Diese Dateien werden in den res/layout-<qualifiers>Verzeichnissen gespeichert . Sie können res/values-<same qualifiers>für jedes Ihrer Layouts eine XML-Datei im Directoy erstellen und eine int / bool / string-Ressource einfügen , um zwischen den von Ihnen verwendeten Layouts zu unterscheiden.

Beispiel:

Datei res/values/screen.xml(vorausgesetzt, res/layout/enthält Ihre Layoutdateien für Mobilteile)

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">phone</string>
</resources>

Datei res/values-sw600dp/screen.xml(vorausgesetzt, sie res/layout-sw600dp/enthält Ihre Layoutdateien für kleine Tablets wie das Nexus 7)

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">7-inch-tablet</string>
</resources>

Datei res/values-sw720dp/screen.xml(vorausgesetzt, sie res/layout-sw720dp/enthält Ihre Layoutdateien für große Tablets wie das Nexus 10):

<?xml version="1.0" encoding="utf-8"?>
<resources>
  <string name="screen_type">10-inch-tablet</string>
</resources>

Jetzt ist der Bildschirmtyp über die R.string.screen_typeKonstante zugänglich .

Verwenden Sie den folgenden Code, um festzustellen, ob es sich bei dem Gerät um ein Tablet handelt oder nicht:

public boolean isTablet(Context context) {
    boolean xlarge = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE);
    boolean large = ((context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE);
    return (xlarge || large);
}

GROSSE und XLARGE Bildschirmgrößen werden vom Hersteller anhand des Abstands vom Auge festgelegt, in dem sie verwendet werden sollen (daher die Idee eines Tablets).

Weitere Informationen: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Dieser Beitrag hat mir sehr geholfen,

Leider habe ich nicht den Ruf, alle Antworten zu bewerten, die mir geholfen haben.

Ich musste feststellen, ob mein Gerät ein Tablet oder ein Telefon war, damit ich die Logik des Bildschirms implementieren konnte. Und in meiner Analyse muss das Tablet ab MDPI mehr als 7 Zoll (Xlarge) betragen.

Hier ist der folgende Code, der basierend auf diesem Beitrag erstellt wurde.

/**
 * Checks if the device is a tablet or a phone
 * 
 * @param activityContext
 *            The Activity Context.
 * @return Returns true if the device is a Tablet
 */
public static boolean isTabletDevice(Context activityContext) {
    // Verifies if the Generalized Size of the device is XLARGE to be
    // considered a Tablet
    boolean xlarge = ((activityContext.getResources().getConfiguration().screenLayout & 
                        Configuration.SCREENLAYOUT_SIZE_MASK) == 
                        Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI
    // (160dpi)
    if (xlarge) {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity) activityContext;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160,
        // DENSITY_TV=213, DENSITY_XHIGH=320
        if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT
                || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH
                || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM
                || metrics.densityDpi == DisplayMetrics.DENSITY_TV
                || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) {

            // Yes, this is a tablet!
            return true;
        }
    }

    // No, this is not a tablet!
    return false;
}

Warum nicht die Größe der Bildschirmdiagonale berechnen und anhand dieser Entscheidung entscheiden, ob es sich bei dem Gerät um ein Telefon oder ein Tablet handelt?

private boolean isTablet()
{
    Display display = getWindowManager().getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    int width = displayMetrics.widthPixels / displayMetrics.densityDpi;
    int height = displayMetrics.heightPixels / displayMetrics.densityDpi;

    double screenDiagonal = Math.sqrt( width * width + height * height );
    return (screenDiagonal >= 9.0 );
}

Natürlich kann man argumentieren, ob der Schwellenwert 9 Zoll oder weniger betragen sollte.

es gibt keinen Unterschied. Sie sollten definieren, was Ihrer Meinung nach der Unterschied ist, und dies überprüfen. Ist ein Galaxie-Tab ein Telefon? oder eine Tablette? und warum?

Sie sollten definieren, nach welchen spezifischen Funktionen Sie suchen, und dafür Code erstellen.

Es scheint, dass Sie nach "Neigung" suchen. Ich denke, das ist das gleiche wie beim Beschleunigungsmesser (ist das ein Wort?). Sie können einfach überprüfen, ob das Gerät dies unterstützt, indem Sie Folgendes verwenden:

public class Accel extends Activity implements SensorListener {
...
  SensorManager sensorMgr = (SensorManager) getSystemService(SENSOR_SERVICE);
  boolean accelSupported = sensorMgr.registerListener(this,
        SENSOR_ACCELEROMETER,
        SENSOR_DELAY_UI);
...
}

(von http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . Ich habe es nicht getestet)

Ich gehe davon aus, dass Sie bei der Definition von "Handy / Telefon" wissen möchten, ob Sie auf dem Gerät einen Anruf tätigen können, der auf einem als "Tablet" definierten Gerät nicht möglich ist. Der Weg, dies zu überprüfen, ist unten. Wenn Sie etwas wissen möchten, das auf Sensoren, Bildschirmgröße usw. basiert, ist dies wirklich eine andere Frage.

Während die Bildschirmauflösung oder die Ressourcenverwaltung groß oder groß verwendet wurde, war dies in der Vergangenheit möglicherweise ein gültiger Ansatz. Neue mobile Geräte verfügen jetzt über so große Bildschirme und hohe Auflösungen, dass sie diese Linie verwischen, wenn Sie dies wirklich wünschen Um zu wissen, ob ein Telefonanruf oder kein Telefonanruf möglich ist, ist das Folgende "am besten".

TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){
    return "Tablet";
}else{
    return "Mobile";
}

Basierend auf Robert Dale Johnson III und Helton Isac habe ich mir diesen Code ausgedacht. Ich hoffe, das ist nützlich

public static boolean isTablet(Context context) {
    TelephonyManager manager = 
        (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
    if (manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE) {
        //Tablet
        return true;
    } else {
        //Mobile
        return false; 
    }
}

public static boolean isTabletDevice(Context activityContext) {
    // Verifies if the Generalized Size of the device is XLARGE to be
    // considered a Tablet
    boolean xlarge = 
         ((activityContext.getResources().getConfiguration().screenLayout & 
           Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE);

    // If XLarge, checks if the Generalized Density is at least MDPI (160dpi)
    if (xlarge) {
        DisplayMetrics metrics = new DisplayMetrics();
        Activity activity = (Activity) activityContext;
        activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);

        // MDPI=160, DEFAULT=160, DENSITY_HIGH=240, DENSITY_MEDIUM=160,
        // DENSITY_TV=213, DENSITY_XHIGH=320
        if (metrics.densityDpi == DisplayMetrics.DENSITY_DEFAULT
                  || metrics.densityDpi == DisplayMetrics.DENSITY_HIGH
                  || metrics.densityDpi == DisplayMetrics.DENSITY_MEDIUM   
                  || metrics.densityDpi == DisplayMetrics.DENSITY_XHIGH) {

             // Yes, this is a tablet!
             return true;
        }
    }

    // No, this is not a tablet!
    return false;
}

Also in deinem Code mache einen Filter wie

if(isTabletDevice(Utilities.this) && isTablet(Utilities.this)){
    //Tablet
} else {
    //Phone
}

Im Quellcode der Google IOSched 2017-App wird die folgende Methode verwendet:

public static boolean isTablet(Context context) {
    return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
}

Wenn Sie sich auf den Code von Google beziehen möchten, um zu entscheiden, welche Geräte eine Tablet-Benutzeroberfläche verwenden, finden Sie unten:

  // SystemUI (status bar) layout policy
        int shortSizeDp = shortSize
                * DisplayMetrics.DENSITY_DEFAULT
                / DisplayMetrics.DENSITY_DEVICE;

        if (shortSizeDp < 600) {
            // 0-599dp: "phone" UI with a separate status & navigation bar
            mHasSystemNavBar = false;
            mNavigationBarCanMove = true;
        } else if (shortSizeDp < 720) {
            // 600-719dp: "phone" UI with modifications for larger screens
            mHasSystemNavBar = false;
            mNavigationBarCanMove = false;
        } else {
            // 720dp: "tablet" UI with a single combined status & navigation bar
            mHasSystemNavBar = true;
            mNavigationBarCanMove = false;
        }
        }

Diese Methode wird von Google empfohlen. Ich sehe diesen Code in der Google Offical Android Appiosched

public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}

Kein Code notwendig

In den anderen Antworten werden viele Möglichkeiten aufgeführt, um programmgesteuert festzustellen, ob es sich bei dem Gerät um ein Telefon oder ein Tablet handelt. Wenn Sie jedoch die Dokumentation lesen , ist dies nicht die empfohlene Methode, um verschiedene Bildschirmgrößen zu unterstützen.

Deklarieren Sie stattdessen unterschiedliche Ressourcen für Tablets oder Telefone. Sie tun dies , meine Hinzufügen zusätzlicher Ressourcenordner für layout, valuesusw.

• Fügen Sie für Android 3.2 (API Level 13) einen sw600dpOrdner hinzu. Dies bedeutet , das s mallest w reite mindestens 600dp, die etwa das Telefon / Tablette divide ist. Sie können jedoch auch andere Größen hinzufügen. In dieser Antwort finden Sie ein Beispiel für das Hinzufügen einer zusätzlichen Layoutressourcendatei.

• Wenn Sie auch vor Android 3.2 - Geräte unterstützt werden, dann müssen Sie hinzufügen largeoder xlargeOrdner Unterstützung Tabletten. (Telefone sind in der Regel smallund normal.)

Hier ist ein Bild davon, was Ihre Ressourcen nach dem Hinzufügen zusätzlicher XML-Dateien für verschiedene Bildschirmgrößen mögen könnten.

Bei Verwendung dieser Methode bestimmt das System alles für Sie. Sie müssen sich keine Gedanken darüber machen, welches Gerät zur Laufzeit verwendet wird. Sie stellen nur die entsprechenden Ressourcen bereit und lassen Android die ganze Arbeit erledigen.

Anmerkungen

• Sie können Aliase verwenden , um das Duplizieren identischer Ressourcendateien zu vermeiden.

Lesenswerte Android-Dokumente

• Unterstützung mehrerer Bildschirme
• Unterstützung verschiedener Bildschirmgrößen
• Verteilen auf bestimmte Bildschirme

Wenn Sie nur auf API-Ebene> = 13 abzielen, versuchen Sie es

public static boolean isTablet(Context context) {
    return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
}

Prost :-)

Beim Nachdenken über die "neuen" akzeptierten Verzeichnisse (z. B. values-sw600dp) habe ich diese Methode basierend auf der Breite des Bildschirms DP erstellt:

 public static final int TABLET_MIN_DP_WEIGHT = 450;
 protected static boolean isSmartphoneOrTablet(Activity act){
    DisplayMetrics metrics = new DisplayMetrics();
    act.getWindowManager().getDefaultDisplay().getMetrics(metrics);

    int dpi = 0;
    if (metrics.widthPixels < metrics.heightPixels){
        dpi = (int) (metrics.widthPixels / metrics.density);
    }
    else{
        dpi = (int) (metrics.heightPixels / metrics.density);
    }

    if (dpi < TABLET_MIN_DP_WEIGHT)         return true;
    else                                    return false;
}

Auf dieser Liste finden Sie einige der DP gängiger Geräte und Tablet-Größen:

Wdp / Hdp

GALAXY Nexus:
360/567 XOOM: 1280/752
400/615
NEXUS 7:
961/528 GALAXY TAB (> 7 && <10):
1280/752 GALAXY S3: 360/615

Wdp = Breite
dp Hdp = Höhe dp

Die beste Lösung, die für mich funktioniert hat, ist ganz einfach:

private boolean isTabletDevice(Resources resources) {   
    int screenLayout = resources.getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK;
    boolean isScreenLarge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_LARGE);
    boolean isScreenXlarge = (screenLayout == Configuration.SCREENLAYOUT_SIZE_XLARGE);
    return (isScreenLarge || isScreenXlarge);
}

So verwendet:

public void onCreate(Bundle savedInstanceState) {
    [...]
    if (this.isTabletDevice(this.getResources()) == true) {
        [...]
    }
}

Ich möchte wirklich nicht auf die Pixelgrößen schauen, sondern mich nur auf die Bildschirmgröße verlassen.

Funktioniert gut, da Nexus 7 (GROSS) als Tablet erkannt wird, nicht jedoch Galaxy S3 (NORMAL).

Verwenden Sie diese Methode, die true zurückgibt , wenn das Gerät ein Tablet ist

public boolean isTablet(Context context) {  
    return (context.getResources().getConfiguration().screenLayout   
        & Configuration.SCREENLAYOUT_SIZE_MASK)    
        >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}

Wenn die Bildschirmgrößenerkennung auf neueren Geräten nicht den korrekten Wert zurückgibt, versuchen Sie Folgendes:

/*
 Returns '1' if device is a tablet
 or '0' if device is not a tablet.
 Returns '-1' if an error occured.
 May require READ_EXTERNAL_STORAGE
 permission.
 */
public static int isTablet()
{
    try
    {
        InputStream ism = Runtime.getRuntime().exec("getprop ro.build.characteristics").getInputStream();
        byte[] bts = new byte[1024];
        ism.read(bts);
        ism.close();

        boolean isTablet = new String(bts).toLowerCase().contains("tablet");
        return isTablet ? 1 : 0;
    }
    catch (Throwable t)
    {t.printStackTrace(); return -1;}
}

Getestet auf Android 4.2.2 (Entschuldigung für mein Englisch.)

Ich weiß, dass dies keine direkte Antwort auf Ihre Frage ist, aber andere Antworten hier geben eine gute Vorstellung davon, wie die Bildschirmgröße ermittelt werden kann. Sie haben in Ihrer Frage geschrieben, dass Sie Probleme mit dem Kippen haben, und das ist mir auch passiert.

Wenn Sie das Gyroskop (oder den Rotationssensor) auf einem Smartphone ausführen, können die x- und y-Achse je nach Standardausrichtung dieses Geräts anders definiert werden als auf einem Tablet (z. B. Samsung GS2 ist das Standardporträt, Samsung GT-7310) Standardlandschaft, neues Google Nexus 7 ist Standardporträt, obwohl es ein Tablet ist!).

Wenn Sie Gyroscope verwenden möchten, erhalten Sie möglicherweise eine funktionierende Lösung für Smartphones, bei einigen Tablets jedoch eine Achsverwirrung oder umgekehrt.

Wenn Sie eine der Lösungen von oben verwenden, wählen Sie nur die Bildschirmgröße und wenden Sie sie an

SensorManager.remapCoordinateSystem(inputRotationMatrix, SensorManager.AXIS_X, 
    SensorManager.AXIS_Y, outputRotationMatrix);

Wenn Sie die Achse umdrehen, wenn sie eine große oder große Bildschirmgröße hat, funktioniert dies möglicherweise in 90% der Fälle. Auf dem Nexus 7 treten jedoch Probleme auf (da die Standardeinstellung im Hochformat und die Bildschirmgröße groß sind).

Die einfachste Möglichkeit, dies zu beheben, finden Sie im RotationVectorSample, das mit den API-Demos geliefert wird, indem Sie nosensorin Ihrem Manifest die Einstellung sceenOrientation festlegen :

<activity
    ...
    android:screenOrientation="nosensor">
...
</activity>

com.sec.feature.multiwindow.tablet im Paketmanager ist nur für Tablets spezifisch und com.sec.feature.multiwindow.phone ist spezifisch für Telefone.

Die folgende Methode berechnet die diagonale Länge des Gerätebildschirms, um zu entscheiden, ob es sich bei dem Gerät um ein Telefon oder Tablet handelt. Das einzige Problem bei dieser Methode ist der Schwellenwert für die Entscheidung, ob das Gerät ein Tablet ist oder nicht. Im folgenden Beispiel habe ich es auf 7 Zoll und höher eingestellt.

public static boolean isTablet(Activity act)
{
    Display display = act.getWindow().getWindowManager().getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    float width = displayMetrics.widthPixels / displayMetrics.xdpi;
    float height = displayMetrics.heightPixels / displayMetrics.ydpi;

    double screenDiagonal = Math.sqrt( width * width + height * height );
    int inch = (int) (screenDiagonal + 0.5);
    Toast.makeText(act, "inch : "+ inch, Toast.LENGTH_LONG).show();
    return (inch >= 7 );
}

public boolean isTablet() {
        int screenLayout = getResources().getConfiguration().screenLayout;
        return (Build.VERSION.SDK_INT >= 11 &&
                (((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) || 
                 ((screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE)));
    }

Es wird immer schwieriger, die Grenze zwischen Telefon und Tablet zu ziehen. Zum Beispiel (Stand August 2015) das Samsung Mega 6.3 bezieht Gerät Ressourcen aus den sw600dp-Ordnern - für Android ist es ein Tablet.

Die Antwort von @Vyshnavi funktioniert auf allen Geräten, die wir getestet haben, jedoch nicht für Mega 6.3.

Die obige Antwort von @Helton Isac gibt Mega 6.3 als Telefon zurück. Da das Gerät jedoch weiterhin Ressourcen von sw600dp abruft, kann dies zu anderen Problemen führen. Wenn Sie beispielsweise einen Viewpager für Telefone und nicht für Tablets verwenden, treten NPE-Fehler auf .

Am Ende scheint es einfach zu viele Bedingungen zu geben, auf die wir prüfen können, und wir müssen möglicherweise akzeptieren, dass einige Telefone tatsächlich Tablets sind :-P

Dies ist die Methode, die ich benutze:

public static boolean isTablet(Context ctx){    
    return = (ctx.getResources().getConfiguration().screenLayout 
    & Configuration.SCREENLAYOUT_SIZE_MASK) 
    >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}

Verwenden von:

Aufbau. SCREENLAYOUT_SIZE_MASK

Aufbau. SCREENLAYOUT_SIZE_LARGE

Dies ist die empfohlene Methode!

warum das benutzen?

Use this method which returns true when the device is a tablet

public boolean isTablet(Context context) {  
return (context.getResources().getConfiguration().screenLayout   
    & Configuration.SCREENLAYOUT_SIZE_MASK)    
    >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}

Ich sehe oben viele Möglichkeiten. Die Konfigurationsklasse hat die richtige Antwort direkt unten:

    /**
 * Check if the Configuration's current {@link #screenLayout} is at
 * least the given size.
 *
 * @param size The desired size, either {@link #SCREENLAYOUT_SIZE_SMALL},
 * {@link #SCREENLAYOUT_SIZE_NORMAL}, {@link #SCREENLAYOUT_SIZE_LARGE}, or
 * {@link #SCREENLAYOUT_SIZE_XLARGE}.
 * @return Returns true if the current screen layout size is at least
 * the given size.
 */
public boolean isLayoutSizeAtLeast(int size) {
    int cur = screenLayout&SCREENLAYOUT_SIZE_MASK;
    if (cur == SCREENLAYOUT_SIZE_UNDEFINED) return false;
    return cur >= size;
}

Ruf einfach an :

 getResources().getConfiguration().
 isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE);

Es ist in Ordnung?

Ich musste das Smartphone / Tablet nur in der Layoutdatei erkennen, da ich den Navigationscode verwende.

Zuerst habe ich ein layout-sw600dp-Verzeichnis erstellt, aber es funktionierte nicht gut, da es auf meinem Nokia 8 im Querformat aktiviert wurde, aber die Bildschirmhöhe zu klein war.

Also habe ich das Verzeichnis in layout-sw600dp-h400dp umbenannt und dann den gewünschten Effekt erzielt. Der Parameter h-xxxdp sollte davon abhängen, wie viel Inhalt Sie in Ihrem Layout ablegen möchten, und sollte daher anwendungsabhängig sein.

Bitte überprüfen Sie den folgenden Code.

private boolean isTabletDevice() {
  if (android.os.Build.VERSION.SDK_INT >= 11) { // honeycomb
    // test screen size, use reflection because isLayoutSizeAtLeast is
    // only available since 11
    Configuration con = getResources().getConfiguration();
    try {
      Method mIsLayoutSizeAtLeast = con.getClass().getMethod(
      "isLayoutSizeAtLeast", int.class);
      boolean r = (Boolean) mIsLayoutSizeAtLeast.invoke(con,
      0x00000004); // Configuration.SCREENLAYOUT_SIZE_XLARGE
      return r;
    } catch (Exception x) {
      x.printStackTrace();
      return false;
    }
  }
  return false;
}

Ich denke, ein Tablet hat eine minimale und maximale Breite und Höhe von 600 Pixel. Sie
müssen also die Bildschirmdichte und die Höhe / Breite in dp kennen,
um den Wert abzurufen:

DisplayMetrics metrics = new DisplayMetrics();
activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
Display display = ((WindowManager)getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int width = display.getWidth(); 
int height = display.getHeight(); 
float density = metrics.density;  
if((width/density>=600 && height/density>=600))
 isTablette = true;
else
 isTablette = false;

ZB haben Sie einen wichtigen Unterschied (zumindest für mein Programm) zwischen Telefon und Tablet. Dies ist die Standardausrichtung des Geräts. Telefon hat eine Hochformatausrichtung, das Tablet - Landschaft. Und jeweils Methode zur Bestimmung des Gerätes:

private static boolean isLandscapeDefault(Display display) {
    Log.d(TAG, "isTablet()");
    final int width = display.getWidth();
    final int height = display.getHeight();

    switch (display.getOrientation()) {
    case 0: case 2:
        if(width > height) return true;
        break;
    case 1: case 3:
        if(width < height) return true;
        break;
    }
    return false;
}

EDITIERT: Nach den Gesprächen mit Dan Hulme wurde der Name der Methode geändert.

Ich empfehle Android-Bibliothek 'Koffein' Das enthält bekommen Telefon oder Tablet, und 10inch ~!

sehr einfach zu bedienen.

Die Bibliothek ist hier.

https://github.com/ShakeJ/Android-Caffeine-library

und verwenden

DisplayUtil.isTablet(this);
DisplayUtil.isTenInch(this);

Für mich ist die Unterscheidung zwischen Telefon und Tablet nicht die Größe des Geräts und / oder die Pixeldichte, die sich mit der Technologie und dem Geschmack ändert, sondern das Bildschirmverhältnis. Wenn ich einen Textbildschirm anzeige, muss ich wissen, ob beispielsweise 15 lange Zeilen (Telefon) und 20 kürzere Zeilen (Tablet) benötigt werden. Für mein Spiel verwende ich Folgendes für eine Schätzung des Rechtecks, mit dem sich meine Software befasst:

    Rect surfaceRect = getHolder().getSurfaceFrame();
    screenWidth = surfaceRect.width();
    screenHeight = surfaceRect.height();
    screenWidthF = (float) screenWidth;
    screenHeightF = (float) screenHeight;
    widthheightratio = screenWidthF/screenHeightF;
    if(widthheightratio>=1.5) {
        isTablet=false;
    }else {
        isTablet=true;
    }

Ich denke, das ist der einfachste Weg, um ehrlich zu sein. Dadurch wird die verwendete Bildschirmgröße überprüft:

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();
int height = display.getHeight();

Viel Glück!