Есть ли способ программно определить, установлено ли устройство, на котором установлено приложение, 7-дюймовый планшет или 10-дюймовый планшет?
Обнаружение 7-дюймового и 10-дюймового планшета программно
Ответ 1
Вы можете использовать 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 для mdpi, hdpi и т.д.
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 и т.д.).
Используя приведенную выше информацию, мы знаем, что если наименьшая ширина устройства больше 600 дп, устройство представляет собой 7-дюймовый планшет, если он больше 720 дп, устройство представляет собой планшет размером 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
}
И как вы рассчитываете, с каким устройством вы работаете.
Ответ 2
Там ничего не сказано 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.
Это удобно, если вам нужно точное количество пикселей экрана, а не плотность. Однако важно отметить, что это все пиксели экрана. Не только те, которые доступны вам.
Ответ 3
поместите этот метод в 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-дюймового размера.
Ответ 4
Вышеупомянутое не всегда работает при переключении портрета и пейзажа.
Если вы ориентируетесь на уровень 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();
}
Ответ 5
Отличная информация, именно то, что я искал! Однако, пробовав это, я обнаружил, что при использовании упомянутых здесь метрик модель Nexus 7 (модель 2012 года) имеет размеры 1280x736. У меня также есть Motorola Xoom работает Jelly Bean, и он неправильно сообщает разрешение 1280x752. Я наткнулся на этот пост здесь, который подтверждает это. В принципе, в ICS/JB расчеты с использованием упомянутых выше показателей, как представляется, исключают размеры панели навигации. Еще несколько исследований привели меня к Frank Nguyen здесь, здесь, где используются разные методы, которые дадут вам необработанные (или реальные) пиксельные размеры экрана. Мое начальное тестирование показало, что следующий код от Frank correclty сообщает о размерах на Nexus 7 (модельный ряд JB 2012), а моя 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();
}
Ответ 6
У меня есть два устройства 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);
см. подробнее здесь..
Ответ 7
В способе, которым 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);
Ответ 8
Вы можете использовать метод ниже, чтобы получить размер экрана в дюймах, на основе этого просто вы можете проверить, какой планшет или телефон устройство.
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;
}
Ответ 9
Я хранили значение в папке значений, которая дает мне экран 7 дюймов или 10 вкл, но мы можем сделать это для любого устройства, использующего папку значений.
как создать папку с разными значениями 2 для разных устройств. Но это зависит от требования.
Ответ 10
Вам придется немного вычислить, используя данные, предоставленные классом DisplayMetrics.
У вас есть heightPixel и widthPixels (разрешение экрана в пикселях)
Вам нужна диагональ, так как размер "дюймового экрана" всегда описывает длину диагонали. Вы можете получить диагональ экрана в пикселях (используя pythagore)
diagonalPixel = √ (heightPixel² + widthPixels²)
то вы можете преобразовать значение пикселя в дюймы благодаря значению плотностиDPI:
inchDiag = diagonalPixel/densityDPI.
Надеюсь, я не ошибся здесь, имейте в виду, что значения, которые вы получаете из класса DisplayMetrics, задаются конструктором, он появляется (в очень редких случаях), что они плохо настроены в соответствии с физическим материалом...
Это даст вам физический размер экрана, но, вероятно, не лучший способ управления несколькими макетами. Подробнее об этой теме
Ответ 11
Другой способ:
-
Создайте еще две папки: values-large + values-xlarge
-
Поместите:
<string name="screentype">LARGE</string>в папку с большими значениями (strings.xml) -
Поместите:
<string name="screentype">XLARGE</string>в значениях-xlarge folder (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 дюймов
}
Ответ 12
Вуаля! All Это все, что вам нужно, чтобы отличить планшеты от телефонов
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;
}