ตรวจจับแท็บเล็ตขนาด 7 นิ้วและ 10 นิ้วโดยใช้โปรแกรม

Question 1

มีวิธีในการค้นหาโดยทางโปรแกรมหรือไม่ว่าอุปกรณ์ที่ติดตั้งแอปนั้นเป็นแท็บเล็ต 7 นิ้วหรือแท็บเล็ต 10 นิ้ว

Question 2

คุณสามารถใช้DisplayMetricsเพื่อรับข้อมูลทั้งหมดเกี่ยวกับหน้าจอที่แอปของคุณกำลังทำงานอยู่

ขั้นแรกเราสร้างDisplayMetricsวัตถุเมตริก:

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

จากสิ่งนี้เราจะได้รับข้อมูลที่จำเป็นในการปรับขนาดจอแสดงผล:

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

สิ่งนี้จะคืนค่าสัมบูรณ์ของความกว้างและความสูงเป็นพิกเซลดังนั้น 1280x720 สำหรับ Galaxy SIII, Galaxy Nexus เป็นต้น

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

คุณจะได้รับdensityของหน้าจอโดยใช้metricsอีกครั้งในรูปแบบของปัจจัยระดับสำหรับอุปกรณ์ซึ่งจะขึ้นอยู่กับที่Android ทรัพยากรการออกแบบสำหรับmdpi, hdpiฯลฯ เครื่องชั่ง DPI

float scaleFactor = metrics.density;

จากผลลัพธ์นี้เราสามารถคำนวณจำนวนพิกเซลอิสระที่มีความหนาแน่นสำหรับความสูงหรือความกว้างที่แน่นอน

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

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

320dp: หน้าจอโทรศัพท์ทั่วไป (240x320 ldpi, 320x480 mdpi, 480x800 hdpi ฯลฯ )

480dp: แท็บเล็ต tweener เช่น Streak (480x800 mdpi)

600dp: แท็บเล็ตขนาด 7 นิ้ว (600x1024 mdpi)

720dp: แท็บเล็ตขนาด 10 นิ้ว (720x1280 mdpi, 800x1280 mdpi ฯลฯ )

จากข้อมูลข้างต้นเราทราบว่าหากอุปกรณ์ที่มีความกว้างน้อยที่สุดมากกว่า 600dp แสดงว่าเป็นแท็บเล็ตขนาด 7 นิ้วหากมีขนาดใหญ่กว่า 720dp อุปกรณ์จะเป็นแท็บเล็ตขนาด 10 นิ้ว

เราสามารถทำงานออกความกว้างที่เล็กที่สุดโดยใช้minฟังก์ชั่นของMathระดับผ่านในheightDpและจะกลับมาwidthDpsmallestWidth

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

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

อย่างไรก็ตามสิ่งนี้ไม่ได้ให้ข้อมูลที่ตรงกันเสมอไปโดยเฉพาะอย่างยิ่งเมื่อทำงานกับแท็บเล็ตที่คลุมเครือซึ่งอาจทำให้ความหนาแน่นเป็น hdpi ไม่ถูกต้องหรืออาจเป็นเพียง 800 x 480 พิกเซล แต่ยังคงอยู่บนหน้าจอขนาด 7 นิ้ว .

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

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

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

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

สิ่งนี้จะคืนค่าความสูงและความกว้างของอุปกรณ์เป็นนิ้ว สิ่งนี้ไม่ได้เป็นประโยชน์เสมอไปในการระบุประเภทของอุปกรณ์เนื่องจากขนาดของอุปกรณ์ที่โฆษณาเป็นเส้นทแยงมุมสิ่งที่เรามีคือความสูงและความกว้าง

อย่างไรก็ตามเราทราบด้วยว่าเมื่อพิจารณาจากความสูงของสามเหลี่ยมและความกว้างเราสามารถใช้ทฤษฎีบทพีทาโกรัสเพื่อคำนวณความยาวของด้านตรงข้ามมุมฉาก (ในกรณีนี้คือขนาดของเส้นทแยงมุมของหน้าจอ)

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

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

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

