Apakah ada cara untuk memeriksa apakah pengguna menggunakan tablet atau telepon? Saya punya masalah dengan fungsi kemiringan dan tablet baru saya (Transformer)

Seperti yang telah disebutkan sebelumnya, Anda tidak ingin memeriksa apakah perangkat itu tablet atau ponsel tetapi Anda ingin tahu tentang fitur perangkat,

Sebagian besar waktu, perbedaan antara tablet dan telepon adalah ukuran layar yang mengapa Anda ingin menggunakan file tata letak yang berbeda. File-file ini disimpan dalam res/layout-<qualifiers>direktori. Anda dapat membuat file XML di directoy res/values-<same qualifiers>untuk setiap tata letak Anda dan memasukkan sumber daya int / bool / string ke dalamnya untuk membedakan antara tata letak yang Anda gunakan.

Contoh:

File res/values/screen.xml(dengan asumsi res/layout/berisi file layout Anda untuk handset)

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

File res/values-sw600dp/screen.xml(dengan asumsi res/layout-sw600dp/berisi file layout Anda untuk tablet kecil seperti Nexus 7)

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

File res/values-sw720dp/screen.xml(dengan asumsi res/layout-sw720dp/berisi file tata letak Anda untuk tablet besar seperti Nexus 10):

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

Sekarang tipe layar dapat diakses melalui R.string.screen_typekonstanta.

Untuk mendeteksi apakah perangkat itu tablet atau tidak, gunakan kode berikut:

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

Ukuran Layar LARGE dan XLARGE ditentukan oleh pabrikan berdasarkan jarak dari mata yang akan digunakan (dengan demikian gagasan tablet).

Info lebih lanjut: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

Posting ini banyak membantu saya,

Sayangnya saya tidak memiliki reputasi yang diperlukan untuk mengevaluasi semua jawaban yang membantu saya.

Saya perlu mengidentifikasi apakah perangkat saya adalah tablet atau telepon, dengan itu saya akan dapat menerapkan logika layar. Dan dalam analisis saya, tablet harus lebih dari 7 inci (Xlarge) mulai dari MDPI.

Berikut kode di bawah ini, yang dibuat berdasarkan posting ini.

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

Mengapa tidak menghitung ukuran layar diagonal dan menggunakannya untuk membuat keputusan apakah perangkat itu ponsel atau 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 );
}

Tentu saja orang dapat berdebat apakah ambang harus 9 inci atau kurang.

tidak ada perbedaan. Anda harus mendefinisikan apa yang menurut Anda bedanya, dan memeriksanya. Apakah galaksi tab telepon? atau tablet? dan mengapa?

Anda harus menentukan fitur spesifik apa yang Anda cari, dan kode untuk itu.

Sepertinya Anda mencari 'miring'. Saya pikir ini sama dengan accelerometer (apakah itu sebuah kata?). Anda hanya dapat memeriksa apakah perangkat mendukungnya, menggunakan:

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

