มีวิธีการตรวจสอบว่าผู้ใช้กำลังใช้แท็บเล็ตหรือโทรศัพท์หรือไม่? ฉันมีปัญหากับฟังก์ชั่นการเอียงและแท็บเล็ตใหม่ของฉัน (Transformer)

ตามที่ได้รับการกล่าวถึงก่อนหน้านี้คุณไม่ต้องการตรวจสอบว่าอุปกรณ์เป็นแท็บเล็ตหรือโทรศัพท์ แต่คุณต้องการทราบเกี่ยวกับคุณสมบัติของอุปกรณ์

ส่วนใหญ่แล้วความแตกต่างระหว่างแท็บเล็ตกับโทรศัพท์คือขนาดหน้าจอซึ่งเป็นสาเหตุที่คุณต้องการใช้ไฟล์เลย์เอาต์ที่แตกต่างกัน ไฟล์เหล่านี้ถูกเก็บไว้ในres/layout-<qualifiers>ไดเรกทอรี คุณสามารถสร้างไฟล์ XML ใน directoy res/values-<same qualifiers>สำหรับแต่ละเลย์เอาต์ของคุณและวาง int / bool / string ทรัพยากรลงในไฟล์เพื่อแยกแยะระหว่างเลย์เอาต์ที่คุณใช้

ตัวอย่าง:

ไฟล์res/values/screen.xml(สมมติว่าres/layout/มีไฟล์เลย์เอาต์ของคุณสำหรับมือถือ)

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

ไฟล์res/values-sw600dp/screen.xml(สมมติว่าres/layout-sw600dp/มีไฟล์เลย์เอาต์ของคุณสำหรับแท็บเล็ตขนาดเล็กเช่น Nexus 7)

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

ไฟล์res/values-sw720dp/screen.xml(สมมติว่าres/layout-sw720dp/มีไฟล์เลย์เอาต์ของคุณสำหรับแท็บเล็ตขนาดใหญ่เช่น Nexus 10):

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

ขณะนี้ประเภทหน้าจอสามารถเข้าถึงได้ผ่านR.string.screen_typeค่าคงที่

ในการตรวจสอบว่าอุปกรณ์เป็นแท็บเล็ตหรือไม่ให้ใช้รหัสต่อไปนี้:

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

LARGE และ XLARGE ขนาดหน้าจอถูกกำหนดโดยผู้ผลิตโดยอิงจากระยะห่างจากดวงตาที่พวกเขาจะใช้ที่ (ดังนั้นความคิดของแท็บเล็ต)

ข้อมูลเพิ่มเติม: http://groups.google.com/group/android-developers/browse_thread/thread/d6323d81f226f93f

โพสต์นี้ช่วยฉันได้มาก

น่าเสียดายที่ฉันไม่มีชื่อเสียงที่จำเป็นในการประเมินคำตอบทั้งหมดที่ช่วยฉัน

ฉันต้องระบุว่าอุปกรณ์ของฉันเป็นแท็บเล็ตหรือโทรศัพท์โดยที่ฉันจะสามารถใช้ตรรกะของหน้าจอได้ และในการวิเคราะห์ของฉันแท็บเล็ตจะต้องมากกว่า 7 นิ้ว (Xlarge) เริ่มต้นที่ MDPI

นี่คือรหัสด้านล่างซึ่งสร้างขึ้นตามโพสต์นี้

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

ทำไมไม่คำนวณขนาดของเส้นทแยงมุมหน้าจอและใช้ในการตัดสินใจว่าอุปกรณ์นั้นเป็นโทรศัพท์หรือแท็บเล็ต

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

แน่นอนหนึ่งสามารถยืนยันว่าเกณฑ์ควรจะ 9 นิ้วหรือน้อยกว่า

ไม่มีความแตกต่าง คุณควรกำหนดสิ่งที่คุณคิดว่าแตกต่างและตรวจสอบสิ่งนั้น กาแล็กซี่แท็บโทรศัพท์หรือไม่ หรือแท็บเล็ต และทำไม?