และนั่นคือวิธีที่คุณคำนวณว่าคุณกำลังทำงานกับอุปกรณ์ประเภทใด

Question 3

ไม่มีอะไรที่พูด7"หรือ10"AFAIK มีสองวิธีในการรับขนาดหน้าจอที่ระบบใช้ในการถอดรหัสบิตแมปและสิ่งที่ไม่ ทั้งคู่พบได้ในResourcesวัตถุของแอปพลิเคชันที่พบในไฟล์Context.

ที่แรกก็คือวัตถุที่สามารถรับได้โดยConfiguration getContext().getResources().getConfiguration()ในนั้นคุณมี:

Configuration#densityDpi - ความหนาแน่นของหน้าจอเป้าหมายถูกแสดงให้สอดคล้องกับตัวกำหนดคุณสมบัติทรัพยากรความหนาแน่น

Configuration#screenHeightDp - ความสูงปัจจุบันของพื้นที่หน้าจอที่มีอยู่ในหน่วย dp ซึ่งสอดคล้องกับตัวระบุทรัพยากรความสูงของหน้าจอ

Configuration#screenWidthDp - ความกว้างปัจจุบันของพื้นที่หน้าจอที่มีอยู่ในหน่วย dp ซึ่งสอดคล้องกับตัวระบุทรัพยากรความกว้างของหน้าจอ

Configuration#smallestScreenWidthDp - ขนาดหน้าจอที่เล็กที่สุดที่แอปพลิเคชันจะเห็นในการทำงานปกติซึ่งสอดคล้องกับคุณสมบัติทรัพยากรความกว้างของหน้าจอที่เล็กที่สุด

กับที่คุณสวยมากสามารถใช้แนวทางหน้าจอที่จะคิดออกว่าอุปกรณ์ของคุณจะดึงจากโฟลเดอร์ทรัพยากรเฉพาะที่เกี่ยวข้อง ( hdpi, xhdpi, large, xlargeฯลฯ )

โปรดจำไว้ว่านี่คือที่เก็บข้อมูลบางส่วน:

หน้าจอ xlarge มีขนาดอย่างน้อย 960dp x 720dp
หน้าจอขนาดใหญ่อย่างน้อย 640dp x 480dp
หน้าจอปกติอย่างน้อย 470dp x 320dp
หน้าจอขนาดเล็กอย่างน้อย 426dp x 320dp
320dp: หน้าจอโทรศัพท์ทั่วไป (240x320 ldpi, 320x480 mdpi, 480x800 hdpi ฯลฯ )
480dp: แท็บเล็ต tweener เช่น Streak (480x800 mdpi)
600dp: แท็บเล็ตขนาด 7 นิ้ว (600x1024 mdpi)
720dp: แท็บเล็ตขนาด 10 นิ้ว (720x1280 mdpi, 800x1280 mdpi ฯลฯ )

ข้อมูลเพิ่มเติม

ประการที่สองคือวัตถุที่ได้จากการDisplayMetrics getContext().getResources().getDisplayMetrics()ในนั้นคุณมี:

DisplayMetrics#density - ความหนาแน่นเชิงตรรกะของจอแสดงผล

DisplayMetrics#densityDpi - ความหนาแน่นของหน้าจอแสดงเป็นจุดต่อนิ้ว

DisplayMetrics#heightPixels - ความสูงแน่นอนของการแสดงผลเป็นพิกเซล

DisplayMetrics#widthPixels - ความกว้างสัมบูรณ์ของการแสดงผลเป็นพิกเซล

DisplayMetrics#xdpi - พิกเซลทางกายภาพที่แน่นอนต่อนิ้วของหน้าจอในมิติ X

DisplayMetrics#ydpi - พิกเซลทางกายภาพที่แน่นอนต่อนิ้วของหน้าจอในมิติ Y

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

Question 4

วางวิธีนี้ใน onResume () และสามารถตรวจสอบ

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;

    }

โดยทั่วไปแท็บเล็ตจะเริ่มหลังจากขนาด 6 นิ้ว

Question 5