(dari http://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . Saya belum mengujinya)

Asumsi saya adalah bahwa ketika Anda mendefinisikan 'Ponsel / Ponsel' Anda ingin tahu apakah Anda dapat melakukan panggilan telepon pada perangkat yang tidak dapat dilakukan pada sesuatu yang akan didefinisikan sebagai 'Tablet'. Cara memverifikasi ini ada di bawah. Jika Anda ingin mengetahui sesuatu berdasarkan sensor, ukuran layar, dll, maka ini benar-benar pertanyaan yang berbeda.

Selain itu, saat menggunakan resolusi layar, atau manajemen sumber daya besar vs xlarge, mungkin telah menjadi pendekatan yang valid di perangkat 'Mobile' baru yang lalu sekarang datang dengan layar besar dan resolusi tinggi sehingga mereka mengaburkan garis ini sementara jika Anda benar-benar ingin untuk mengetahui panggilan telepon vs tidak ada kemampuan panggilan telepon di bawah ini adalah 'terbaik'.

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

Berdasarkan Robert Dale Johnson III dan Helton Isac saya datang dengan kode ini Semoga ini bermanfaat

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

Jadi dalam kode Anda buat filter seperti

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

Dalam kode sumber aplikasi Google IOSched 2017 , metode berikut digunakan:

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

Bagi mereka yang ingin merujuk pada kode Google untuk memutuskan perangkat mana yang akan menggunakan UI Tablet dapat merujuk pada di bawah ini:

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

Metode ini direkomendasikan oleh Google. Saya melihat kode ini di Aplikasi Android Resmi Googleiosched

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

Tidak diperlukan kode

Jawaban lainnya mencantumkan banyak cara untuk menentukan secara terprogram apakah perangkat itu ponsel atau tablet. Namun, jika Anda membaca dokumentasinya , itu bukan cara yang disarankan untuk mendukung berbagai ukuran layar.

Sebaliknya, nyatakan sumber daya yang berbeda untuk tablet atau ponsel. Anda melakukan ini menambahkan folder sumber daya tambahan saya untuk layout, values, dll

• Untuk Android 3.2 (API level 13) aktif, tambahkan sw600dpfolder. Ini berarti satu s mallest w idth setidaknya 600dp, yang kira-kira membagi ponsel / tablet. Namun, Anda juga dapat menambahkan ukuran lain juga. Lihat jawaban ini untuk contoh tentang cara menambahkan file sumber daya tata letak tambahan.

• Jika Anda juga mendukung perangkat Android 3.2 sebelumnya, maka Anda perlu menambahkan largeatau xlargefolder untuk mendukung tablet. (Ponsel pada umumnya smalldan normal.)

Berikut adalah gambar dari apa yang mungkin disukai sumber daya Anda setelah menambahkan file xml tambahan untuk ukuran layar yang berbeda.

Saat menggunakan metode ini, sistem menentukan segalanya untuk Anda. Anda tidak perlu khawatir tentang perangkat mana yang digunakan pada saat dijalankan. Anda hanya menyediakan sumber daya yang sesuai dan membiarkan Android melakukan semua pekerjaan.

Catatan

• Anda dapat menggunakan alias untuk menghindari duplikasi file sumber daya yang identik.

Dokumen Android layak dibaca

• Mendukung Banyak Layar
• Mendukung Ukuran Layar Yang Berbeda
• Mendistribusikan ke Layar Tertentu

Jika Anda hanya menargetkan level API> = 13 maka cobalah

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

Bersulang :-)

Memikirkan direktori yang diterima "baru" (nilai-sw600dp misalnya) saya membuat metode ini berdasarkan lebar DP layar:

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

Dan pada daftar ini Anda dapat menemukan beberapa DP perangkat populer dan ukuran tablet:

Wdp / Hdp

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

Wdp = Lebar dp
Hdp = Tinggi dp

Nah, solusi terbaik yang bekerja untuk saya cukup sederhana:

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

Digunakan seperti ini:

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

Saya benar-benar tidak ingin melihat ukuran piksel tetapi hanya mengandalkan ukuran layar.

Berfungsi sebaik Nexus 7 (LARGE) terdeteksi sebagai tablet, tetapi bukan Galaxy S3 (NORMAL).

Gunakan metode ini yang mengembalikan true ketika perangkat adalah tablet

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

Jika deteksi ukuran layar tidak mengembalikan nilai yang benar pada perangkat yang lebih baru, cobalah:

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

Diuji pada Android 4.2.2 (maaf untuk bahasa Inggris saya.)

Saya tahu ini bukan jawaban langsung untuk pertanyaan Anda, tetapi jawaban lain di sini memberikan ide bagus tentang cara mengidentifikasi ukuran layar. Anda menulis dalam pertanyaan Anda bahwa Anda punya masalah dengan memiringkan dan ini baru saja terjadi pada saya juga.

Jika Anda menjalankan giroskop (atau sensor rotasi) pada smartphone, sumbu x dan y dapat ditentukan secara berbeda dari pada tablet, sesuai dengan orientasi default perangkat tersebut (mis. Samsung GS2 adalah potret default, Samsung GT-7310 adalah lansekap default, Google Nexus 7 baru adalah potret default, meskipun itu tablet!).

Sekarang jika Anda ingin menggunakan Giroskop Anda mungkin berakhir dengan solusi yang berfungsi untuk smartphone, tetapi kebingungan sumbu pada beberapa tablet atau sebaliknya.

Jika Anda menggunakan salah satu solusi dari atas untuk hanya pergi untuk ukuran layar dan kemudian berlaku

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

untuk membalik poros jika memiliki ukuran layar besar atau xlarge ini mungkin bekerja di 90% dari kasus tetapi misalnya pada Nexus 7 itu akan menyebabkan masalah (karena memiliki orientasi potret default dan ukuran layar besar).

