Tablet lub telefon - Android

140

Czy istnieje sposób na sprawdzenie, czy użytkownik korzysta z tabletu czy telefonu? Mam problemy z funkcją pochylania i nowym tabletem (Transformer)

Benny
źródło
26
Zadajesz złe pytanie. Nie ma znaczenia, czy urządzenie to telefon, tablet, telewizor, toster, filiżanka do herbaty czy termometr. Liczy się możliwości, a nie zdefiniowana marketingowo klasa urządzenia. Zadaj nowe pytanie dotyczące Androida, opisujące, jakich funkcji szukasz i jak wykryć, czy urządzenie ma takie możliwości lub jak odfiltrować się z rynku w poszukiwaniu urządzeń, które nie mają takich możliwości.
CommonsWare
7
@CommonsWare: czasami chcesz dodać dodatkowe funkcje dla urządzeń z większym ekranem.
Bobs
10
@breceivemail: co oznacza, że ​​musisz sprawdzić, czy urządzenie ma większy ekran. „Większy ekran”! = „Tablet”.
CommonsWare
2
Lepszą odpowiedź można znaleźć tutaj: stackoverflow.com/a/9308284/1750829 To proste :-)
Lub Kazaz
3
Chciałbym negatywnie ocenić całą tę stronę! Telefon obsługuje telefon, tablet nie. Prawie wszystkie sugestie to brudne hacki, których nikt nie powinien używać. Świat byłby lepszym miejscem, gdyby nikt więcej nie zobaczył tej strony!
Mark Gjøl

Odpowiedzi:

122

Jak zostało wspomniane wcześniej, nie chcesz sprawdzać, czy urządzenie to tablet czy telefon, ale chcesz poznać funkcje urządzenia,

W większości przypadków różnica między tabletem a telefonem polega na rozmiarze ekranu, dlatego chcesz używać różnych plików układu. Te pliki są przechowywane w res/layout-<qualifiers>katalogach. Możesz utworzyć plik XML w Directoyres/values-<same qualifiers> dla każdego ze swoich układów i umieścić w nim zasób int / bool / string, aby rozróżnić używane układy.

Przykład:

Plik res/values/screen.xml(zakładając, że res/layout/zawiera pliki układu dla telefonów)

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


Plik res/values-sw600dp/screen.xml(zakładając, że res/layout-sw600dp/zawiera pliki układu dla małych tabletów, takich jak Nexus 7)

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


Plik res/values-sw720dp/screen.xml(zakładając, że res/layout-sw720dp/zawiera pliki układu dla dużych tabletów, takich jak Nexus 10):

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


Teraz typ ekranu jest dostępny za pośrednictwem R.string.screen_typestałej.

Jan
źródło
4
+1, świetna odpowiedź, ponieważ zapewnia lepszy wgląd w to, dlaczego naprawdę chcesz sprawdzić, czy masz tablet / telefon. Zbliżamy się do momentu, w którym telefony i tak staną się małymi tabletami;)
andr.
Jak to się ma do dużych telefonów, takich jak Galaxy Note i nowy Nexus 6? Czy przy użyciu tej techniki te duże urządzenia zostaną wykryte jako telefony lub tablety?
PerracoLabs
1
Niestety ten apporach nie działa na urządzeniu Samsung Mega 6.3 i zwraca go jako tablet (sw600dp) - jakieś inne pomysły, aby to uchwycić?
bkurzius
czy tablety wykonują połączenia telefoniczne?
Mike
61

Aby wykryć, czy urządzenie jest tabletem, użyj następującego kodu:

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

Rozmiary ekranu LARGE i XLARGE są określane przez producenta na podstawie odległości od oka, w którym mają być używane (stąd idea tabletu).

Więcej informacji: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

