Lập trình phát hiện máy tính bảng 7 inch và 10 inch


93

Có cách nào để lập trình tìm xem thiết bị mà ứng dụng được cài đặt là máy tính bảng 7 inch hay máy tính bảng 10 inch không?


Ví dụ: layout-sw600dp tìm kiếm kích thước chiều rộng nhỏ nhất là 600dp.
Rookie

Tôi hiểu điều đó, nhưng bạn đang tìm kiếm điều gì có lập trình?
Geobits

Tôi cần tìm nạp các thiết bị này theo chương trình..như có một số thuộc tính mà tôi không thể xác định trong xml..các thuộc tính này được xác định trong mã chính nó .. vì vậy nếu tôi chỉ cần đặt mã, nó sẽ áp dụng cho tất cả các thiết bị..nhưng Tôi không muốn điều đó ..
Rookie

@Raghav bạn đã thử với ma trận hiển thị để có được kích thước của màn hình và sau đó bạn có thể so sánh. Mặc dù nó không phải là một cách sạch sẽ nhưng bạn có thể sử dụng.
PiyushMishra

Bạn có thể nhận kích thước màn hình của mình và làm việc từ đó ... stackoverflow.com/questions/1016896/…
Raj

Câu trả lời:


234

Bạn có thể sử dụng DisplayMetricsđể nhận toàn bộ thông tin về màn hình mà ứng dụng của bạn đang chạy.

Đầu tiên, chúng tôi tạo một DisplayMetricsđối tượng số liệu:

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

Từ đó, chúng tôi có thể nhận được thông tin cần thiết để kích thước màn hình:

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

Điều này sẽ trả về giá trị tuyệt đối của chiều rộng và chiều cao tính bằng pixel, vì vậy 1280x720 đối với Galaxy SIII, Galaxy Nexus, v.v.

Điều này thường không hữu ích một mình, vì khi chúng tôi làm việc trên thiết bị Android, chúng tôi thường thích làm việc với các pixel độc lập với mật độ, nhúng.

Bạn sẽ densitysử dụng metricslại màn hình dưới dạng hệ số tỷ lệ cho thiết bị, dựa trên Tài nguyên thiết kế Android cho mdpi, hdpiv.v. DPI thang đo

float scaleFactor = metrics.density;

Từ kết quả này, chúng tôi có thể tính toán số lượng pixel độc lập với mật độ có cho một chiều cao hoặc chiều rộng nhất định.

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

Kết quả bạn nhận được từ việc này sẽ giúp bạn quyết định loại màn hình bạn đang làm việc cùng với các ví dụ về Cấu hình Android , cung cấp cho bạn dp tương đối cho từng kích thước màn hình:

  • 320dp: màn hình điện thoại thông thường (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, v.v.).
  • 480dp: một máy tính bảng tweener như Streak (480x800 mdpi).
  • 600dp: máy tính bảng 7 ”(600x1024 mdpi).
  • 720dp: máy tính bảng 10 ”(720x1280 mdpi, 800x1280 mdpi, v.v.).

Sử dụng thông tin trên, chúng ta biết rằng nếu chiều rộng nhỏ nhất của thiết bị lớn hơn 600dp, thiết bị là máy tính bảng 7 ", nếu lớn hơn 720dp, thiết bị là máy tính bảng 10".

Chúng ta có thể tính ra chiều rộng nhỏ nhất bằng cách sử dụng minhàm của Mathlớp, truyền vào heightDpwidthDptrả về smallestWidth.

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

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

Tuy nhiên, điều này không phải lúc nào cũng cung cấp cho bạn kết quả trùng khớp chính xác, đặc biệt là khi làm việc với các máy tính bảng không rõ ràng có thể trình bày sai mật độ của chúng là hdpi khi không hoặc có thể chỉ là 800 x 480 pixel nhưng vẫn ở trên màn hình 7 " .

Ngoài các phương pháp này, nếu bạn cần biết kích thước chính xác của một thiết bị tính bằng inch, bạn cũng có thể tính toán điều đó bằng cách sử dụng metricsphương pháp cho biết có bao nhiêu pixel trên mỗi inch của màn hình.

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

Bạn có thể sử dụng kiến ​​thức về số lượng pixel trong mỗi inch của thiết bị và tổng số pixel để tính toán thiết bị đó là bao nhiêu inch.

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

Điều này sẽ trả về chiều cao và chiều rộng của thiết bị theo đơn vị inch. Điều này một lần nữa không phải lúc nào cũng hữu ích để xác định đó là loại thiết bị nào, vì kích thước được quảng cáo của thiết bị là đường chéo, tất cả những gì chúng ta có là chiều cao và chiều rộng.

