Tablet atau Telepon - Android

140

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

Benny
sumber
26
Anda mengajukan pertanyaan yang salah. Tidak masalah apakah perangkat itu telepon, tablet, televisi, pemanggang roti, cangkir teh, atau termometer. Yang penting adalah kemampuan, bukan kelas perangkat yang ditentukan pemasaran. Silakan tanyakan pertanyaan Android baru yang menjelaskan kemampuan apa yang Anda cari dan bagaimana mendeteksi apakah perangkat memiliki kemampuan seperti itu, atau bagaimana menyaring diri Anda keluar dari Pasar untuk perangkat yang tidak memiliki kemampuan seperti itu.
CommonsWare
7
@CommonsWare: beberapa kali Anda ingin menambahkan fitur tambahan untuk perangkat yang memiliki layar lebih besar.
Bobs
10
@breceivemail: Yang berarti Anda perlu memeriksa apakah perangkat memiliki layar yang lebih besar. "Layar lebih besar"! = "Tablet".
CommonsWare
2
Jawaban yang lebih baik dapat ditemukan di sini: stackoverflow.com/a/9308284/1750829 Sesederhana itu :-)
Atau Kazaz
3
Saya ingin menghapus seluruh halaman ini! Telepon memang telepon, tablet tidak. Hampir semua saran adalah hack kotor yang tidak boleh digunakan siapa pun. Dunia akan menjadi tempat yang lebih baik jika tidak ada yang melihat halaman ini lagi!
Mark Gjøl

Jawaban:

122

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.

John
sumber
4
+1, jawaban yang bagus karena memberikan lebih banyak wawasan mengapa Anda sebenarnya ingin memeriksa tablet / telepon. Kami mendekati momen di mana ponsel akan menjadi tablet kecil pula;)
andr
Bagaimana ini berlaku untuk ponsel besar, seperti Galaxy Note dan Nexus 6 baru? Dengan menggunakan teknik ini, akankah perangkat besar ini terdeteksi sebagai ponsel atau tablet?
PerracoLabs
1
Sayangnya, apporach ini tidak berfungsi untuk perangkat Samsung Mega 6.3 dan mengembalikannya sebagai tablet (sw600dp) - ada ide lain untuk menangkap ini?
bkurzius
apakah tablet membuat panggilan telepon?
Mike
61

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

petey
sumber
Pada keduanya - Kindle Fire dan Motorola Droid Bionic - SCREENLAYOUT_SIZE_MASK == 15. Jadi mengapa solusi Anda bekerja?
IgorGanapolsky
Saya percaya, ini hasilnya benar di Kindle Fire. Saya tidak punya bionik pada saya hari ini ... tetapi saya akan memeriksa beberapa hari ketika teman saya kembali ke kota. Namun ..... Saya sudah menguji jawaban Helton Isac dan itu berfungsi dengan baik. Silakan periksa juga.
petey
4
Ada Configuration.SCREENLAYOUT_SIZE_XLARGE, jadi Anda tidak harus menggunakan konstanta, dan Anda bisa menggunakannya >= LARGE.
Triang3l
2
Galaxy Note tampaknya melaporkan SCREENLAYOUT_SIZE_LARGE sehingga akan salah diklasifikasikan sebagai tablet
miguelSantirso
1
Jika font perangkat kecil dan ukuran tampilan kecil dalam pengaturan, case ini dikembalikan true.
arul
38

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;
}
Helton Isac
sumber
2
Solusi terbaik yang saya temukan, terima kasih Helton Isac! Mungkin Anda dapat menambahkan (untuk solusi yang lebih baik) cek untuk inci layar? bagaimanapun, 10 untuk solusi ini
Aracem
7
Saya sangat tidak setuju. Ini adalah metode untuk menemukan ukuran layar tertentu. Sekali lagi, seperti yang saya jawab, TIDAK ADA perbedaan antara tablet dan telepon. Ini bukan jawaban untuk pertanyaan itu. Tidak mungkin untuk membedakan karena tidak ada 1 perbedaan. Jika Anda perlu kode untuk fitur tertentu (seperti yang tampaknya Anda lakukan untuk ukuran layar tertentu), maka lakukan, tetapi jangan menyebutnya tablet vs ponsel. Starter topik tampaknya menempatkan garis @ fungsionalitas tilt tertentu. Baca komentar @commonware tentang pertanyaan itu.
Nanne
1
Saya setuju dengan Nanne, tetapi seperti yang saya katakan, dalam Aplikasi saya, saya perlu menunjukkan dua panel jika layarnya cukup besar untuk melakukannya. Dan saya tidak dapat menggunakan tata letak dalam hal ini, karena logika layar berada di sisi Java.
Helton Isac
3
Helton, terima kasih untuk ini. Kupikir aku akan mengatakan ini kembali: Kindle Fire: false, Moto Xoom (v1): true, Galaxy Note: false, Galaxy Tab 10.1 terbatas: true
petey
Selain argumen, Configuration.SCREENLAYOUT_SIZE_XLARGE = 4 menurut developer.android.com/reference/android/content/res/… yang dapat digunakan sebagai gantinya untuk level API kurang dari 9.
trgraglia
12

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.

Volker Voecking
sumber
Ini tidak berfungsi ... beberapa telepon melaporkan nilai kerapatan yang salah dan perhitungan dalam inci gagal - lihat di sana: stackoverflow.com/questions/2193457/…
STeN
Ya, saya suka tablet 7 '(ukuran saku) dan jawaban ini adalah yang terbaik menurut saya. Tetapi kembali (screenDiagonal> = 9.0); harus dikembalikan (screenDiagonal> = 6.5). Namun tergantung pada penggunaan seperti di komentar di komentar untuk pertanyaan.
Jan Bergström
11

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)