petey
źródło
Na obu - Kindle Fire i Motorola Droid Bionic - SCREENLAYOUT_SIZE_MASK == 15. Dlaczego więc Twoje rozwiązanie miałoby działać?
IgorGanapolsky
Wierzę, że to prawda na Kindle Fire. Nie mam dziś przy sobie bioniki ... ale sprawdzę za kilka dni, kiedy mój przyjaciel wróci do miasta. Jednak ..... testowałem odpowiedź Heltona Isaca i działa pięknie. Proszę to też sprawdzić.
petey
4
Jest Configuration.SCREENLAYOUT_SIZE_XLARGE, więc nie musisz używać stałej i możesz użyć >= LARGE.
Triang3l
2
Wydaje się, że Galaxy Note zgłasza SCREENLAYOUT_SIZE_LARGE, więc zostałby błędnie sklasyfikowany jako tablet
miguelSantirso
1
Jeśli czcionka urządzenia jest mała, a rozmiar wyświetlacza jest mały w ustawieniach, ten przypadek jest zwracany jako prawda.
arul
38

Ten post bardzo mi pomógł,

Niestety nie mam reputacji potrzebnej do oceny wszystkich odpowiedzi, które mi pomogły.

Musiałem określić, czy moim urządzeniem jest tablet czy telefon, dzięki czemu będę w stanie zaimplementować logikę ekranu. W mojej analizie tablet musi mieć więcej niż 7 cali (Xlarge), zaczynając od MDPI.

Oto poniższy kod, który został utworzony na podstawie tego postu.

