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?
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?
Câu trả lời:
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ẽ density
sử dụng metrics
lạ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
, hdpi
v.v.
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 min
hàm của Math
lớp, truyền vào heightDp
và widthDp
trả 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 metrics
phươ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.
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 đó.
resources.getConfiguration().smallestScreenWidthDp
từ 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.
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 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.).
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.
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!
đặ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.
Đ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();
}
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();
}
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 ..
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ớn và xlarge .
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":
Đ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);
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;
}
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.
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
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. 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;
}
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
}
Resources
trong Context
: resources.displayMetrics.isTablet()
hoặc từ WindowManager
đó được lưu trữ trong Activity
: val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)
displayMetrics.isTablet()