Deteksi tablet 7 inci dan 10 inci secara terprogram

94

Adakah cara untuk menemukan secara terprogram apakah perangkat tempat aplikasi dipasang adalah tablet 7 inci atau tablet 10 inci?

android  android-layout  screen 
— Calon
sumber
Sebagai Contoh: layout-sw600dp mencari ukuran lebar terkecil 600dp.
— Rookie
Saya mengerti itu, tapi apa yang Anda cari secara terprogram?
— Geobits
Saya perlu mengambil perangkat ini secara terprogram..karena ada beberapa properti yang tidak dapat saya definisikan di xml..properti itu didefinisikan dalam kode itu sendiri .. jadi jika saya hanya meletakkan kode, itu akan berlaku untuk semua perangkat..tetapi Saya tidak ingin itu ..
— Rookie
@Raghav sudahkah Anda mencoba dengan matriks tampilan untuk mendapatkan ukuran layar dan kemudian Anda dapat membandingkan. Meskipun ini bukan cara yang bersih tetapi Anda bisa menggunakannya.
— PiyushMishra
Anda bisa mendapatkan dimensi layar dan berolahraga dari sana ... stackoverflow.com/questions/1016896/…
— Raj

Jawaban:

234

Anda dapat menggunakan DisplayMetricsuntuk mendapatkan banyak informasi tentang layar tempat aplikasi Anda berjalan.

Pertama, kami membuat DisplayMetricsobjek metrik:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Dari sini, kita bisa mendapatkan informasi yang dibutuhkan untuk mengukur tampilan:

int widthPixels = metrics.widthPixels;
int heightPixels = metrics.heightPixels;

Ini akan mengembalikan nilai absolut dari lebar dan tinggi dalam piksel, jadi 1280x720 untuk Galaxy SIII, Galaxy Nexus, dll.

Ini biasanya tidak membantu dengan sendirinya, karena saat kami bekerja pada perangkat Android, kami biasanya lebih suka bekerja dalam piksel kepadatan independen, celupkan.

Anda mendapatkan densitylayar menggunakan metricslagi, dalam bentuk faktor skala untuk perangkat, yang didasarkan pada Sumber Daya Desain Android untuk mdpi, hdpidll. Skala DPI

float scaleFactor = metrics.density;

Dari hasil ini, kita dapat menghitung jumlah piksel independen kepadatan yang ada untuk tinggi atau lebar tertentu. 

float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor

Hasil yang Anda peroleh dari ini akan membantu Anda memutuskan jenis layar yang Anda gunakan dalam hubungannya dengan contoh Konfigurasi Android , yang memberi Anda dp relatif untuk setiap ukuran layar:

  • 320dp: layar ponsel biasa (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, dll).
  • 480dp: tablet tweener seperti Streak (480x800 mdpi).
  • 600dp: tablet 7 inci (600x1024 mdpi).
  • 720dp: tablet 10 inci (720x1280 mdpi, 800x1280 mdpi, dll).

Menggunakan informasi di atas, kita tahu bahwa jika lebar terkecil perangkat lebih besar dari 600dp, perangkat tersebut adalah tablet 7 ", jika lebih besar dari 720dp, perangkat tersebut adalah tablet 10".

Kita bisa menghitung lebar terkecil menggunakan minfungsi Mathclass, meneruskan heightDpdan widthDpuntuk mengembalikan smallestWidth.

float smallestWidth = Math.min(widthDp, heightDp);

if (smallestWidth > 720) {
    //Device is a 10" tablet
} 
else if (smallestWidth > 600) {
    //Device is a 7" tablet
}

Namun, ini tidak selalu memberi Anda kecocokan persis, terutama saat bekerja dengan tablet yang tidak dikenal yang mungkin salah merepresentasikan kepadatannya sebagai hdpi padahal sebenarnya bukan, atau yang mungkin hanya 800 x 480 piksel namun masih pada layar 7 " .

Lebih jauh ke metode ini, jika Anda perlu mengetahui dimensi perangkat yang tepat dalam inci, Anda dapat mengetahuinya juga, menggunakan metricsmetode berapa banyak piksel yang ada per inci layar.

float widthDpi = metrics.xdpi;
float heightDpi = metrics.ydpi;

Anda dapat menggunakan pengetahuan tentang berapa banyak piksel dalam setiap inci perangkat dan jumlah total piksel untuk menentukan berapa inci perangkat tersebut.

float widthInches = widthPixels / widthDpi;
float heightInches = heightPixels / heightDpi;

