Обнаружение 7-дюймового и 10-дюймового планшета программно
Есть ли способ программно определить, является ли устройство, на котором установлено приложение, 7-дюймовым планшетом или 10-дюймовым планшетом?
11 ответов
Вы можете использовать DisplayMetrics чтобы получить всю информацию об экране, на котором работает ваше приложение.
Во-первых, мы создаем DisplayMetrics метрика объекта:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
Отсюда мы можем получить информацию, необходимую для определения размера дисплея:
int widthPixels = metrics.widthPixels;
int heightPixels = metrics.heightPixels;
Это вернет абсолютное значение ширины и высоты в пикселях, поэтому 1280x720 для Galaxy SIII, Galaxy Nexus и т. Д.
Обычно это не помогает само по себе, так как, когда мы работаем на устройствах Android, мы обычно предпочитаем работать с пикселями, независимыми от плотности, dip.
Вы получаете density экрана с помощью metrics Опять же, в виде масштабного коэффициента для устройства, которое основано на Android Design Resources для mdpi, hdpi и т.п. 
float scaleFactor = metrics.density;
Исходя из этого результата, мы можем вычислить количество пикселей, независимых от плотности, для определенной высоты или ширины.
float widthDp = widthPixels / scaleFactor
float heightDp = heightPixels / scaleFactor
Результат, который вы получите от этого, поможет вам решить, с каким типом экрана вы работаете, в сочетании с примерами конфигурации Android, которые дают вам относительное значение dp для каждого размера экрана:
- 320dp: типичный экран телефона (240x320 точек на дюйм, 320x480 точек на дюйм, 480x800 точек на дюйм и т. Д.).
- 480 точек на дюйм: планшет-миниатюра типа Streak (480x800 точек на дюйм).
- 600 точек на дюйм: 7-дюймовый планшет (600x1024 точек на дюйм).
- 720 точек на дюйм: 10-дюймовый планшет (720x1280 точек на дюйм, 800x1280 точек на дюйм и т. Д.).
Используя приведенную выше информацию, мы знаем, что если наименьшая ширина устройства превышает 600dp, устройство представляет собой 7-дюймовый планшет, если оно превышает 720dp, устройство представляет собой 10-дюймовый планшет.
Мы можем определить наименьшую ширину, используя min функция Math класс, проходящий в heightDp и widthDp вернуть smallestWidth,
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
}
И вот как вы рассчитываете, с каким устройством вы работаете.
Там нет ничего, что говорит 7" или же 10" НАСКОЛЬКО МНЕ ИЗВЕСТНО. Есть примерно два способа получить размеры экрана, которые система использует при декодировании растровых изображений и еще много чего. Они оба найдены в приложении 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 точек на дюйм, 320x480 точек на дюйм, 480x800 точек на дюйм и т. Д.).
- 480 точек на дюйм: планшет-миниатюра типа Streak (480x800 точек на дюйм).
- 600 точек на дюйм: 7-дюймовый планшет (600x1024 точек на дюйм).
- 720 точек на дюйм: 10-дюймовый планшет (720x1280 точек на дюйм, 800x1280 точек на дюйм и т. Д.).
Второе - это DisplayMetrics объект, полученный getContext().getResources().getDisplayMetrics(), В том, что у вас есть:
DisplayMetrics#density - логическая плотность отображения.
DisplayMetrics#densityDpi - Плотность экрана, выраженная в точках на дюйм.
DisplayMetrics#heightPixels - Абсолютная высота дисплея в пикселях.
DisplayMetrics#widthPixels - Абсолютная ширина дисплея в пикселях.
DisplayMetrics#xdpi - Точные физические пиксели на дюйм экрана в измерении X.
DisplayMetrics#ydpi - Точные физические пиксели на дюйм экрана в Y-измерении.
Это удобно, если вам нужно точное количество пикселей на экране, а не плотность. Тем не менее, важно отметить, что это все пиксели экрана. Не только те, которые вам доступны.
Поместите этот метод в 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 дюймов.
Вышеуказанное не всегда работает при переключении портрета и пейзажа.
Если вы нацелены на уровень API 13+, это легко, как описано выше - используйте Configuration.smallestScreenWidthDp, а затем протестируйте соответственно:
resources.getConfiguration().smallestScreenWidthDp
В противном случае, если вы можете себе это позволить, используйте следующий метод, который является очень точным, чтобы обнаружить 600dp (как 6") против 720dp (как 10"), позволяя системе сказать вам:
1) Добавьте в layout-sw600dp и layout-sw720dp (и, если применимо, его ландшафт) невидимое представление с правильным идентификатором, например:
Для 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) Затем по коду, например, Activity, протестируйте соответственно:
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();
}
Отличная информация, именно то, что я искал! Однако, попробовав это, я обнаружил, что при использовании метрик, упомянутых здесь, отчеты Nexus 7 (модель 2012 года) имеют размеры 1280x736. У меня также есть Motorola Xoom под управлением Jelly Bean, и он неправильно сообщает о разрешении 1280x752. Я наткнулся на этот пост здесь, который подтверждает это. По сути, в ICS/JB расчеты с использованием упомянутых выше показателей, по-видимому, исключают размеры панели навигации. Еще несколько исследований привели меня к ответу Фрэнка Нгуена, в котором используются разные методы, которые дадут вам необработанные (или реальные) размеры экрана в пикселях. Мое первоначальное тестирование показало, что следующий код из исправления Фрэнка сообщает о размерах на 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();
}
Они определяют, как Android определяет размеры экрана, используя четыре обобщенных размера: маленький, нормальный, большой и большой.
В то время как в документации 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);
У меня два андроид устройства с одинаковым разрешением
Device1 -> разрешение экрана 480х800, размер экрана -> 4,7 дюйма
Device2 -> разрешение экрана 480х800, размер экрана -> 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);
подробности смотрите здесь..
Вы можете использовать метод ниже, чтобы получить размер экрана в дюймах, исходя из того, что вы просто можете проверить, какой планшет или телефон устройство.
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;
}
Я сохранял значение в папке значений, которое дает мне экран 7 дюймов или 10 дюймов, но мы можем сделать это для любого устройства, используя папку значений.
Например, создать папку с разными значениями для двух разных устройств. Но эта вещь зависит от требования.
Вуаля! Это все, что вам нужно, чтобы отличить планшеты от телефонов.
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;
}
Вам нужно будет немного вычислить, используя данные, предоставленные классом DisplayMetrics.
У вас есть heightPixel и widthPixels (разрешение экрана в пикселях)
Вам нужна диагональ, поскольку "размер экрана в дюймах" всегда описывает длину диагонали. Вы можете получить диагональ экрана в пикселях (используя пифагор)
diagonalPixel = √ (heightPixel² + widthPixels²)
затем вы можете преобразовать значение пикселя в дюймы благодаря значению densityDPI:
inchDiag = diagonalPixel / densityDPI.
Я надеюсь, что здесь я не допустил ошибок, имейте в виду, что значения, которые вы получаете от класса DisplayMetrics, задаются конструктором, кажется (в очень редких случаях), что они не установлены должным образом в соответствии с физическим материалом...
Это даст вам физический размер экрана, но это, вероятно, не лучший способ управления несколькими макетами. Больше на эту тему
По-другому:
Создайте еще 2 папки: values-large + values-xlarge
Положил:
<string name="screentype">LARGE</string>в большой папке значений (strings.xml)Положил:
<string name="screentype">XLARGE</string>в папке values-xlarge (strings.xml)В коде:
String mType = getString (R.string.screentype);
if (mType! = null && mType.equals ("LARGE") {
// от 4 до 7 дюймов
} else if (mType! = null && mType.equals ("XLARGE") {
// от 7 до 10 дюймов
}
Вот несколько полезных расширений kotlin:
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
}