/**
 * 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
źródło
2
Najlepsze rozwiązanie, jakie znalazłem, dziękuję Helton Isac! Może mógłbyś dodać (dla lepszego rozwiązania) kratkę na cale ekranu? w każdym razie 10 dla tego rozwiązania
Aracem
7
I naprawdę nie zgodzić. Jest to metoda znajdowania określonego rozmiaru ekranu. Ponownie, jak już odpowiedziałem, NIE MA różnicy między tabletem a telefonem. To nie jest odpowiedź na pytanie. Nie jest możliwe rozróżnienie, ponieważ nie ma 1 różnicy. Jeśli potrzebujesz kodować dla pewnych funkcji (tak jak wydaje się to robić dla niektórych rozmiarów ekranu), zrób to, ale nie nazywaj tego tabletem a telefonem. Wydawało się, że starter tematu umieścił line @ pewną funkcjonalność pochylenia. Przeczytaj uważnie komentarz @commonware do tego pytania.
Nanne
1
Zgadzam się z Nanne, ale tak jak powiedziałem, w mojej Aplikacji muszę pokazać dwa panele, jeśli ekran jest wystarczająco duży, aby to zrobić. I nie mogę używać układów w tym przypadku, ponieważ logika ekranu była po stronie Java.
Helton Isac
3
Helton, dzięki za to. Pomyślałem, że powróci: Kindle Fire: false, Moto Xoom (v1): true, Galaxy Note: false, Galaxy Tab 10.1 limited: true
petey
Oprócz argumentu Configuration.SCREENLAYOUT_SIZE_XLARGE = 4 zgodnie z developer.android.com/reference/android/content/res/…, który może być użyty zamiast tego dla poziomu API niższego niż 9.
trgraglia
12

Dlaczego nie obliczyć przekątnej ekranu i na tej podstawie podjąć decyzję, czy urządzenie to telefon czy tablet?

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

Oczywiście można się spierać, czy próg powinien wynosić 9 cali czy mniej.

Volker Voecking
źródło
To nie działa ... po prostu niektóre telefony zgłaszają nieprawidłowe wartości gęstości, a obliczenia w calach
kończą się
Cóż, lubię 7-calowe tablety (kieszonkowe) i myślę, że ta odpowiedź jest najlepsza. Ale powrót (przekątna ekranu> = 9,0); powinien zostać zwrócony (przekątna ekranu> = 6,5). Jednak w zależności od zastosowania, jak w komentarzach do pytania.
Jan Bergström
11

nie ma różnicy. Powinieneś zdefiniować, co Twoim zdaniem jest różnicą, i to sprawdzić. Czy Galaxy Tab to telefon? czy tablet? i dlaczego?

Powinieneś zdefiniować, jakich konkretnych funkcji szukasz, i zakodować to.

Wygląda na to, że szukasz „tilt”. Myślę, że to to samo, co akcelerometr (czy to słowo?). Możesz po prostu sprawdzić, czy urządzenie to obsługuje, używając:

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

(z http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . nie testowałem tego)

Nanne
źródło
Mam problemy z funkcją przechylania i moim nowym tabletem (Transformer)
Benny
Coś w rodzaju głupiej odpowiedzi imo - oczywiście jest różnica. Galaxy = telefon. Czemu? Bo to po pierwsze „smartfon” według producenta. Jeśli sugerujesz, że musi sprawdzić rozmiar, zdolność do dzwonienia lub ... cokolwiek - po prostu to powiedz.
Dave
3
Nie zgadzam się, może nie działać dla wszystkich telefonów komórkowych, podczas gdy niektóre tablety mają te czujniki. Dlatego moja początkowa odpowiedź o braku różnicy. W każdym razie dodałem kod, który powinieneś wypróbować.
Nanne
2
Problem polega na tym, że ponieważ tablety są „budowane” w trybie poziomym, osie X i Y akcelerometru są odwracane, gdy oczekujesz, że aplikacja będzie działać w trybie pionowym. Może to trochę zepsuć sprawę :) Dlatego ważne jest, aby sprawdzić pogodę na tablecie, czy nie.
pumpkee
1
Ale jest na odwrót => jeśli to jedyna rzecz, która sprawia, że ​​urządzenie jest tabletem, powinieneś dowiedzieć się, jak działa oś x / y, a nie odwrotnie. Swoją drogą wątpię, czy dotyczy to wszystkich tabletów i / lub telefonów?
Nanne
10

Zakładam, że kiedy definiujesz „Komórka / Telefon”, chcesz wiedzieć, czy możesz wykonać połączenie telefoniczne na urządzeniu, którego nie można wykonać na czymś, co można by zdefiniować jako „Tablet”. Sposób sprawdzenia tego znajduje się poniżej. Jeśli chcesz wiedzieć coś na podstawie czujników, rozmiaru ekranu itp., To jest naprawdę inne pytanie.

Ponadto, podczas korzystania z rozdzielczości ekranu lub zarządzania zasobami duże w porównaniu z dużymi, mogło to być właściwe podejście w przeszłości, nowe urządzenia `` mobilne '' są teraz dostarczane z tak dużymi ekranami i wysoką rozdzielczością, że zacierają tę linię, jeśli naprawdę chcesz aby wiedzieć, jak rozmowa telefoniczna vs brak możliwości połączenia telefonicznego, poniższe jest „najlepsze”.

TelephonyManager manager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
if(manager.getPhoneType() == TelephonyManager.PHONE_TYPE_NONE){
    return "Tablet";
}else{
    return "Mobile";
}
Robert Dale Johnson III
źródło
9
Niektóre tablety mogą telefonować i mieć typ GSM lub CDMA ... Twoje rozwiązanie też nie jest idealne.
arnouf
6

Na podstawie Roberta Dale Johnsona III i Heltona Isaca wymyśliłem ten kod Mam nadzieję, że jest to przydatne

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

Więc w swoim kodzie utwórz filtr taki jak

if(isTabletDevice(Utilities.this) && isTablet(Utilities.this)){
    //Tablet
} else {
    //Phone
}
Cjames
źródło
6

W kodzie źródłowym aplikacji Google IOSched 2017 zastosowano następującą metodę:

public static boolean isTablet(Context context) {
    return context.getResources().getConfiguration().smallestScreenWidthDp >= 600;
}
Murat
źródło
3

Ci, którzy chcą odnieść się do kodu Google decydującego o tym, które urządzenia będą używać interfejsu tabletu, mogą zapoznać się poniżej:

  // 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
źródło
2
jaka jest wartość shortSize?
kc ochibili
3

Ta metoda jest zalecana przez Google. Widzę ten kod w aplikacji Google Offical na Androidaiosched

public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
}
hqt
źródło
To rozwiązanie np. Nie działa na emulatorze z API 18 i Nexus 7 1200 x 1920 xhdpi!
Ingo,
1
powinieneś przetestować na prawdziwym urządzeniu :)
hqt
Przetestowałem na emulatorze i wynik „isTablet (kontekst kontekstu) był fałszywy. Spróbuj samodzielnie na emulatorze.
Ingo
1
Dzięki za to @hqt, właśnie transkodowałem to do C # potrzebnego dla Xamarin Studio:public static bool isTablet (Context context) { return (context.Resources.Configuration.ScreenLayout & Android.Content.Res.ScreenLayout.SizeMask) >= Android.Content.Res.ScreenLayout.SizeLarge; }
Phil Ryan
2

Nie potrzeba żadnego kodu

Pozostałe odpowiedzi zawierają wiele sposobów programowego określania, czy urządzenie to telefon czy tablet. Jeśli jednak przeczytasz dokumentację , nie jest to zalecany sposób obsługi różnych rozmiarów ekranu.

Zamiast tego zadeklaruj różne zasoby dla tabletów lub telefonów. Robisz to moje dodawanie dodatkowych zasobów dla folderów layout, valuesitp

  • W przypadku systemu Android 3.2 (poziom interfejsu API 13) należy dodać sw600dpfolder. Oznacza to, że s mallest w IDþ przynajmniej 600dp, który jest w przybliżeniu taki podział komórkowy / tabletkę. Możesz jednak dodać również inne rozmiary. Zapoznaj się z tą odpowiedzią, aby zobaczyć przykład, jak dodać dodatkowy plik zasobów układu.

  • Jeśli obsługujesz także urządzenia z systemem starszym niż Android 3.2, musisz dodać large lub xlargefoldery, aby obsługiwać tablety. (Telefony są na ogół smalli normal.)

Oto obraz tego, co mogą spodobać się Twoim zasobom po dodaniu dodatkowych plików xml dla różnych rozmiarów ekranu.

wprowadź opis obrazu tutaj

Korzystając z tej metody, system określa wszystko za Ciebie. Nie musisz się martwić, które urządzenie jest używane w czasie wykonywania. Wystarczy zapewnić odpowiednie zasoby i pozwolić Androidowi wykonać całą pracę.

Uwagi

  • Możesz użyć aliasów, aby uniknąć duplikowania identycznych plików zasobów.

Warto przeczytać dokumenty dotyczące Androida

Suragch
źródło
2

Jeśli kierujesz tylko na poziom interfejsu API> = 13, spróbuj

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

Twoje zdrowie :-)

Mohanraj Balasubramaniam
źródło
1

Myśląc o "nowych" zaakceptowanych katalogach (na przykład values-sw600dp) stworzyłem tę metodę w oparciu o szerokość ekranu DP:

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

Na tej liście można znaleźć niektóre DP popularnych urządzeń i rozmiarów tabletów:

Wdp / Hdp

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

Wdp = Szerokość dp
Hdp = Wysokość dp

Aracem
źródło
1

Cóż, najlepsze rozwiązanie, które u mnie zadziałało, jest dość proste:

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

Używane w ten sposób:

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

Naprawdę nie chcę patrzeć na rozmiary pikseli, ale polegam tylko na rozmiarze ekranu.

Działa dobrze, ponieważ Nexus 7 (LARGE) jest wykrywany jako tablet, ale nie Galaxy S3 (NORMAL).

Maks
źródło
1

Użyj tej metody, która zwraca wartość true, gdy urządzeniem jest tablet

public boolean isTablet(Context context) {  
    return (context.getResources().getConfiguration().screenLayout   
        & Configuration.SCREENLAYOUT_SIZE_MASK)    
        >= Configuration.SCREENLAYOUT_SIZE_LARGE; 
}
Vyshnavi
źródło
To rozwiązanie np. Nie działa na emulatorze z API 18 i Nexus 7 1200 x 1920 xhdpi!
Ingo,
To już nie działa na niektórych urządzeniach. Na przykład zwraca fałsz dla urządzenia Samsung Mega
bkurzius
Tak ... To już nie działa ... Właściwie użyłem do dodawania wartości logicznych we wszystkich plikach łańcuchowych dla wartości każdego folderu, values_large itp. <Bool name = "isTablet"> false </bool> <bool name = "isLargeTablet"> false </bool>, a następnie sprawdź, czy R.bool.isTablet jest prawdziwy, aby sprawdzić, czy urządzenie to tablet
Vyshnavi
1

Jeśli wykrywanie rozmiaru ekranu nie zwraca prawidłowej wartości na nowszych urządzeniach, spróbuj:

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

Testowane na Androidzie 4.2.2 (przepraszam za mój angielski).

BSTech
źródło
0

Wiem, że to nie jest bezpośrednia odpowiedź na twoje pytanie, ale inne odpowiedzi tutaj dają dobry pomysł, jak rozpoznać rozmiar ekranu. Napisałeś w swoim pytaniu, że masz problemy z przechylaniem i mi się to przydarzyło.

Jeśli uruchomisz żyroskop (lub czujnik obrotu) na smartfonie, osie X i Y mogą być zdefiniowane inaczej niż na tablecie, zgodnie z domyślną orientacją tego urządzenia (np. Samsung GS2 to domyślny portret, Samsung GT-7310 jest domyślny poziomo, nowy Google Nexus 7 to domyślny portret, chociaż to tablet!).

Teraz, jeśli chcesz korzystać z żyroskopu, możesz skończyć z działającym rozwiązaniem dla smartfonów, ale w przypadku niektórych tabletów z pomieszaniem osi.

Jeśli używasz jednego z powyższych rozwiązań, wybierz tylko rozmiar ekranu, a następnie zastosuj

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

aby odwrócić oś, jeśli ma duży lub duży rozmiar ekranu, może to zadziałać w 90% przypadków, ale na przykład w Nexusie 7 spowoduje problemy (ponieważ ma domyślną orientację pionową i duży rozmiar ekranu).

Najprostszy sposób rozwiązania tego problemu znajduje się w RotationVectorSample, który jest dostarczany z demonstracjami interfejsu API, ustawiając sceenOrientation na nosensorw swoim manifeście:

<activity
    ...
    android:screenOrientation="nosensor">
...
</activity>
Alexander Pacha
źródło
0

com.sec.feature.multiwindow.tablet w menedżerze pakietów jest specyficzna tylko dla tabletu, a com.sec.feature.multiwindow.phone jest specyficzna dla telefonu.

RBz
źródło
0

Poniższa metoda polega na obliczeniu przekątnej ekranu urządzenia, aby zdecydować, czy urządzenie to telefon lub tablet. jedyną troską w przypadku tej metody jest to, jaka jest wartość progowa decydująca o tym, czy urządzenie jest tabletem, czy nie. w poniższym przykładzie ustawiłem go na 7 cali i więcej.

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
źródło
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
źródło
0

Coraz trudniej jest wyznaczyć granicę między telefonem a tabletem. Na przykład (stan na sierpień 2015 r.) Urządzenie Samsung Mega 6.3 pobiera zasoby z folderów sw600dp - w przypadku Androida jest to tablet.

Odpowiedź od @Vyshnavi działa na wszystkich testowanych przez nas urządzeniach, ale nie na Mega 6.3.

@Helton Isac odpowiedź powyżej zwraca Mega 6.3 jako telefon - ale ponieważ urządzenie nadal pobiera zasoby ze sw600dp, może to powodować inne problemy - na przykład, jeśli używasz przeglądarki dla telefonów, a nie tabletów, skończysz z błędami NPE .

W końcu wydaje się, że jest zbyt wiele warunków do sprawdzenia i być może będziemy musieli zaakceptować, że niektóre telefony to tak naprawdę tablety :-P

bkurzius
źródło
0

Oto metoda, której używam:

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

Za pomocą:

Konfiguracja. SCREENLAYOUT_SIZE_MASK

Konfiguracja. SCREENLAYOUT_SIZE_LARGE

To jest zalecana metoda!

Jorgesys
źródło
Wyjaśnienie dla -1? , jest to metoda polecana przez Google.
Jorgesys,
0

dlaczego tego używać?

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

Widzę wiele sposobów powyżej. klasa Konfiguracja otrzymała właściwą odpowiedź tuż poniżej:

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

Zadzwoń :

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

w porządku?

Longalei
źródło
0

Musiałem wykryć smartfon / tablet tylko w pliku układu, ponieważ używam kodu nawigacyjnego.

Najpierw utworzyłem katalog layout-sw600dp, ale nie działał on dobrze, ponieważ aktywowałby się na mojej Nokii 8 w trybie poziomym, ale wysokość ekranu byłaby zbyt mała.

Więc zmieniłem nazwę katalogu na layout-sw600dp-h400dp i uzyskałem pożądany efekt. Parametr h-xxxdp powinien zależeć od tego, ile treści chcesz upuścić w swoim układzie i jako taki powinien zależeć od aplikacji.

Dominique Lorre
źródło
-1

Sprawdź poniższy kod.

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
źródło
1
Nie jest już ważny z ICS. Rzeczywiście, istnieją tablety z wersjami Androida poniżej 11
mdelolmo
1
To NIE jest wiarygodne. Nowe telefony ICS mają poziom API> 11.
Jason Robinson,
-1

Myślę, że tablet ma minimalną i maksymalną szerokość i wysokość 600 pikseli,
więc
aby pobrać wartość , musisz znać gęstość ekranu i wysokość / szerokość w dp :

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
źródło
To nie jest prawda, ponieważ wynik Samsung Galaxy S3 720 x 1280.
Nikhil
-1

Np. Mam jedną ważną różnicę (przynajmniej dla mojego programu) między telefonem a tabletem. Jest to domyślna orientacja urządzenia. Telefon ma orientację pionową, tablet - poziomy. I odpowiednio metoda określenia urządzenia:

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

ZMIENIONO: Po rozmowach z Danem Hulme zmieniono nazwę metody.

Srebro
źródło
1
Nie wszystkie tablety mają domyślną orientację poziomą. A jeśli „domyślna” orientacja ma znaczenie dla twojego programu, prawdopodobnie jest błędna z innych powodów. Przykład można znaleźć w tym poście na blogu programistów Androida .
Dan Hulme
Czy może Pan podać konkretne przykłady tabletów, których w domyślnym ustawieniu szerokość jest mniejsza niż wysokość? I oczywiście wiesz lepiej, jaka powinna być moja aplikacja: D.
Srebro
Przykładem może być Nexus 7. Ale nie musisz wierzyć mi na słowo: przeczytaj artykuł, do którego utworzyłem łącze, który wyjaśnia wszystko.
Dan Hulme
Myślę, że powinienem zmienić nazwę mojej metody. W rzeczywistości, co ważniejsze (przynajmniej dla mojej aplikacji;)) domyślna orientacja urządzenia, a moja metoda jest odpowiednia do tego zadania. Również bardzo poprawnie zidentyfikowano problem @Nanne odpowiedź, patrz wyżej.
Srebro
-1

Dla mnie różnicą między telefonem a tabletem nie jest rozmiar urządzenia i / lub gęstość pikseli, która będzie się zmieniać wraz z technologią i gustem, ale raczej proporcje ekranu. Jeśli wyświetlam ekran z tekstem, muszę wiedzieć, czy na przykład potrzeba 15 długich linii (telefon), a 20 krótszych (tablet). W mojej grze używam następujących do oszacowania pola gry dla prostokąta, z którym będzie się mierzyć moje oprogramowanie:

    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
źródło
-3

Myślę, że to najłatwiejszy sposób, aby być uczciwym. Spowoduje to sprawdzenie używanego rozmiaru ekranu:

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

Powodzenia!

Otroberts
źródło