Ini akan mengembalikan tinggi dan lebar perangkat dalam inci. Ini sekali lagi tidak selalu membantu untuk menentukan jenis perangkat itu, karena ukuran perangkat yang diiklankan adalah diagonal, yang kami miliki hanyalah tinggi dan lebarnya.

Namun, kita juga tahu bahwa mengingat tinggi segitiga dan lebarnya, kita dapat menggunakan teorema Pythagoras untuk menghitung panjang hipotenusa (Dalam hal ini, ukuran layar diagonal).

//a² + b² = c²

//The size of the diagonal in inches is equal to the square root of the height in inches squared plus the width in inches squared.
double diagonalInches = Math.sqrt(
    (widthInches * widthInches) 
    + (heightInches * heightInches));

Dari sini, kita dapat mengetahui apakah perangkat itu tablet atau bukan:

if (diagonalInches >= 10) {
    //Device is a 10" tablet
} 
else if (diagonalInches >= 7) {
    //Device is a 7" tablet
}

Dan begitulah cara Anda menghitung jenis perangkat yang Anda gunakan.

— Sean O'Toole
sumber
3
Kiat bagus Sean. Saya biasa memeriksa dengan px untuk tablet, tetapi dalam beberapa kasus ada masalah (Galaxy 3, 4, Note, memiliki piksel yang sama atau lebih besar dari Nexus 7). Sekarang saya juga bisa memeriksa inci. Berikut adalah daftar dari banyak spesifikasi layar perangkat populer: en.wikipedia.org/wiki/List_of_displays_by_pixel_density
— Pelanes
8
Jangan gunakan xdpi atau ydpi. Ini opsional dan akan ditetapkan oleh pabrikan, tidak dihitung. Mereka sering kali tidak digunakan atau tidak akurat.
— sturrockad
2
Menggunakan metode Anda untuk mendapatkan lebar dalam dpi, saya mendapatkan hasil yang berbeda tergantung pada orientasinya. misalnya untuk Nexus 7: POTRET: tinyWidth = 600.9; LANDSCAPE: SmallWidth = 552,8; Apa alasan untuk itu?
— Christopher Masser
3
Logikanya if (smallestWidth > 600) { /* 7" */ } else if (smallestWidth > 720) { /* 10" */ }salah: 10 "tablet dikenali sebagai 7". Saya mengambil kebebasan untuk memperbaikinya.
— Jonik
21
Akhirnya saya melanjutkan resources.getConfiguration().smallestScreenWidthDpdari jawaban DeeV yang merupakan satu-satunya metode yang memberikan nilai yang sama baik dalam potret maupun lanskap pada Nexus 7 saya (600dp). Itu ditambahkan di API level 13.
— Jonik
32

Tidak ada yang mengatakan 7"atau 10"AFAIK. Ada sekitar dua cara untuk mendapatkan dimensi layar yang digunakan sistem saat mendekode bitmap dan yang lainnya. Keduanya ditemukan di objek aplikasi yang Resourcesditemukan di Context.

Yang pertama adalah Configurationbenda yang bisa diperoleh getContext().getResources().getConfiguration(). Di dalamnya Anda memiliki:

Configuration#densityDpi - Kepadatan layar target yang sedang dirender, sesuai dengan qualifier sumber daya kepadatan.

Configuration#screenHeightDp - Ketinggian saat ini dari ruang layar yang tersedia, dalam unit dp, sesuai dengan kualifikasi sumber daya tinggi layar.

Configuration#screenWidthDp - Lebar saat ini dari ruang layar yang tersedia, dalam satuan dp, sesuai dengan kualifikasi sumber daya lebar layar.

Configuration#smallestScreenWidthDp - Ukuran layar terkecil yang akan dilihat aplikasi dalam operasi normal, sesuai dengan qualifier sumber daya lebar layar terkecil.

Dengan itu, Anda dapat cukup banyak menggunakan pedoman layar untuk mencari tahu apakah perangkat Anda menarik dari folder sumber daya khusus masing-masing ( hdpi, xhdpi, large, xlarge, dll).

Ingat, ini adalah beberapa ember:

  • Layar xlarge setidaknya 960dp x 720dp
  • layar besar setidaknya 640dp x 480dp
  • layar normal setidaknya 470dp x 320dp

  • layar kecil setidaknya 426dp x 320dp

  • 320dp: layar ponsel biasa (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, dll).

  • 480dp: tablet tweener seperti Streak (480x800 mdpi).
  • 600dp: tablet 7 inci (600x1024 mdpi).
  • 720dp: tablet 10 inci (720x1280 mdpi, 800x1280 mdpi, dll).

