Tablet oder Telefon - Android

139

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

Benny
quelle
26
Sie stellen die falsche Frage. Es spielt keine Rolle, ob es sich bei dem Gerät um ein Telefon, ein Tablet, einen Fernseher, einen Toaster, eine Teetasse oder ein Thermometer handelt. Was zählt, sind die Fähigkeiten, nicht die vom Marketing definierte Klasse des Geräts. Stellen Sie eine neue Android-Frage, in der beschrieben wird, welche Funktionen Sie suchen und wie Sie feststellen können, ob das Gerät über solche Funktionen verfügt, oder wie Sie sich aus dem Markt für Geräte herausfiltern können, denen solche Funktionen fehlen.
CommonsWare
7
@CommonsWare: Manchmal möchten Sie zusätzliche Funktionen für Geräte mit einem größeren Bildschirm hinzufügen.
Bobs
10
@breceivemail: Das heißt, Sie müssen überprüfen, ob das Gerät einen größeren Bildschirm hat. "Größerer Bildschirm"! = "Tablet".
CommonsWare
2
Eine bessere Antwort finden Sie hier: stackoverflow.com/a/9308284/1750829 So einfach ist das :-)
Oder Kazaz
3
Ich möchte diese ganze Seite ablehnen! Ein Telefon telefoniert, ein Tablet nicht. So ziemlich alle Vorschläge sind schmutzige Hacks, die niemand verwenden sollte. Die Welt wäre ein besserer Ort, wenn niemand diese Seite jemals wieder sehen würde!
Mark Gjøl

Antworten:

121

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 .

John
quelle
4
+1, eine großartige Antwort, da sie mehr Aufschluss darüber gibt, warum Sie tatsächlich nach Tablet / Telefon suchen möchten. Wir nähern sie einen Moment , in dem Telefon ohnehin kleine Tabletten werden wird;)
Andr
Wie trifft dies auf große Telefone wie das Galaxy Note und das neue Nexus 6 zu? Werden diese großen Geräte mit dieser Technik als Telefone oder Tablets erkannt?
PerracoLabs
1
Leider funktioniert dieser Ansatz für das Samsung Mega 6.3-Gerät nicht und gibt es als Tablet (sw600dp) zurück - gibt es noch andere Ideen, um dies zu erfassen?
bkurzius
telefonieren Tablets?
Mike
61

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

Petey
quelle
Auf beiden - Kindle Fire und Motorola Droid Bionic - SCREENLAYOUT_SIZE_MASK == 15. Warum sollte Ihre Lösung also funktionieren?
Igor Ganapolsky
Ich glaube, dies trifft auf den Kindle Fire zu. Ich habe heute kein Bionic bei mir ... aber ich werde in ein paar Tagen einchecken, wenn mein Freund zurück in die Stadt kommt. Allerdings ... Ich habe die Antwort von Helton Isac getestet und sie funktioniert wunderbar. Bitte überprüfen Sie das auch.
Petey
4
Es gibt Configuration.SCREENLAYOUT_SIZE_XLARGEalso keine Konstante, und Sie können verwenden >= LARGE.
Triang3l
2
Galaxy Note scheint SCREENLAYOUT_SIZE_LARGE zu melden, sodass es fälschlicherweise als Tablet klassifiziert wird
miguelSantirso
1
Wenn die Geräteschriftart klein und die Anzeigegröße in den Einstellungen klein ist, wird dieser Fall als true zurückgegeben.
Arul
38

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;
}
Helton Isac
quelle
2
Die beste Lösung, die ich gefunden habe, danke Helton Isac! Vielleicht können Sie (für eine bessere Lösung) eine Überprüfung für die Zoll des Bildschirms hinzufügen? sowieso eine 10 für diese Lösung
Aracem
7
Ich bin wirklich anderer Meinung. Dies ist eine Methode, um eine bestimmte Bildschirmgröße zu ermitteln. Wie ich bereits geantwortet habe, gibt es keinen Unterschied zwischen einem Tablet und einem Telefon. Dies ist keine Antwort auf die Frage. Es ist nicht möglich zu unterscheiden, da es keinen Unterschied gibt. Wenn Sie für bestimmte Funktionen codieren müssen (wie Sie es für bestimmte Bildschirmgrößen zu tun scheinen), tun Sie dies, aber nennen Sie es nicht Tablet gegen Telefon. Der Themenstarter schien die Linie auf bestimmte Neigungsfunktionen zu setzen. Lesen Sie den Kommentar von @commonware zu dieser Frage gründlich durch.
Nanne
1
Ich stimme Nanne zu, aber wie gesagt, in meiner Bewerbung muss ich zwei Panels anzeigen, wenn der Bildschirm groß genug ist, um dies zu tun. In diesem Fall kann ich keine Layouts verwenden, da sich die Bildschirmlogik auf der Java-Seite befand.
Helton Isac
3
Helton, danke dafür. Ich dachte, ich würde sagen, dass dies zurückkehrt: Kindle Fire: false, Moto Xoom (v1): true, Galaxy Hinweis: false, Galaxy Tab 10.1 limitiert: true
petey
Abgesehen von dem Argument ist Configuration.SCREENLAYOUT_SIZE_XLARGE = 4 gemäß developer.android.com/reference/android/content/res/… , das stattdessen für API-Level unter 9 verwendet werden kann.
trgraglia
12

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.