คุณควรกำหนดคุณสมบัติเฉพาะที่คุณต้องการและรหัสสำหรับสิ่งนั้น

ดูเหมือนว่าคุณกำลังมองหา 'เอียง' ฉันคิดว่านี่เหมือนกับ accelerometer (นั่นคือคำ?) คุณสามารถตรวจสอบว่าอุปกรณ์รองรับหรือไม่โดยใช้:

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

(จากhttp://stuffthathappens.com/blog/2009/03/15/android-accelerometer/ . ฉันยังไม่ได้ทดสอบ)

สมมติฐานของฉันคือเมื่อคุณกำหนด 'มือถือ / โทรศัพท์' คุณต้องการที่จะรู้ว่าคุณสามารถโทรออกบนอุปกรณ์ที่ไม่สามารถทำสิ่งที่จะกำหนดเป็นแท็บเล็ต วิธีการตรวจสอบนี้อยู่ด้านล่าง หากคุณต้องการรู้อะไรบางอย่างจากเซ็นเซอร์ขนาดหน้าจอ ฯลฯ นี่เป็นคำถามที่แตกต่าง

นอกจากนี้ในขณะที่ใช้ความละเอียดหน้าจอหรือการจัดการทรัพยากรขนาดใหญ่เทียบกับ xlarge อาจเป็นวิธีการที่ถูกต้องในอุปกรณ์ 'มือถือ' ที่ผ่านมาใหม่กำลังมาพร้อมกับหน้าจอขนาดใหญ่และความละเอียดสูงที่พวกเขาเบลอบรรทัดนี้ หากต้องการทราบว่าการโทรศัพท์ไม่มีความสามารถในการโทรด้านล่างคือ 'ดีที่สุด'

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

จาก Robert Dale Johnson III และ Helton Isac ฉันใช้รหัสนี้หวังว่านี่จะเป็นประโยชน์

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

ดังนั้นในรหัสของคุณทำให้ตัวกรองเหมือน

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

ในซอร์สโค้ดแอป Google IOSched 2017 จะใช้วิธีการต่อไปนี้:

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

สำหรับผู้ที่ต้องการอ้างถึงรหัสของ Google ในการตัดสินใจว่าอุปกรณ์ใดจะใช้ Tablet UI สามารถดูได้จากด้านล่าง:

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

วิธีนี้เป็นวิธีที่ Google แนะนำ ฉันเห็นรหัสนี้ในแอปอย่างเป็นทางการของ Google Androidiosched

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

ไม่จำเป็นต้องใช้รหัส

คำตอบอื่น ๆ แสดงรายการหลายวิธีในการกำหนดทางโปรแกรมว่าอุปกรณ์นั้นเป็นโทรศัพท์หรือแท็บเล็ต อย่างไรก็ตามหากคุณอ่านเอกสารนั่นไม่ใช่วิธีที่แนะนำในการรองรับขนาดหน้าจอที่หลากหลาย

ให้ประกาศทรัพยากรอื่น ๆ สำหรับแท็บเล็ตหรือโทรศัพท์แทน คุณทำเช่นนี้เพิ่มโฟลเดอร์ทรัพยากรของฉันเพิ่มเติมสำหรับlayout, valuesฯลฯ

• สำหรับ Android 3.2 (API ระดับ 13) เปิดให้เพิ่มsw600dpโฟลเดอร์ ซึ่งหมายความว่าs id ที่w mallest อย่างน้อย 600dp ซึ่งประมาณโทรศัพท์ / แท็บเล็ตแบ่ง อย่างไรก็ตามคุณสามารถเพิ่มขนาดอื่นได้เช่นกัน ลองดูคำตอบนี้เพื่อดูตัวอย่างวิธีเพิ่มไฟล์ทรัพยากรเลย์เอาต์เพิ่มเติม

• หากคุณรองรับอุปกรณ์ Android 3.2 ล่วงหน้าคุณจะต้องเพิ่มlargeหรือxlargeโฟลเดอร์เพื่อรองรับแท็บเล็ต (โทรศัพท์ทั่วไปsmallและnormal.)

นี่คือภาพที่ทรัพยากรของคุณอาจชอบหลังจากเพิ่มไฟล์ xml พิเศษสำหรับขนาดหน้าจอที่แตกต่างกัน

เมื่อใช้วิธีนี้ระบบจะกำหนดทุกอย่างให้คุณ คุณไม่ต้องกังวลกับการใช้อุปกรณ์ใดในขณะใช้งาน คุณเพียงแค่ให้ทรัพยากรที่เหมาะสมและให้ Android ทำทุกอย่างให้สำเร็จ

หมายเหตุ

• คุณสามารถใช้นามแฝงเพื่อหลีกเลี่ยงการทำซ้ำไฟล์ทรัพยากรที่เหมือนกัน

เอกสาร Android มูลค่าการอ่าน

• รองรับหลายหน้าจอ
• รองรับขนาดหน้าจอที่แตกต่างกัน
• กระจายไปยังหน้าจอเฉพาะ

หากคุณกำหนดเป้าหมายเฉพาะระดับ API> = 13 ให้ลอง

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

ไชโย :-)