Cara paling sederhana untuk memperbaikinya disediakan dalam RotationVectorSample yang dikirimkan dengan demo API dengan mengatur sceenOrientation ke nosensordalam manifes Anda:

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

com.sec.feature.multiwindow.tablet di manajer paket hanya khusus untuk tablet dan com.sec.feature.multiwindow.phone khusus untuk ponsel.

metode di bawah ini menghitung panjang diagonal layar perangkat untuk memutuskan perangkat adalah ponsel atau tablet. satu-satunya perhatian untuk metode ini adalah berapa nilai ambang untuk memutuskan apakah perangkat tablet atau tidak. pada contoh di bawah ini saya atur 7 inch ke atas.

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

Semakin sulit untuk menarik garis antara ponsel dan tablet. Misalnya (per Agustus 2015) Samsung Mega 6.3 menarik sumber daya dari folder sw600dp - sejauh yang menyangkut Android itu adalah tablet.

Jawaban dari @Vyshnavi berfungsi di semua perangkat yang telah kami uji tetapi tidak untuk Mega 6.3.

@Helton Isac menjawab di atas mengembalikan Mega 6.3 sebagai telepon - tetapi karena perangkat masih mengambil sumber daya dari sw600dp dapat menyebabkan masalah lain - misalnya jika Anda menggunakan viewpager untuk ponsel dan bukan untuk tablet Anda akan berakhir dengan kesalahan NPE .

Pada akhirnya sepertinya ada terlalu banyak kondisi untuk diperiksa dan kami mungkin hanya harus menerima bahwa beberapa ponsel sebenarnya adalah tablet :-P

Ini adalah metode yang saya gunakan:

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

Menggunakan:

Konfigurasi. SCREENLAYOUT_SIZE_MASK

Konfigurasi. SCREENLAYOUT_SIZE_LARGE

Ini adalah metode yang direkomendasikan!

mengapa menggunakan ini?

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

Saya melihat banyak cara di atas. Kelas konfigurasi telah mendapatkan jawaban yang benar di bawah ini:

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

panggil saja:

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

tidak apa-apa?

Saya perlu mendeteksi smartphone / tablet hanya dalam file tata letak, karena saya menggunakan kode navigasi.

Apa yang saya lakukan pertama adalah membuat direktori layout-sw600dp tetapi tidak berfungsi dengan baik karena akan diaktifkan pada Nokia 8 saya dalam mode lansekap, tetapi ketinggian layar akan terlalu kecil.

Jadi, saya mengganti nama direktori menjadi layout-sw600dp-h400dp dan kemudian saya mendapatkan efek yang diinginkan. Parameter h-xxxdp harus bergantung pada seberapa banyak konten yang ingin Anda lepas pada tata letak Anda dan karenanya harus bergantung pada aplikasi.

Silakan periksa kode di bawah ini.

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

Saya pikir tablet memiliki lebar dan tinggi minimum 600 px,
jadi perlu tahu kepadatan layar dan tinggi / lebar dalam dp,
untuk mengambil nilainya:

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;

Misalnya ada satu perbedaan penting (setidaknya untuk program saya) antara ponsel dan tablet. Ini adalah orientasi standar perangkat. Ponsel memiliki orientasi potret, tablet - landscape. Dan masing-masing metode untuk menentukan perangkat:

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

Diedit: Setelah diskusi dengan Dan Hulme mengubah nama metode.

Saya merekomendasikan perpustakaan Android 'kafein' Itu mengandung get Phone atau tablet, dan 10inch ~!

sangat mudah digunakan.

perpustakaan ada di sini.

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

dan gunakan

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

Bagi saya perbedaan antara ponsel dan tablet bukan ukuran perangkat dan / atau kerapatan piksel, yang akan berubah dengan teknologi dan rasanya, melainkan rasio layar. Jika saya menampilkan layar teks saya perlu tahu jika, katakanlah, 15 baris panjang diperlukan (telepon) vs 20 baris lebih pendek (tablet). Untuk permainan saya, saya menggunakan yang berikut ini untuk perkiraan rata-rata persegi panjang yang akan ditangani oleh perangkat lunak saya:

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

Saya pikir ini adalah cara termudah untuk jujur. Ini akan memeriksa ukuran layar yang digunakan:

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

Semoga berhasil!