ข้างต้นใช้ไม่ได้เสมอไปเมื่อเปลี่ยนแนวตั้งกับแนวนอน

หากคุณกำหนดเป้าหมาย API ระดับ 13+ มันเป็นเรื่องง่ายตามที่อธิบายไว้ข้างต้น - ใช้ Configuration.smarestScreenWidthDp แล้วทดสอบตาม

resources.getConfiguration().smallestScreenWidthDp

มิฉะนั้นหากคุณสามารถจ่ายได้ให้ใช้วิธีการต่อไปนี้ซึ่งเป็นวิธีที่แม่นยำมากในการตรวจจับ 600dp (เช่น 6 ") เทียบกับ 720dp (เช่น 10") โดยให้ระบบบอกคุณ:

1) เพิ่มไปยัง layout-sw600dp และ layout-sw720dp (และถ้าใช้ได้ในแนวนอน) มุมมองที่มองไม่เห็นพร้อม ID ที่เหมาะสมตัวอย่างเช่น:

สำหรับ 720 บน layout-sw720dp:

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

สำหรับ 600 บน layout-sw600dp:

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

2) จากนั้นในรหัสตัวอย่างเช่นกิจกรรมให้ทดสอบตาม:

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

Question 6

ข้อมูลที่ดีคือสิ่งที่ฉันกำลังมองหา! อย่างไรก็ตามหลังจากลองใช้แล้วฉันพบว่าเมื่อใช้เมตริกที่กล่าวถึงที่นี่รายงาน Nexus 7 (รุ่น 2012) ที่มีขนาด 1280x736 ฉันยังมี Motorola Xoom ที่ใช้ Jelly Bean และรายงานความละเอียด 1280x752 อย่างไม่ถูกต้อง ฉันสะดุดกับโพสต์นี้ที่นี่ที่ยืนยันสิ่งนี้ โดยทั่วไปใน ICS / JB การคำนวณโดยใช้เมตริกที่กล่าวถึงข้างต้นดูเหมือนจะไม่รวมมิติข้อมูลของแถบนำทาง การวิจัยเพิ่มเติมทำให้ฉัน ได้รับคำตอบของ Frank Nguyen ที่นี่ซึ่งใช้วิธีการต่างๆที่จะให้ขนาดพิกเซลของหน้าจอดิบ (หรือจริง) การทดสอบครั้งแรกของฉันแสดงให้เห็นว่ารหัสต่อไปนี้จาก Frank correclty รายงานขนาดบน Nexus 7 (รุ่นปี 2012 รันใน JB) และ Motorola Xoom ของฉันที่ใช้ 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();
}

Question 7

ฉันมีอุปกรณ์ Android สองเครื่องที่มีความละเอียดเท่ากัน

Device1 -> ความละเอียด 480x800 ขนาดหน้าจอในแนวทแยง -> 4.7 นิ้ว

Device2 -> ความละเอียด 480x800 ขนาดหน้าจอในแนวทแยง -> 4.0 นิ้ว

ให้ขนาดหน้าจอในแนวทแยงของอุปกรณ์ -> 5.8

วิธีแก้ปัญหาของคุณคือ ..

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

ดูรายละเอียดที่นี่ ..

Question 8

พวกเขามีวิธีการที่ Android ระบุขนาดหน้าจอคือผ่านสี่ขนาดทั่วไป: ขนาดเล็ก , ปกติ , ขนาดใหญ่และXLarge

ในขณะที่เอกสารของ Android ระบุว่าเลิกใช้งานกลุ่มขนาดแล้ว

... กลุ่มขนาดเหล่านี้เลิกใช้แล้วเพื่อสนับสนุนเทคนิคใหม่ในการจัดการขนาดหน้าจอตามความกว้างของหน้าจอที่มี หากคุณกำลังพัฒนาสำหรับ Android 3.2 ขึ้นไปโปรดดู [การประกาศเค้าโครงแท็บเล็ตสำหรับ Android 3.2] (hdpi (สูง) ~ 240dpi) สำหรับข้อมูลเพิ่มเติม