Volker Voecking
quelle
Dies funktioniert nicht ... einfach einige Telefone melden die falschen Dichtewerte und die Berechnung in Zoll schlägt fehl - siehe dort: stackoverflow.com/questions/2193457/…
STeN
Nun, ich mag 7 'Tablets (Taschenformat) und diese Antwort ist die beste, die ich denke. Aber return (screenDiagonal> = 9.0); sollte zurückgegeben werden (screenDiagonal> = 6.5). Allerdings abhängig von der Verwendung wie in den Kommentaren zur Frage kommentiert.
Jan Bergström
11

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)

Nanne
quelle
Ich habe Probleme mit meiner Neigungsfunktion und meinem neuen Tablet (Transformer)
Benny
Eine dumme Antwort imo - natürlich gibt es einen Unterschied. Galaxy = Telefon. Warum? Weil es laut Hersteller ein "Smartphone" ist. Wenn Sie andeuten, dass er nach Größe, Anruffähigkeit oder ... irgendetwas suchen muss, sagen Sie das einfach.
Dave
3
Ich bin anderer Meinung, es funktioniert möglicherweise nicht für alle Handys, während einige Tablets über diese Sensoren verfügen. Deshalb meine erste Antwort über keinen Unterschied. Wie auch immer, ich habe einen Code hinzugefügt, den Sie ausprobieren sollten.
Nanne
2
Das Problem ist, dass die x- und y-Achse des Beschleunigungsmessers umgedreht werden, wenn Sie erwarten, dass Ihre App im Hochformat ausgeführt wird, da Tablets im Querformat "erstellt" werden. Dies kann die Dinge ziemlich durcheinander bringen :) Daher ist es wichtig, dass Sie überprüfen, ob Sie auf einem Tablet laufen oder nicht.
Pumpkee
1
Aber dann ist es umgekehrt => Wenn dies das einzige ist, was ein Gerät zu einem Tablet macht, sollten Sie herausfinden, wie die x / y-Achse funktioniert, und nicht umgekehrt. Ich bezweifle übrigens, dass dies für alle Tablets und / oder Telefone gilt?
Nanne
10

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";
}
Robert Dale Johnson III
quelle
9
Einige Tablets können telefonieren und haben einen GSM- oder CDMA-Typ ... Ihre Lösung ist also auch nicht perfekt.
Arnouf
6

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
}
Cjames
quelle
5

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

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

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;
        }
        }
