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

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.

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

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

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.

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)

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

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
}

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

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

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

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.

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

• Obsługa wielu ekranów
• Obsługa różnych rozmiarów ekranu
• Dystrybucja na określone ekrany

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

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

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

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

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

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>

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.

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

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

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

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!

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?

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.

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

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;

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.

Polecam bibliotekę Android „kofeina”, która zawiera telefon lub tablet i 10 cali ~!

bardzo łatwy w użyciu.

biblioteka jest tutaj.

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

I użyć

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

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

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!