Tuy nhiên, chúng ta cũng biết rằng với chiều cao của một tam giác và chiều rộng, chúng ta có thể sử dụng định lý Pitago để tính độ dài cạnh huyền (Trong trường hợp này là kích thước của đường chéo màn hình).

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

Từ đó, chúng tôi có thể xác định xem thiết bị có phải là máy tính bảng hay không:

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

Và đó là cách bạn tính toán loại thiết bị bạn đang làm việc.


3
Lời khuyên tuyệt vời Sean. Tôi đã từng kiểm tra bằng px cho máy tính bảng, nhưng trong một số trường hợp, có vấn đề (Galaxy 3, 4, Note, có px bằng hoặc hơn Nexus 7). Bây giờ tôi cũng có thể kiểm tra inch. Dưới đây là danh sách nhiều thông số kỹ thuật thiết bị màn hình phổ biến: en.wikipedia.org/wiki/List_of_displays_by_pixel_density
Pelanes

8
Không sử dụng xdpi hoặc ydpi. Đây là những tùy chọn và sẽ do nhà sản xuất quy định, không tính toán. Chúng thường không được sử dụng hoặc không chính xác.
squrockad

2
Sử dụng phương pháp của bạn để lấy chiều rộng theo dpi, tôi nhận được các kết quả khác nhau tùy thuộc vào hướng. ví dụ: đối với Nexus 7: PORTRAIT: smallWidth = 600,9; CẢNH QUAN: nhỏ nhấtWidth = 552,8; lý do cho điều đó là gì?
Christopher Masser

3
Logic if (smallestWidth > 600) { /* 7" */ } else if (smallestWidth > 720) { /* 10" */ }còn thiếu sót: Máy tính bảng 10 "được công nhận là 7". Tôi đã tự do để sửa chữa điều đó.
Jonik

21
Cuối cùng tôi đã đi với resources.getConfiguration().smallestScreenWidthDptừ câu trả lời của DeeV đó là phương pháp duy nhất cung cấp cho các giá trị như nhau trong cả hai bức chân dung và phong cảnh trên của tôi Nexus 7 (600dp). Nó đã được bổ sung ở mức API 13.
Jonik

32

Không có gì nói 7"hoặc 10"AFAIK. Có hai cách để lấy kích thước màn hình mà hệ thống sử dụng khi giải mã bitmap và không. Cả hai đều được tìm thấy trong Resourcesđối tượng của ứng dụng được tìm thấy trong Context.

Đầu tiên là Configurationđối tượng có thể lấy được bằng getContext().getResources().getConfiguration(). Trong đó bạn có:

Configuration#densityDpi - Mật độ màn hình đích đang được hiển thị, tương ứng với bộ định tính tài nguyên mật độ.

Configuration#screenHeightDp - Chiều cao hiện tại của không gian màn hình khả dụng, tính bằng đơn vị dp, tương ứng với định tính tài nguyên chiều cao màn hình.

Configuration#screenWidthDp - Chiều rộng hiện tại của không gian màn hình khả dụng, tính bằng đơn vị dp, tương ứng với định tính tài nguyên chiều rộng màn hình.

Configuration#smallestScreenWidthDp - Kích thước màn hình nhỏ nhất mà ứng dụng sẽ nhìn thấy trong hoạt động bình thường, tương ứng với định tính tài nguyên chiều rộng màn hình nhỏ nhất.

Cùng với đó, bạn có thể sử dụng khá nhiều các hướng dẫn màn hình để tìm hiểu xem thiết bị của bạn được kéo từ các thư mục tài nguyên chuyên ngành tương ứng ( hdpi, xhdpi, large, xlarge, vv).

Hãy nhớ rằng, đây là một số nhóm:

  • màn hình xlarge ít nhất là 960dp x 720dp
  • màn hình lớn ít nhất là 640dp x 480dp
  • màn hình bình thường tối thiểu 470dp x 320dp
  • màn hình nhỏ tối thiểu là 426dp x 320dp

  • 320dp: màn hình điện thoại thông thường (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, v.v.).

  • 480dp: một máy tính bảng tweener như Streak (480x800 mdpi).
  • 600dp: máy tính bảng 7 ”(600x1024 mdpi).
  • 720dp: máy tính bảng 10 ”(720x1280 mdpi, 800x1280 mdpi, v.v.).

Thêm thông tin

Thứ hai là DisplayMetricsđối tượng thu được bằng getContext().getResources().getDisplayMetrics(). Trong đó bạn có:

DisplayMetrics#density - Mật độ hợp lý của màn hình.