Nanne
sumber
Saya punya masalah dengan fungsi kemiringan dan tablet baru saya (Transformer)
Benny
Semacam jawaban konyol imo - tentu saja ada perbedaan. Galaxy = telepon. Mengapa? Karena itu adalah "smartphone" menurut produsen untuk satu. Jika Anda mengisyaratkan bahwa dia perlu memeriksa ukuran, atau kemampuan untuk menelepon, atau ... apa saja - katakan saja.
Dave
3
Saya tidak setuju, ini mungkin tidak berfungsi untuk semua ponsel, sementara beberapa tablet memang memiliki sensor ini. Itu sebabnya jawaban awal saya tentang tidak ada perbedaan. Bagaimanapun, saya telah menambahkan beberapa kode yang harus Anda coba.
Nanne
2
Masalahnya adalah, bahwa karena tablet "membangun" dalam mode lansekap, sumbu x dan y dari accelerometer diputar ketika Anda mengharapkan aplikasi Anda berjalan dalam mode potret. Ini dapat mengacaukan segalanya :) Jadi, sangat penting bagi Anda memeriksa cuaca apakah Anda menggunakan tablet atau tidak.
pumpkee
1
Tapi kemudian sebaliknya => jika itu adalah satu-satunya hal yang membuat perangkat tablet, Anda harus mencari tahu bagaimana sumbu x / y bekerja, bukan sebaliknya. Saya ragu dengan cara apakah ini berlaku untuk semua tablet dan / atau telepon?
Nanne
10

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";
}
Robert Dale Johnson III
sumber
9
Beberapa tablet dapat ponsel dan memiliki tipe GSM atau CDMA ... Jadi solusi Anda juga tidak sempurna.
arnouf
6

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
}
Cjames
sumber
5

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

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

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;
        }
        }
Pier Betos
sumber
2
apa nilainya shortSize?
kc ochibili
3

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;
}
hqt
sumber
Solusi ini misalnya tidak bekerja pada Emulator dengan API 18 dan Nexus 7 1200 x 1920 xhdpi!
Ingo
1
Anda harus menguji pada perangkat nyata :)
hqt
Saya telah menguji Emulator dan hasilnya "isTablet (Konteks konteks) salah. Coba sendiri pada Emulator.
Ingo
1
Terima kasih untuk @hqt ini, saya baru saja menyalin kode ini ke C # yang diperlukan untuk 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

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.

masukkan deskripsi gambar di sini

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

Suragch
sumber
2

Jika Anda hanya menargetkan level API> = 13 maka cobalah

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

Bersulang :-)

Mohanraj Balasubramaniam
sumber
1

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

Aracem
sumber
1

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

Maks
sumber
1

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; 
}
Vyshnavi
sumber
Solusi ini misalnya tidak bekerja pada Emulator dengan API 18 dan Nexus 7 1200 x 1920 xhdpi!
Ingo
Ini tidak lagi berfungsi pada beberapa perangkat. Misalnya ia mengembalikan false untuk perangkat Samsung Mega
bkurzius
Ya .. Ini tidak lagi berfungsi ... Saya sebenarnya biasa menambahkan boolean di semua file string untuk setiap nilai folder, values_large dll. <Bool name = "isTablet"> false </bool> <bool name = "isLargeTablet"> false </bool> dan kemudian periksa apakah R.bool.isTablet benar untuk menemukan apakah perangkat tersebut tablet
Vyshnavi
1

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

BSTech
sumber
0

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>
Alexander Pacha
sumber
0

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

RBz
sumber
0

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 );
}
MinFu
sumber
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
sumber
0

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

bkurzius
sumber
0

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!

Jorgesys
sumber
Penjelasan untuk -1? , ini adalah metode yang direkomendasikan oleh google.
Jorgesys
0

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?

Longalei
sumber
0

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.

Dominique Lorre
sumber
-1

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;
}
SathishBabu S
sumber
1
Tidak lagi berlaku dengan ICS. Memang, ada tablet dengan versi Android di bawah 11
mdelolmo
1
Ini TIDAK bisa diandalkan. Telepon ICS baru memiliki tingkat API> 11.
Jason Robinson
-1

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;

pengguna1503892
sumber
Ini tidak benar karena Samsung galaxy s3 menghasilkan 720 x 1280.
Nikhil
-1

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.

Perak
sumber
1
Tidak semua tablet memiliki orientasi lanskap default. Dan jika orientasi "default" penting bagi program Anda, itu mungkin salah dengan cara lain. Lihat posting Blog Pengembang Android ini sebagai contoh.
Dan Hulme
Tolong, bisakah Anda memberikan contoh spesifik tablet, yang dalam orientasi default lebarnya kurang dari tinggi? Dan tentu saja Anda tahu lebih baik apa yang seharusnya menjadi aplikasi saya: D.
Perak
Nexus 7 akan menjadi salah satu contoh. Tetapi Anda tidak harus mengambil kata saya untuk itu: baca artikel yang saya tautkan, yang menjelaskan semuanya.
Dan Hulme
Saya pikir harus mengubah nama metode saya. Bahkan, yang lebih penting (setidaknya untuk aplikasi saya;)) orientasi perangkat default, dan metode saya cukup untuk tugas ini. Juga mengidentifikasi masalah @Nanne dengan benar, lihat di atas.
Perak
-1

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);
GoyangJ
sumber
-1

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;
    }
Androidcoder
sumber
-3

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!

Otroberts
sumber