กำลังคิดเกี่ยวกับไดเรกทอรีที่ "ใหม่" (ตัวอย่างเช่น values-sw600dp) ฉันสร้างวิธีนี้โดยอิงจากความกว้างหน้าจอ DP:

 public static final int TABLET_MIN_DP_WEIGHT = 450;
 protected static boolean isSmartphoneOrTablet(Activity act){
    DisplayMetrics metrics = new DisplayMetrics();
    act.getWindowManager().getDefaultDisplay().getMetrics(metrics);

    int dpi = 0;
    if (metrics.widthPixels < metrics.heightPixels){
        dpi = (int) (metrics.widthPixels / metrics.density);
    }
    else{
        dpi = (int) (metrics.heightPixels / metrics.density);
    }

    if (dpi < TABLET_MIN_DP_WEIGHT)         return true;
    else                                    return false;
}

และในรายการนี้คุณสามารถค้นหา DP ของอุปกรณ์และขนาดแท็บเล็ตยอดนิยมบางส่วน:

Wdp / Hdp

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

Wdp = ความกว้าง dp
Hdp = ความสูง dp

ทางออกที่ดีที่สุดที่ใช้งานได้สำหรับฉันนั้นง่ายมาก:

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

ใช้แบบนี้:

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

ฉันไม่ต้องการดูขนาดพิกเซล แต่พึ่งขนาดหน้าจอเท่านั้น

ทำงานได้ดีเช่นเดียวกับ Nexus 7 (LARGE) ที่ตรวจพบว่าเป็นแท็บเล็ต แต่ไม่ใช่ Galaxy S3 (ปกติ)

ใช้วิธีนี้ซึ่งจะคืนค่าจริงเมื่ออุปกรณ์เป็นแท็บเล็ต

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

หากการตรวจจับขนาดหน้าจอไม่ส่งคืนค่าที่ถูกต้องสำหรับอุปกรณ์ใหม่ให้ลองทำดังนี้

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

ผ่านการทดสอบบน Android 4.2.2 (ขออภัยสำหรับภาษาอังกฤษของฉัน)

ฉันรู้ว่านี่ไม่ใช่คำตอบสำหรับคำถามของคุณโดยตรง แต่คำตอบอื่น ๆ ที่นี่ให้ความคิดที่ดีเกี่ยวกับวิธีระบุขนาดหน้าจอ คุณเขียนในคำถามของคุณว่าคุณมีปัญหากับการเอียงและสิ่งนี้ก็เกิดขึ้นกับฉันเช่นกัน