DisplayMetrics#densityDpi - Mật độ màn hình được biểu thị bằng số chấm trên inch.

DisplayMetrics#heightPixels - Chiều cao tuyệt đối của màn hình tính bằng pixel.

DisplayMetrics#widthPixels - Chiều rộng tuyệt đối của màn hình tính bằng pixel.

DisplayMetrics#xdpi - Các pixel vật lý chính xác trên mỗi inch của màn hình trong kích thước X.

DisplayMetrics#ydpi - Các pixel vật lý chính xác trên mỗi inch của màn hình trong kích thước Y.

Điều này rất hữu ích nếu bạn cần số điểm ảnh chính xác của màn hình hơn là mật độ. Tuy nhiên, điều quan trọng cần lưu ý là đây là tất cả các pixel của màn hình. Không chỉ những thứ có sẵn cho bạn.


4
+1, tôi đang nhận được kết quả tốt nhất với smallestScreenWidthDp. Không giống như các giải pháp khác, nó cho giá trị như nhau trên Nexus 7 của tôi (600dp) bất kể hướng nào . Như một phần thưởng, nó cũng là mã đơn giản nhất!
Jonik

1
Tôi nghĩ đây tiếp tục là cách tốt nhất vì nó phải khớp với ký hiệu sw ??? dp trên đường dẫn tài nguyên. Tính nhất quán là quan trọng.
lilbyrdie

13

đặt phương thức này trong onResume () và có thể kiểm tra.

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;

    }

nói chung máy tính bảng bắt đầu sau kích thước 6 inch.


8

Điều trên không phải lúc nào cũng hoạt động khi chuyển đổi dọc và ngang.

Nếu bạn đang nhắm mục tiêu API cấp 13+, thì dễ dàng như được mô tả ở trên - sử dụng Configuration.smallestScreenWidthDp, sau đó kiểm tra tương ứng:

resources.getConfiguration().smallestScreenWidthDp

Nếu không, nếu bạn có đủ khả năng, hãy sử dụng phương pháp sau đây là một cách tiếp cận rất chính xác để phát hiện 600dp (như 6 ") so với 720dp (như 10") bằng cách cho phép hệ thống cho bạn biết:

1) Thêm vào layout-sw600dp và layout-sw720dp (và nếu có thể là ngang của nó) một chế độ xem ẩn với ID thích hợp, ví dụ:

Đối với 720, trên layout-sw720dp:

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

Đối với 600, trên layout-sw600dp:

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

2) Sau đó, trên mã, ví dụ, Activity, hãy kiểm tra tương ứng:

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

4
Bạn không cần phải tạo một bố cục riêng biệt, tôi tin rằng bạn có thể chỉ cần có một string.xml riêng biệt dựa trên kích thước, bằng cách có các thư mục giá trị khác nhau, như giá trị-sw600dp, v.v. Hãy xác định một chuỗi <string name = 'screenize' > 600dp </string> trong thư mục sw600dp, v.v. Nó thậm chí không cần phải là một chuỗi, nó có thể ở dạng ints.xml hoặcmens.xml.
ajacian81

7

Thông tin tuyệt vời, đúng với những gì tôi đang tìm kiếm! Tuy nhiên, sau khi thử điều này, tôi nhận thấy rằng khi sử dụng các chỉ số được đề cập ở đây, Nexus 7 (kiểu máy 2012) báo cáo có kích thước 1280x736. Tôi cũng có một chiếc Motorola Xoom chạy Jelly Bean và nó báo cáo sai độ phân giải 1280x752. Tôi tình cờ thấy bài đăng này ở đây xác nhận điều này. Về cơ bản, trong ICS / JB, các tính toán sử dụng các số liệu được đề cập ở trên dường như loại trừ các thứ nguyên của Thanh điều hướng. Một số nghiên cứu khác đã đưa tôi đến câu trả lời của Frank Nguyen ở đây sử dụng các phương pháp khác nhau sẽ cung cấp cho bạn kích thước pixel thô (hoặc thực) của màn hình. Thử nghiệm ban đầu của tôi cho thấy rằng đoạn mã sau đây từ Frank Correclty báo cáo kích thước trên Nexus 7 (phiên bản 2012 chạy phiên bản JB) và Motorola Xoom chạy JB của tôi:

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

3

Tôi có hai thiết bị Android có cùng độ phân giải

Kích thước màn hình đường chéo Device1 -> độ phân giải 480x800 -> 4,7 inch

Device2 -> độ phân giải 480x800 kích thước màn hình chéo -> 4.0 inch

Nó cung cấp cho cả hai thiết bị kích thước màn hình chéo -> 5,8