Info lebih lanjut

Yang kedua adalah DisplayMetricsbenda yang diperoleh getContext().getResources().getDisplayMetrics(). Dalam hal itu Anda memiliki:

DisplayMetrics#density - Kepadatan logis layar.

DisplayMetrics#densityDpi - Kepadatan layar dinyatakan sebagai titik per inci.

DisplayMetrics#heightPixels - Tinggi absolut tampilan dalam piksel.

DisplayMetrics#widthPixels - Lebar absolut tampilan dalam piksel.

DisplayMetrics#xdpi - Piksel fisik yang tepat per inci dari layar dalam dimensi X.

DisplayMetrics#ydpi - Piksel fisik per inci yang tepat dari layar dalam dimensi Y.

Ini berguna jika Anda membutuhkan jumlah piksel layar yang tepat, bukan kepadatan. Namun, penting untuk dicatat bahwa ini semua adalah piksel layar. Tidak hanya yang tersedia untuk Anda.

— DeeV
sumber
4
+1, Saya mendapatkan hasil terbaik dengan smallestScreenWidthDp. Berbeda dengan solusi lain, ini memberikan nilai yang sama pada Nexus 7 saya (600dp) terlepas dari orientasinya . Sebagai bonus, ini juga merupakan kode paling sederhana!
— Jonik
1
Saya rasa ini terus menjadi cara terbaik karena harus cocok dengan notasi sw ??? dp pada jalur sumber daya. Konsistensi itu penting.
— lilbyrdie
13

tempatkan metode ini di onResume () dan dapat diperiksa.

public double tabletSize() {

     double size = 0;
        try {

            // Compute screen size

            DisplayMetrics dm = context.getResources().getDisplayMetrics();

            float screenWidth  = dm.widthPixels / dm.xdpi;

            float screenHeight = dm.heightPixels / dm.ydpi;

            size = Math.sqrt(Math.pow(screenWidth, 2) +

                                 Math.pow(screenHeight, 2));

        } catch(Throwable t) {

        }

        return size;

    }

umumnya tablet dimulai setelah ukuran 6 inci.

— PiyushMishra
sumber
8

Hal di atas tidak selalu berfungsi saat beralih potret vs. lanskap.

Jika Anda menargetkan API level 13+, semudah yang dijelaskan di atas - gunakan Configuration.smallestScreenWidthDp, lalu uji sesuai:

resources.getConfiguration().smallestScreenWidthDp

Jika tidak, jika Anda mampu membelinya, gunakan metode berikut yang merupakan pendekatan yang sangat akurat untuk mendeteksi 600dp (seperti 6 ") vs. 720dp (seperti 10") dengan membiarkan sistem memberi tahu Anda:

1) Tambahkan ke layout-sw600dp dan layout-sw720dp (dan jika ada, lanskapnya) tampilan yang tidak terlihat dengan ID yang sesuai, misalnya:

Untuk 720, pada layout-sw720dp: 

<View android:id="@+id/sw720" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

Untuk 600, pada layout-sw600dp:

<View android:id="@+id/sw600" android:layout_width="0dp" android:layout_height="0dp" android:visibility="gone"/>

2) Kemudian pada kode, misalnya, Aktivitas, uji sesuai:

private void showFragment() {
    View v600 = (View) findViewById(R.id.sw600);
    View v720 = (View) findViewById(R.id.sw720);
    if (v600 != null || v720 !=null)
        albumFrag = AlbumGridViewFragment.newInstance(albumRefresh);
    else
        albumFrag = AlbumListViewFragment.newInstance(albumRefresh);
    getSupportFragmentManager()
        .beginTransaction()
        .replace(R.id.view_container, albumFrag)
        .setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
        .commit();
}
— CEO
sumber
4
Anda tidak perlu membuat tata letak terpisah, saya yakin Anda hanya dapat memiliki strings.xml terpisah berdasarkan ukuran, dengan memiliki folder nilai yang berbeda, seperti values-sw600dp, dll. Memiliki string yang ditentukan <string name = 'screensize' > 600dp </ string> di folder sw600dp, dll. Bahkan tidak harus berupa string, bisa juga di ints.xml atau dimens.xml.
— ajacian81
7