หากคุณเรียกใช้ไจโรสโคป (หรือเซ็นเซอร์หมุน) บนสมาร์ทโฟนคุณสามารถกำหนดแกน x และแกน y ได้แตกต่างจากบนแท็บเล็ตตามการวางแนวเริ่มต้นของอุปกรณ์นั้น (เช่น Samsung GS2 เป็นแนวตั้งมาตรฐาน Samsung GT-7310 คือ แนวนอนเริ่มต้น Google Nexus 7 ใหม่เป็นแนวตั้งแม้ว่าจะเป็นแท็บเล็ต!)

ตอนนี้ถ้าคุณต้องการใช้ Gyroscope คุณอาจต้องใช้วิธีแก้ปัญหาที่ใช้งานได้กับสมาร์ทโฟน แต่ความสับสนของแกนในแท็บเล็ตบางตัวหรือในทางกลับกัน

หากคุณใช้วิธีแก้ปัญหาข้อใดข้อหนึ่งจากด้านบนเพื่อใช้กับขนาดหน้าจอจากนั้นใช้เท่านั้น

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

เพื่อพลิกแกนถ้ามันมีขนาดใหญ่หรือขนาดหน้าจอที่ใหญ่ขนาดนี้อาจทำงานได้ใน 90% ของเคส แต่ตัวอย่างเช่นใน Nexus 7 มันจะทำให้เกิดปัญหา (เพราะมันมีการวางแนวแนวตั้งเริ่มต้นและหน้าจอขนาดใหญ่)

วิธีที่ง่ายที่สุดในการแก้ไขปัญหานี้มีให้ใน RotationVectorSample ที่มาพร้อมกับการสาธิต API โดยการตั้งค่า sceenOrientation nosensorในรายการของคุณ:

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

com.sec.feature.multiwindow.tablet ในตัวจัดการแพ็กเกจเฉพาะกับแท็บเล็ตและ com.sec.feature.multiwindow.phone เฉพาะสำหรับโทรศัพท์

วิธีการด้านล่างกำลังคำนวณความยาวแนวทแยงของหน้าจอของอุปกรณ์เพื่อตัดสินว่าอุปกรณ์นั้นเป็นโทรศัพท์หรือแท็บเล็ต ข้อกังวลเพียงอย่างเดียวสำหรับวิธีนี้คือสิ่งที่เป็นค่าเกณฑ์ในการตัดสินใจสภาพอากาศอุปกรณ์แท็บเล็ตหรือไม่ ในตัวอย่างด้านล่างฉันตั้งเป็น 7 นิ้วขึ้นไป

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

การวาดเส้นแบ่งระหว่างโทรศัพท์และแท็บเล็ตทำได้ยากขึ้น ตัวอย่างเช่น (ณ เดือนสิงหาคม 2015) อุปกรณ์Samsung Mega 6.3ดึงทรัพยากรจากโฟลเดอร์ sw600dp - ตราบใดที่ Android ยังเกี่ยวข้องกับแท็บเล็ต

คำตอบจาก@Vyshnavi สามารถใช้ได้กับอุปกรณ์ทั้งหมดที่เราทดสอบ แต่ไม่ได้ใช้กับ Mega 6.3

@Helton Isacคำตอบข้างต้นจะส่งคืน Mega 6.3 เป็นโทรศัพท์ - แต่เนื่องจากอุปกรณ์ยังคงคว้าทรัพยากรจาก sw600dp มันอาจทำให้เกิดปัญหาอื่น ๆ - ตัวอย่างเช่นถ้าคุณใช้ viewpager สำหรับโทรศัพท์และไม่ใช่แท็บเล็ตคุณจะปิดท้ายด้วยข้อผิดพลาด NPE .

ในที่สุดดูเหมือนว่ามีเงื่อนไขมากเกินไปที่จะตรวจสอบและเราอาจต้องยอมรับว่าโทรศัพท์บางรุ่นเป็นแท็บเล็ตจริง :-P

นี่คือวิธีการที่ฉันใช้:

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

โดยใช้:

องค์ประกอบ SCREENLAYOUT_SIZE_MASK

