Có cách nào để kiểm tra xem người dùng đang sử dụng máy tính bảng hay điện thoại không? Tôi đã gặp sự cố với chức năng nghiêng của mình và máy tính bảng mới (Transformer)

Như đã được đề cập trước đây, bạn không muốn kiểm tra xem thiết bị là máy tính bảng hay điện thoại nhưng bạn muốn biết về các tính năng của thiết bị,

Hầu hết thời gian, sự khác biệt giữa máy tính bảng và điện thoại là kích thước màn hình, đó là lý do tại sao bạn muốn sử dụng các tệp bố cục khác nhau. Những tập tin này được lưu trữ trong các res/layout-<qualifiers>thư mục. Bạn có thể tạo một tệp XML trong directoy res/values-<same qualifiers>cho từng bố cục của mình và đặt tài nguyên int / bool / chuỗi vào đó để phân biệt giữa các bố cục bạn sử dụng.

Thí dụ:

Tệp res/values/screen.xml(giả sử res/layout/chứa tệp bố cục của bạn cho thiết bị cầm tay)

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

Tệp res/values-sw600dp/screen.xml(giả sử res/layout-sw600dp/chứa tệp bố cục của bạn cho máy tính bảng nhỏ như Nexus 7)

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

Tệp res/values-sw720dp/screen.xml(giả sử res/layout-sw720dp/chứa tệp bố cục của bạn cho máy tính bảng lớn như Nexus 10):

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

Bây giờ loại màn hình có thể truy cập thông qua R.string.screen_typehằng số.

Để phát hiện thiết bị có phải là máy tính bảng hay không, hãy sử dụng mã sau:

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

Kích thước màn hình LARGE và XLARGE được xác định bởi nhà sản xuất dựa trên khoảng cách từ mắt mà chúng sẽ được sử dụng (do đó là ý tưởng của một chiếc máy tính bảng).

Thông tin thêm: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Bài đăng này đã giúp tôi rất nhiều,

Thật không may, tôi không có danh tiếng cần thiết để đánh giá tất cả các câu trả lời đã giúp tôi.

Tôi cần xác định xem thiết bị của mình là máy tính bảng hay điện thoại, với điều đó tôi sẽ có thể thực hiện logic của màn hình. Và trong phân tích của tôi, máy tính bảng phải lớn hơn 7 inch (Xlarge) bắt đầu từ MDPI.

Đây là đoạn mã dưới đây, được tạo ra dựa trên bài đăng này.

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

Tại sao không tính toán kích thước của đường chéo màn hình và sử dụng nó để đưa ra quyết định xem thiết bị là điện thoại hay máy tính bảng?

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

Tất nhiên người ta có thể tranh luận liệu ngưỡng nên là 9 inch hay ít hơn.

không có sự khác biệt Bạn nên xác định những gì bạn nghĩ là sự khác biệt, và kiểm tra xem điều đó. Là một tab thiên hà một điện thoại? hay một chiếc máy tính bảng? và tại sao?

Bạn nên xác định những tính năng cụ thể mà bạn đang tìm kiếm và mã cho điều đó.

Có vẻ như bạn đang tìm kiếm "độ nghiêng". Tôi nghĩ rằng đây là giống như gia tốc kế (đó có phải là một từ?). Bạn chỉ có thể kiểm tra xem thiết bị có hỗ trợ hay không, sử dụng:

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