Informasi hebat, hanya apa yang saya cari! Namun, setelah mencoba ini, saya menemukan bahwa saat menggunakan metrik yang disebutkan di sini, Nexus 7 (model 2012) melaporkan memiliki dimensi 1280x736. Saya juga memiliki Motorola Xoom yang menjalankan Jelly Bean dan salah melaporkan resolusi 1280x752. Saya menemukan posting ini di sini yang menegaskan ini. Pada dasarnya, di ICS / JB penghitungan menggunakan metrik yang disebutkan di atas tampaknya mengecualikan dimensi Bilah Navigasi. Beberapa penelitian lebih lanjut membawa saya pada jawaban Frank Nguyen di sini yang menggunakan metode berbeda yang akan memberi Anda dimensi piksel mentah (atau nyata) dari layar. Pengujian awal saya telah menunjukkan bahwa kode berikut dari koreksi Frank melaporkan dimensi pada Nexus 7 (model 2012 runnin JB) dan Motorola Xoom saya menjalankan JB:

int width = 0, height = 0;
final DisplayMetrics metrics = new DisplayMetrics();
Display display = getWindowManager().getDefaultDisplay();
Method mGetRawH = null, mGetRawW = null;

try {
    // For JellyBeans and onward
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
        display.getRealMetrics(metrics);

        width = metrics.widthPixels;
        height = metrics.heightPixels;
    } else {
        mGetRawH = Display.class.getMethod("getRawHeight");
        mGetRawW = Display.class.getMethod("getRawWidth");

        try {
            width = (Integer) mGetRawW.invoke(display);
            height = (Integer) mGetRawH.invoke(display);
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
} catch (NoSuchMethodException e3) {
    e3.printStackTrace();
}
— Jason
sumber
3

Saya memiliki dua perangkat android dengan resolusi yang sama

Perangkat1 -> resolusi ukuran layar diagonal 480x800 -> 4,7 inci

Device2 -> resolusi ukuran layar diagonal 480x800 -> 4,0 inci

Ini memberi kedua ukuran layar diagonal perangkat -> 5,8

solusi untuk masalahmu adalah ..

DisplayMetrics dm = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(dm);
int width=dm.widthPixels;
int height=dm.heightPixels;
int dens=dm.densityDpi;
double wi=(double)width/(double)dens;
double hi=(double)height/(double)dens;
double x = Math.pow(wi,2);
double y = Math.pow(hi,2);
double screenInches = Math.sqrt(x+y);

lihat detailnya di sini ..

— AndroidGeek
sumber
2

Cara Android menentukan ukuran layar adalah melalui empat ukuran umum: kecil , normal , besar , dan xlarge .

Sedangkan dokumentasi Android menyatakan bahwa kelompok ukuran tidak digunakan lagi

... grup ukuran ini tidak digunakan lagi karena mendukung teknik baru untuk mengelola ukuran layar berdasarkan lebar layar yang tersedia. Jika Anda mengembangkan untuk Android 3.2 dan yang lebih baru, lihat [Menyatakan Tata Letak Tablet untuk Android 3.2] (hdpi (tinggi) ~ 240dpi) untuk informasi selengkapnya.

Umumnya penentu ukuran besar menentukan tablet 7 ". Dan penentu ukuran xlarge menentukan tablet 10":

masukkan deskripsi gambar di sini

Hal yang menyenangkan tentang memicu pada pengualifikasi ukuran, adalah Anda dapat menjamin bahwa aset dan kode Anda sesuai dengan aset mana yang akan digunakan atau jalur kode yang akan diaktifkan.

Untuk mengambil pengualifikasi ukuran dalam kode, lakukan panggilan berikut:

int sizeLarge = SCREENLAYOUT_SIZE_LARGE // For 7" tablet
boolean is7InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeLarge);

int sizeXLarge = SCREENLAYOUT_SIZE_XLARGE // For 10" tablet
boolean is10InchTablet = context.getResources().getConfiguration()
    .isLayoutSizeAtLeast(sizeXLarge);
— Benjamin
sumber
2

Anda dapat menggunakan metode di bawah ini untuk mendapatkan ukuran layar dalam inci, berdasarkan itu Anda dapat memeriksa tablet atau ponsel mana perangkat tersebut.