องค์ประกอบ SCREENLAYOUT_SIZE_LARGE

นี่เป็นวิธีที่แนะนำ!

ทำไมต้องใช้สิ่งนี้

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

ฉันเห็นหลายวิธีข้างต้นคลาสการกำหนดค่าได้รับคำตอบที่ถูกต้องด้านล่าง:

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

เพียงแค่โทร:

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

ไม่เป็นไร?

ฉันต้องการตรวจสอบสมาร์ทโฟน / แท็บเล็ตในไฟล์เลย์เอาต์เท่านั้นเพราะฉันใช้รหัสนำทาง

สิ่งที่ฉันทำครั้งแรกคือการสร้างไดเรกทอรี layout-sw600dp แต่มันใช้งานไม่ได้เพราะมันจะเปิดใช้งานบน Nokia 8 ของฉันในโหมดแนวนอน แต่ความสูงของหน้าจอจะเล็กเกินไป

ดังนั้นฉันเปลี่ยนชื่อไดเรกทอรีเป็น layout-sw600dp-h400dp จากนั้นฉันได้รับผลที่ต้องการ พารามิเตอร์ h-xxxdp ควรขึ้นอยู่กับจำนวนเนื้อหาที่คุณต้องการวางในเลย์เอาต์ของคุณและขึ้นอยู่กับแอปพลิเคชัน

กรุณาตรวจสอบรหัสด้านล่าง

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

ฉันคิดว่าแท็บเล็ตมีความกว้างและความสูงขั้นต่ำสูงสุด 600 px
ดังนั้นต้องทราบความหนาแน่นของหน้าจอและความสูง / ความกว้างในหน่วย dp
เพื่อดึงค่า:

DisplayMetrics metrics = new DisplayMetrics();
activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
Display display = ((WindowManager)getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int width = display.getWidth(); 
int height = display.getHeight(); 
float density = metrics.density;  
if((width/density>=600 && height/density>=600))
 isTablette = true;
else
 isTablette = false;

เช่นมีความแตกต่างที่สำคัญอย่างหนึ่ง (อย่างน้อยสำหรับโปรแกรมของฉัน) ระหว่างโทรศัพท์และแท็บเล็ต มันคือการวางแนวเริ่มต้นของอุปกรณ์ โทรศัพท์มีการวางแนวแนวตั้งแท็บเล็ต - แนวนอน และวิธีการตามลำดับเพื่อตรวจสอบอุปกรณ์:

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

แก้ไข: หลังจากการหารือกับ Dan Hulme เปลี่ยนชื่อของวิธีการ

ฉันขอแนะนำหุ่นยนต์ไลบรารี 'คาเฟอีน' ที่มีโทรศัพท์หรือแท็บเล็ตและ 10 นิ้ว ~!

ใช้งานง่ายมาก

ห้องสมุดอยู่ที่นี่

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

และการใช้งาน

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

สำหรับฉันความแตกต่างระหว่างโทรศัพท์และแท็บเล็ตไม่ได้เป็นขนาดของอุปกรณ์และ / หรือความหนาแน่นของพิกเซลซึ่งจะเปลี่ยนไปด้วยเทคโนโลยีและรสนิยม แต่ค่อนข้างอัตราส่วนหน้าจอ หากฉันกำลังแสดงหน้าจอข้อความฉันต้องรู้ว่าพูดว่าต้องใช้สายยาว 15 บรรทัด (โทรศัพท์) และ 20 บรรทัดที่สั้นกว่า (แท็บเล็ต) สำหรับเกมของฉันฉันใช้สิ่งต่อไปนี้เพื่อประเมินเบสบอลของซอฟต์แวร์ของฉันที่จะจัดการกับ:

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

ฉันคิดว่านี่เป็นวิธีที่ง่ายที่สุดที่จะซื่อสัตย์ นี่จะตรวจสอบขนาดหน้าจอที่ใช้:

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

ขอให้โชคดี!