Pier Betos
quelle
2
Was ist der Wert von shortSize?
kc ochibili
3

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;
}
hqt
quelle
Diese Lösung funktioniert zB nicht auf einem Emulator mit API 18 und Nexus 7 1200 x 1920 xhdpi!
Ingo
1
Sie sollten auf einem echten Gerät testen :)
HQT
Ich habe auf Emulator getestet und das Ergebnis von "isTablet (Kontextkontext) war falsch. Versuchen Sie es selbst auf Emulator.
Ingo
1
Vielen Dank für dieses @hqt, ich habe dies gerade in das C # transkodiert, das für Xamarin Studio benötigt wird:public static bool isTablet (Context context) { return (context.Resources.Configuration.ScreenLayout & Android.Content.Res.ScreenLayout.SizeMask) >= Android.Content.Res.ScreenLayout.SizeLarge; }
Phil Ryan
2

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.

Geben Sie hier die Bildbeschreibung ein

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

Suragch
quelle
2

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

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

Prost :-)

Mohanraj Balasubramaniam
quelle
1

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

Aracem
quelle
1

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

Max
quelle
1

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; 
}
Vyshnavi
quelle
Diese Lösung funktioniert zB nicht auf einem Emulator mit API 18 und Nexus 7 1200 x 1920 xhdpi!
Ingo
Dies funktioniert auf einigen Geräten nicht mehr. Zum Beispiel gibt es für Samsung Mega-Gerät
false zurück
Ja .. Das funktioniert nicht mehr ... Ich habe in der gesamten Zeichenfolgendatei für jeden Ordner Werte, Werte_Groß usw. Boolesche Werte hinzugefügt. <Bool name = "isTablet"> false </ bool> <bool name = "isLargeTablet"> false </ bool> und überprüfen Sie dann, ob R.bool.isTablet wahr ist, um festzustellen, ob das Gerät Tablet ist
Vyshnavi
1

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

BSTech
quelle
0

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>
Alexander Pacha
quelle
0

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

RBz
quelle
0

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 );
}
MinFu
quelle
0
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)));
    }
Zar E Ahmer
quelle
0

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

bkurzius
quelle
0

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!

Jorgesys
quelle
Erklärung für -1? Dies ist eine von Google empfohlene Methode.
Jorgesys
0

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?

Longalei
quelle
0

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.

Dominique Lorre
quelle
-1

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;
}
SathishBabu S.
quelle
1
Nicht mehr gültig mit ICS. In der Tat gibt es Tablets mit Android-Versionen unter 11
mdelolmo
1
Dies ist NICHT zuverlässig. Die neuen ICS-Telefone haben eine API-Stufe> 11.
Jason Robinson
-1

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;

user1503892
quelle
Dies ist nicht richtig, weil Samsung Galaxy S3 Ergebnis 720 x 1280.
Nikhil
-1

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.

Silber
quelle
1
Nicht alle Tablets haben eine Standard-Querformatausrichtung. Und wenn die "Standard" -Orientierung für Ihr Programm von Bedeutung ist, ist sie wahrscheinlich auf andere Weise falsch. Ein Beispiel finden Sie in diesem Blog-Beitrag für Android-Entwickler .
Dan Hulme
Können Sie bitte konkrete Beispiele für Tablets nennen, bei denen in der Standardausrichtung die Breite kleiner als die Höhe ist? Und natürlich weißt du besser, was meine App sein soll: D.
Silber
Das Nexus 7 wäre ein Beispiel. Aber Sie müssen nicht mein Wort dafür nehmen: Lesen Sie den Artikel, den ich verlinkt habe, der alles erklärt.
Dan Hulme
Ich denke, sollte den Namen meiner Methode ändern. Noch wichtiger ist (zumindest für meine App;)) die Standardausrichtung des Geräts, und meine Methode ist für diese Aufgabe geeignet. Auch sehr richtig identifiziert das Problem @Nanne Antwort, siehe oben.
Silber
-1

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);
ShakeJ
quelle
-1

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;
    }
Androidcoder
quelle
-3

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!

Otroberts
quelle