giải pháp cho vấn đề của bạn là ..

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

xem chi tiết tại đây ..


2

Họ cách mà Android quy định cụ thể kích cỡ màn hình là thông qua bốn kích thước tổng quát: nhỏ , bình thường , lớnxlarge .

Trong khi tài liệu Android nói rằng các nhóm kích thước không được dùng nữa

... các nhóm kích thước này không còn được dùng nữa để ủng hộ một kỹ thuật mới để quản lý kích thước màn hình dựa trên chiều rộng màn hình có sẵn. Nếu bạn đang phát triển cho Android 3.2 trở lên, hãy xem [Khai báo bố cục máy tính bảng cho Android 3.2] (hdpi (cao) ~ 240dpi) để biết thêm thông tin.

Nói chung, bộ định lượng kích thước lớn chỉ định máy tính bảng 7 ". Và bộ định lượng kích thước xlarge chỉ định máy tính bảng 10":

nhập mô tả hình ảnh ở đây

Điều thú vị khi kích hoạt trên bộ định lượng kích thước là bạn có thể đảm bảo rằng nội dung và mã của bạn phù hợp với nhau về nội dung sẽ sử dụng hoặc đường dẫn mã để kích hoạt.

Để truy xuất bộ định lượng kích thước trong mã, hãy thực hiện các cuộc gọi sau:

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

2

Bạn có thể sử dụng cách dưới đây để lấy kích thước màn hình theo đơn vị inch, dựa vào đó đơn giản bạn có thể kiểm tra đó là máy tính bảng hay điện thoại nào.

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

2

Tôi đang lưu trữ một giá trị trong thư mục giá trị cung cấp cho tôi màn hình là 7 inch hoặc 10 inch nhưng chúng tôi có thể làm điều đó cho bất kỳ thiết bị nào bằng cách sử dụng thư mục giá trị.

như tạo thư mục 2 giá trị khác nhau cho 2 thiết bị khác nhau. Nhưng điều này phụ thuộc vào yêu cầu.


1

Bạn sẽ phải thực hiện một chút tính toán bằng cách sử dụng dữ liệu do lớp DisplayMetrics cung cấp.

Bạn có heightPixel và widthPixels (độ phân giải màn hình tính bằng pixel)

Bạn cần đường chéo vì 'kích thước màn hình inch' luôn mô tả độ dài đường chéo. Bạn có thể lấy màn hình theo đường chéo theo pixel (sử dụng pythagore)

crossonalPixel = √ (heightPixel² + widthPixel²)

thì bạn có thể chuyển đổi giá trị pixel thành inch nhờ giá trị mật độDPI:

inchDiag = crossonalPixel / mật độDPI.

Tôi hy vọng mình không mắc lỗi ở đây, hãy lưu ý rằng các giá trị bạn nhận được từ lớp DisplayMetrics được cung cấp bởi hàm tạo, có vẻ như (trong một số trường hợp rất hiếm) chúng không được thiết lập tốt theo vật liệu vật lý ...

Điều này sẽ cung cấp cho bạn kích thước màn hình vật lý nhưng có lẽ không phải là cách tốt hơn để quản lý nhiều bố cục. Thêm về chủ đề này


1

Cách khác:

  • Tạo thêm 2 thư mục: giá trị-lớn + giá trị-xlarge

  • Đặt: <string name="screentype">LARGE</string>trong thư mục giá trị-lớn (string.xml)

  • Đặt: <string name="screentype">XLARGE</string>trong thư mục giá trị-xlarge (string.xml)

  • Trong mã:

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

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

    // từ 4 ~ 7 inch

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

    // từ 7 ~ 10 inch

    }


1

Thì đấy! 😀 Đây là tất cả những gì bạn cần để phân biệt máy tính bảng với điện thoại

1. Chức năng trợ giúp để lấy chiều rộng màn hình:

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

2. Chức năng tìm ra thiết bị có phải là máy tính bảng hay không

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

3. Cuối cùng, nếu bạn đang muốn thực hiện các thao tác khác nhau cho các kích thước thiết bị khác nhau:

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

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

0

Dưới đây là một số tiện ích mở rộng kotlin hữu ích:


    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
    }

Điều đó hoạt động! Nhưng bạn nên sử dụng DisplayMetrics thích hợp, ví dụ: từ Resourcestrong Context: resources.displayMetrics.isTablet() hoặc từ WindowManagerđó được lưu trữ trong Activity: val displayMetrics = DisplayMetrics() windowManager.defaultDisplay.getMetrics(displayMetrics) displayMetrics.isTablet()
Akbolat SSS
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.