โดยทั่วไปตัวกำหนดขนาดขนาดใหญ่จะระบุแท็บเล็ตขนาด 7 "และตัวกำหนดขนาดxlargeระบุแท็บเล็ต 10":

ป้อนคำอธิบายภาพที่นี่

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

ในการดึงตัวกำหนดขนาดในรหัสให้ทำการเรียกต่อไปนี้:

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

Question 9

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

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

Question 10

ฉันเก็บค่าไว้ในโฟลเดอร์ค่าที่ให้หน้าจอเป็น 7 นิ้วหรือ 10 นิ้ว แต่เราสามารถทำได้สำหรับอุปกรณ์ใด ๆ โดยใช้โฟลเดอร์ค่า

เช่นสร้างโฟลเดอร์ 2 ค่าที่แตกต่างกันสำหรับอุปกรณ์ 2 เครื่องที่แตกต่างกัน แต่สิ่งนี้ขึ้นอยู่กับความต้องการ

Question 11

คุณจะต้องทำการคำนวณเล็กน้อยโดยใช้ข้อมูลที่กำหนดโดยคลาสDisplayMetrics

คุณมี heightPixel และ widthPixels (ความละเอียดหน้าจอเป็นพิกเซล)

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

diagonalPixel = √ (heightPixel² + widthPixels²)

จากนั้นคุณสามารถแปลงค่าพิกเซลเป็นนิ้วได้ด้วยค่าความหนาแน่น DPI:

inchDiag = diagonalPixel / densityDPI

ฉันหวังว่าฉันจะไม่ทำผิดที่นี่โปรดทราบว่าค่าที่คุณได้รับจากคลาส DisplayMetrics นั้นได้รับจากผู้สร้างดูเหมือนว่า (ในบางกรณีที่หายากมาก) จะไม่ได้รับการตั้งค่าที่ดีตามวัสดุทางกายภาพ ...

ซึ่งจะให้ขนาดหน้าจอจริง แต่อาจไม่ใช่วิธีที่ดีกว่าในการจัดการเลย์เอาต์หลาย ๆ แบบ เพิ่มเติมเกี่ยวกับหัวข้อนี้

Question 12

อีกวิธีหนึ่ง:

สร้างอีก 2 โฟลเดอร์: values-large + values-xlarge
ใส่: <string name="screentype">LARGE</string>ในโฟลเดอร์ values-large (strings.xml)
ใส่: <string name="screentype">XLARGE</string>ในโฟลเดอร์ values-xlarge (strings.xml)
ในรหัส:

สตริง mType = getString (R.string.screentype);

ถ้า (mType! = null && mType.equals ("LARGE") {

// ตั้งแต่ 4 ~ 7 นิ้ว

} else if (mType! = null && mType.equals ("XLARGE") {

// ตั้งแต่ 7 ~ 10 นิ้ว

}

Question 13

โวลา! 😀นี่คือทั้งหมดที่คุณจะต้องแยกแท็บเล็ตออกจากโทรศัพท์

1. ฟังก์ชั่นตัวช่วยเพื่อรับความกว้างของหน้าจอ:

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

2. ฟังก์ชั่นเพื่อดูว่าอุปกรณ์เป็นแท็บเล็ตหรือไม่

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

3. สุดท้ายหากคุณต้องการดำเนินการต่างๆสำหรับอุปกรณ์ขนาดต่างๆ:

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

boolean is10InchTablet() {
    return getScreenWidth() >= 720;
}

Question 14

นี่คือส่วนขยายของ kotlin ที่มีประโยชน์:

    
    fun DisplayMetrics.isTablet(): Boolean {
        return getScreenWidth() >= 600
    }
    
    fun DisplayMetrics.is7InchTablet(): Boolean {
        return getScreenWidth() >= 600 && getScreenWidth() < 720
    }
    
    fun DisplayMetrics.is10InchTablet(): Boolean {
        return getScreenWidth() >= 720
    }
    
    fun DisplayMetrics.getScreenWidth(): Float {
        return widthPixels.coerceAtMost(heightPixels) / density
    }