(từ http: // warethathappens.com/blog/2009/03/15/android-accelerometer/ . Tôi chưa thử nghiệm nó)

Giả định của tôi là khi bạn xác định 'Điện thoại di động / Điện thoại', bạn muốn biết liệu bạn có thể thực hiện cuộc gọi điện thoại trên thiết bị không thể thực hiện trên một thứ được xác định là 'Máy tính bảng' hay không. Cách để xác minh điều này là dưới đây. Nếu bạn muốn biết một cái gì đó dựa trên cảm biến, kích thước màn hình, vv thì đây thực sự là một câu hỏi khác.

Ngoài ra, trong khi sử dụng độ phân giải màn hình hoặc quản lý tài nguyên lớn so với xlarge, có thể là một cách tiếp cận hợp lệ trong các thiết bị 'Mobile' mới trước đây hiện đang có màn hình lớn và độ phân giải cao đến mức chúng làm mờ dòng này trong khi bạn thực sự muốn để biết cuộc gọi điện thoại và không có khả năng gọi điện thoại dưới đây là 'tốt nhất'.

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

Dựa trên Robert Dale Johnson III và Helton Isac, tôi đã đưa ra mã này Hy vọng điều này hữu ích

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

Vì vậy, trong mã của bạn tạo một bộ lọc như

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

Trong mã nguồn ứng dụng Google IOSched 2017 , phương pháp sau được sử dụng:

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

Đối với những người muốn tham khảo mã của Google về việc quyết định thiết bị nào sẽ sử dụng UI UI có thể tham khảo bên dưới:

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

Phương pháp này được Google khuyên dùng. Tôi thấy mã này trong Ứng dụng Android chính thức của Googleiosched

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

Không cần mã

Các câu trả lời khác liệt kê nhiều cách xác định theo chương trình cho dù thiết bị là điện thoại hay máy tính bảng. Tuy nhiên, nếu bạn đọc tài liệu , đó không phải là cách được khuyến nghị để hỗ trợ các kích cỡ màn hình khác nhau.

Thay vào đó, khai báo các tài nguyên khác nhau cho máy tính bảng hoặc điện thoại. Bạn làm điều này thêm tôi thư mục tài nguyên bổ sung cho layout, valuesvv

• Đối với Android 3.2 (API cấp 13), hãy thêm sw600dpthư mục. Điều này có nghĩa là s mallest w idth ít nhất là 600dp, xấp xỉ khoảng cách giữa điện thoại / máy tính bảng. Tuy nhiên, bạn cũng có thể thêm các kích thước khác. Kiểm tra câu trả lời này để biết ví dụ về cách thêm tệp tài nguyên bố cục bổ sung.

• Nếu bạn cũng đang hỗ trợ các thiết bị Android 3.2 trước, thì bạn sẽ cần thêm largehoặc xlargethư mục để hỗ trợ máy tính bảng. (Điện thoại nói chung smallvà normal.)

Dưới đây là hình ảnh về những gì tài nguyên của bạn có thể thích sau khi thêm tệp xml bổ sung cho các kích thước màn hình khác nhau.

Khi sử dụng phương pháp này, hệ thống sẽ xác định mọi thứ cho bạn. Bạn không phải lo lắng về việc thiết bị nào đang được sử dụng trong thời gian chạy. Bạn chỉ cần cung cấp các tài nguyên phù hợp và để Android thực hiện tất cả công việc.

Ghi chú

• Bạn có thể sử dụng các bí danh để tránh trùng lặp các tệp tài nguyên giống hệt nhau.

Tài liệu Android đáng đọc

• Hỗ trợ nhiều màn hình
• Hỗ trợ kích thước màn hình khác nhau
• Phân phối cho các màn hình cụ thể

Nếu bạn chỉ nhắm mục tiêu cấp API> = 13 thì hãy thử

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

chúc mừng :-)

Suy nghĩ về các thư mục được nhận "mới" (ví dụ giá trị-sw600dp) tôi đã tạo phương pháp này dựa trên chiều rộng DP của màn hình:

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

Và trong danh sách này, bạn có thể tìm thấy một số DP của các thiết bị và kích thước máy tính bảng phổ biến:

Wdp / Hdp

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

Wdp = Chiều rộng dp
Hdp = Chiều cao dp

Chà, giải pháp tốt nhất phù hợp với tôi khá đơn giản:

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

Được sử dụng như thế này:

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

Tôi thực sự không muốn nhìn vào kích thước pixel mà chỉ dựa vào kích thước màn hình.

Hoạt động tốt như Nexus 7 (LARGE) được phát hiện dưới dạng máy tính bảng, nhưng không phải Galaxy S3 (BÌNH THƯỜNG).

Sử dụng phương pháp này trả về giá trị true khi thiết bị là máy tính bảng

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

Nếu phát hiện kích thước màn hình không trả về giá trị chính xác trên các thiết bị mới hơn, hãy thử:

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

Đã thử nghiệm trên Android 4.2.2 (xin lỗi vì tiếng Anh của tôi.)

Tôi biết đây không phải là câu trả lời trực tiếp cho câu hỏi của bạn, nhưng những câu trả lời khác ở đây cho bạn ý tưởng tốt về cách xác định kích thước màn hình. Bạn đã viết trong câu hỏi của bạn rằng bạn có vấn đề với độ nghiêng và điều này cũng xảy ra với tôi.

Nếu bạn chạy con quay hồi chuyển (hoặc cảm biến xoay) trên điện thoại thông minh, trục x và y có thể được xác định khác so với trên máy tính bảng, theo hướng mặc định của thiết bị đó (ví dụ: Samsung GS2 là chân dung mặc định, Samsung GT-7310 là phong cảnh mặc định, Google Nexus 7 mới là chân dung mặc định, mặc dù nó là máy tính bảng!).

Bây giờ nếu bạn muốn sử dụng Con quay hồi chuyển, bạn có thể kết thúc với một giải pháp hoạt động cho điện thoại thông minh, nhưng nhầm lẫn trục trên một số máy tính bảng hoặc ngược lại.

Nếu bạn sử dụng một trong các giải pháp từ phía trên để chỉ sử dụng kích thước màn hình và sau đó áp dụng

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

để lật trục nếu nó có kích thước màn hình lớn hoặc xlộng, điều này có thể hoạt động trong 90% các trường hợp, nhưng ví dụ trên Nexus 7, nó sẽ gây ra sự cố (vì nó có hướng dọc mặc định và kích thước màn hình lớn).