private static double checkDimension(Context context) {

    WindowManager windowManager = ((Activity)context).getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);

    // since SDK_INT = 1;
    int mWidthPixels = displayMetrics.widthPixels;
    int mHeightPixels = displayMetrics.heightPixels;

    // includes window decorations (statusbar bar/menu bar)
    try
    {
        Point realSize = new Point();
        Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize);
        mWidthPixels = realSize.x;
        mHeightPixels = realSize.y;
    }
    catch (Exception ignored) {}

    DisplayMetrics dm = new DisplayMetrics();
    windowManager.getDefaultDisplay().getMetrics(dm);
    double x = Math.pow(mWidthPixels/dm.xdpi,2);
    double y = Math.pow(mHeightPixels/dm.ydpi,2);
    double screenInches = Math.sqrt(x+y);
    Log.d("debug","Screen inches : " + screenInches);
    return screenInches;
}
— Ashish Rajvanshi
sumber
2

Saya menyimpan nilai dalam folder nilai yang memberi saya layar 7 inci atau 10 inci tetapi kami dapat melakukannya untuk perangkat apa pun menggunakan folder nilai.

seperti membuat folder nilai-2 yang berbeda untuk 2 perangkat yang berbeda. Tapi hal ini tergantung kebutuhan.

— sharma_kunal
sumber
1

Anda harus melakukan sedikit komputasi menggunakan data yang diberikan oleh kelas DisplayMetrics .

Anda memiliki heightPixel dan widthPixels (resolusi layar dalam piksel)

Anda memerlukan diagonal karena 'ukuran layar inci' selalu menggambarkan panjang diagonal. Anda bisa mendapatkan layar diagonal dalam piksel (menggunakan pythagore)

diagonalPixel = √ (heightPixel² + widthPixels²)

maka Anda dapat mengubah nilai piksel menjadi inci berkat nilai densityDPI:

inchDiag = diagonalPixel / densityDPI.

Saya harap saya tidak membuat kesalahan di sini, ketahuilah bahwa nilai yang Anda peroleh dari kelas DisplayMetrics diberikan oleh konstruktor, tampaknya (dalam kasus yang sangat jarang) tidak diatur dengan baik sesuai dengan materi fisik ...

Ini akan memberi Anda ukuran layar fisik tetapi mungkin ini bukan cara yang lebih baik untuk mengelola banyak tata letak. Lebih lanjut tentang topik ini

— Guian
sumber
1

Cara lain:

  • Buat 2 folder lagi: values-large + values-xlarge

  • Letakkan: <string name="screentype">LARGE</string>di folder besar nilai (strings.xml)

  • Letakkan: <string name="screentype">XLARGE</string>di folder values-xlarge (strings.xml)

  • Dalam kode:

    String mType = getString (R.string.screentype);

    if (mType! = null && mType.equals ("BESAR") {

    // dari 4 ~ 7 inci

    } lain jika (mType! = null && mType.equals ("XLARGE") {

    // dari 7 ~ 10 inci

    }

— Frank Nguyen
sumber
1

Voila! 😀 Hanya ini yang Anda perlukan untuk membedakan tablet dari ponsel

1. Fungsi pembantu untuk mendapatkan lebar layar:

private float getScreenWidth() {
    DisplayMetrics metrics = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(metrics);
    return Math.min(metrics.widthPixels, metrics.heightPixels) / metrics.density;
}

2. Berfungsi untuk mengetahui apakah suatu perangkat adalah tablet

boolean isTablet() {
    return getScreenWidth() >= 600;
}

3. Terakhir, jika Anda ingin melakukan operasi yang berbeda untuk ukuran perangkat yang berbeda:

boolean is7InchTablet() {
    return getScreenWidth() >= 600 && getScreenWidth() < 720;
}

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}
— Sagar
sumber
0

Berikut beberapa ekstensi kotlin yang berguna:


    fun DisplayMetrics.isTablet(): Boolean {
        return screenWith() >= 600
    }

    fun DisplayMetrics.is7InchTablet(): Boolean {
        return screenWith() >= 600 && screenWith() < 720
    }

    fun DisplayMetrics.is10InchTablet(): Boolean {
        return screenWith() >= 720
    }

    fun DisplayMetrics.screenWith(): Float {
        return widthPixels.coerceAtMost(heightPixels) / density
    }
— Danimate
sumber
Itu bekerja! Tetapi Anda harus menggunakan DisplayMetrics yang tepat, misalnya dari Resourcesdalam Context: resources.displayMetrics.isTablet() atau dari WindowManageryang disimpan di Activity: val displayMetrics = DisplayMetrics() windowManager.defaultDisplay.getMetrics(displayMetrics) displayMetrics.isTablet()
— Akbolat SSS
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.