Cách đơn giản nhất để khắc phục điều này được cung cấp trong RotationVectorSample đi kèm với các bản trình diễn API bằng cách đặt sceenOrientation thành nosensortrong bảng kê khai của bạn:

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

com.sec.feature.multiwindow.tablet trong trình quản lý gói chỉ dành riêng cho máy tính bảng và com.sec.feature.multiwindow.phone dành riêng cho điện thoại.

Phương pháp bên dưới là tính chiều dài đường chéo của màn hình thiết bị để quyết định thiết bị là điện thoại hoặc máy tính bảng. mối quan tâm duy nhất cho phương pháp này là giá trị ngưỡng nào để quyết định thời tiết thiết bị có phải là máy tính bảng hay không. trong ví dụ dưới đây tôi đặt nó là 7 inch trở lên.

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

Ngày càng khó khăn hơn để vẽ ranh giới giữa điện thoại và máy tính bảng. Chẳng hạn (kể từ tháng 8 năm 2015), thiết bị Samsung Mega 6.3 lấy tài nguyên từ các thư mục sw600dp - theo như Android có liên quan thì đó là một chiếc máy tính bảng.

Câu trả lời từ @Vyshnavi hoạt động trong tất cả các thiết bị chúng tôi đã thử nghiệm nhưng không dành cho Mega 6.3.

Câu trả lời @Helton Isac ở trên trả về Mega 6.3 dưới dạng điện thoại - nhưng vì thiết bị vẫn lấy tài nguyên từ sw600dp nên nó có thể gây ra các sự cố khác - ví dụ: nếu bạn sử dụng trình xem cho điện thoại chứ không phải cho máy tính bảng, bạn sẽ gặp phải lỗi NPE .

Cuối cùng, dường như có quá nhiều điều kiện để kiểm tra và chúng ta có thể phải chấp nhận rằng một số điện thoại thực sự là máy tính bảng :-P

Đây là phương pháp mà tôi sử dụng:

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

Sử dụng:

Cấu hình. SCREENLAYOUT_SIZE_MASK

Cấu hình. SCREENLAYOUT_SIZE_LARGE

Đây là phương pháp được khuyến khích!

Tại sao lại dùng cái này?

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

tôi thấy nhiều cách ở trên. Lớp cấu hình đã có câu trả lời đúng ngay bên dưới:

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

chỉ cần gọi:

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

được rồi?

Tôi chỉ cần phát hiện điện thoại thông minh / máy tính bảng trong tệp bố cục vì tôi đang sử dụng mã điều hướng.

Điều tôi đã làm trước tiên là tạo thư mục layout-sw600dp nhưng nó không hoạt động tốt vì nó sẽ kích hoạt trên Nokia 8 của tôi ở chế độ ngang, nhưng chiều cao màn hình sẽ quá nhỏ.

Vì vậy, tôi đã đổi tên thư mục là layout-sw600dp-h400dp và sau đó tôi nhận được hiệu ứng mong muốn. Tham số h-xxxdp nên phụ thuộc vào số lượng nội dung bạn muốn thả trên bố cục của bạn và do đó nên phụ thuộc vào ứng dụng.

Vui lòng kiểm tra mã dưới đây.

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

Tôi nghĩ rằng một máy tính bảng có chiều rộng và chiều cao tối thiểu 600 px,
vì vậy cần biết mật độ màn hình và chiều cao / chiều rộng tính bằng dp,
để lấy giá trị:

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;

Ví dụ: có một sự khác biệt quan trọng (ít nhất là đối với chương trình của tôi) giữa điện thoại và máy tính bảng. Đây là định hướng mặc định của thiết bị. Điện thoại có hướng dọc, máy tính bảng - phong cảnh. Và phương pháp tương ứng để xác định thiết bị:

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

EDITED: Sau các cuộc thảo luận với Dan Hulme đã thay đổi tên của phương pháp.

Tôi khuyên dùng thư viện Android 'caffeine' Có chứa điện thoại hoặc máy tính bảng và 10 inch ~!

sử dụng rất dễ dàng.

thư viện ở đây

https://github.com/ShakeJ/Android-Caffeine-l Library

Và sử dụng

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

Đối với tôi, sự khác biệt giữa điện thoại và máy tính bảng không phải là kích thước của thiết bị và / hoặc mật độ pixel, mà sẽ thay đổi theo công nghệ và hương vị, mà là tỷ lệ màn hình. Nếu tôi đang hiển thị màn hình văn bản, tôi cần biết nếu cần, 15 dòng dài là cần thiết (điện thoại) so với 20 dòng ngắn hơn (máy tính bảng). Đối với trò chơi của tôi, tôi sử dụng cách sau đây để ước tính sân bóng của hình chữ nhật mà phần mềm của tôi sẽ xử lý:

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

Tôi nghĩ rằng đây là cách dễ nhất để thành thật. Điều này sẽ kiểm tra kích thước màn hình đang được sử dụng:

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

May mắn nhất!