Обнаружение 7-дюймового и 10-дюймового планшета программно

Вы можете использовать DisplayMetrics чтобы получить целую кучу информации о экране, на котором работает ваше приложение.

Во-первых, мы создаем объект метрики DisplayMetrics :

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

Из этого мы можем получить информацию, необходимую для определения размера дисплея:

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

Это вернет абсолютное значение ширины и высоты в пикселях, поэтому 1280×720 для Galaxy SIII, Galaxy Nexus и т. Д.

Обычно это не помогает само по себе, поскольку, когда мы работаем на устройствах Android, мы обычно предпочитаем работать с независимыми от плотности пикселями.

Вы снова получаете density экрана, используя metrics , в виде масштабного коэффициента для устройства, которое основано на ресурсах Android Design для mdpi , hdpi и т. Д.

 float scaleFactor = metrics.density; 

Из этого результата мы можем вычислить количество независимых от плотности пикселей, которые есть для определенной высоты или ширины.

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

Результат, который вы получите от этого, поможет вам решить, какой тип экрана вы работаете в сочетании с примерами конфигурации Android , которые дают вам относительный dp для каждого размера экрана:

• 320dp: обычный экран телефона (240×320 ldpi, 320×480 mdpi, 480×800 hdpi и т. Д.).
• 480dp: планшет Tweener, такой как Streak (480×800 mdpi).
• 600dp: 7-дюймовый планшет (600×1024 mdpi).
• 720dp: 10-дюймовый планшет (720×1280 mdpi, 800×1280 mdpi и т. Д.).

Используя приведенную выше информацию, мы знаем, что если наименьшая ширина устройства превышает 600 дп, устройство представляет собой 7-дюймовый планшет, если он больше 720 дп, устройство представляет собой планшет размером 10 дюймов.

Мы можем выработать наименьшую ширину, используя функцию min classа Math , передавая heightDp и widthDp чтобы вернуть smallestWidth widthDp .

 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" AFAIK. Существует примерно два способа получить размер экрана, который использует система при декодировании растровых изображений и еще много чего. Они оба найдены в объекте Resources приложения, найденном в Context .

Первый – это объект Configuration который может быть получен getContext().getResources().getConfiguration() . В нем у вас есть:

Configuration#densityDpi – 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: обычный экран телефона (240×320 ldpi, 320×480 mdpi, 480×800 hdpi и т. Д.).

• 480dp: планшет Tweener, такой как Streak (480×800 mdpi).
• 600dp: 7-дюймовый планшет (600×1024 mdpi).
• 720dp: 10-дюймовый планшет (720×1280 mdpi, 800×1280 mdpi и т. Д.).

Больше информации

Второй – объект 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-дюймового размера.

Отличная информация, именно то, что я искал! Однако, пробовав это, я обнаружил, что при использовании упомянутых здесь метрик модель Nexus 7 (модель 2012 года) имеет размеры 1280×736. У меня также есть Motorola Xoom работает Jelly Bean, и он неправильно сообщает разрешение 1280×752. Я наткнулся на этот пост, который подтверждает это. В принципе, в ICS / JB расчеты с использованием упомянутых выше показателей, как представляется, исключают размеры панели навигации. Еще несколько исследований привели меня к ответу Франка Нгуена, в котором используются разные методы, которые дадут вам необработанные (или реальные) пиксельные размеры экрана. Мое начальное тестирование показало, что следующий код от 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(); } 

Вышеупомянутое не всегда работает при переключении портрета и пейзажа.

Если вы ориентируетесь на уровень API 13+, это легко, как описано выше, – используйте Configuration.smallestScreenWidthDp, а затем протестируйте соответственно:

 resources.getConfiguration().smallestScreenWidthDp 

В противном случае, если вы можете себе это позволить, используйте следующий метод, который является очень точным подходом к обнаружению 600dp (например, 6 “) по сравнению с 720dp (например, 10”), позволяя системе сказать вам:

1) Добавьте в layout-sw600dp и layout-sw720dp (и, если применимо, его ландшафт) невидимое представление с соответствующим идентификатором, например:

Для 720, на layout-sw720dp:

Для 600, на layout-sw600dp:

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

У меня есть два устройства Android с одинаковым разрешением

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

см. подробности здесь ..

Они способ, которым Android определяет размеры экрана, – это четыре обобщенных размера: маленький , нормальный , большой и xlarge .

Хотя в документации на Android указано, что группы размеров устарели

… эти группы размеров устарели в пользу новой техники для управления размерами экрана на основе доступной ширины экрана. Если вы разрабатываете Android 3.2 и выше, см. [Объявление табличных макетов для Android 3.2] (hdpi (high) ~ 240dpi) для получения дополнительной информации.

Обычно спецификатор размера определяет спецификацию 7- дюймового планшета. А спецификатор размера xlarge определяет 10- дюймовый планшет:

Хорошая вещь о запуске на определителе размера – это то, что вы можете гарантировать, что ваши активы и код согласуются с тем, какой актив использовать или ввести код для активации.

Чтобы получить classификатор размера в коде, выполните следующие вызовы:

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

Вы можете использовать метод ниже, чтобы получить размер экрана в дюймах, на основе которого вы можете проверить, какой планшет или телефон устройство.

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

Вам придется немного вычислить, используя данные, заданные classом DisplayMetrics .

У вас есть heightPixel и widthPixels (разрешение экрана в пикселях)

Вам нужна диагональ, так как размер «дюймового экрана» всегда описывает длину диагонали. Вы можете получить диагональ экрана в пикселях (используя pythagore)

diagonalPixel = √ (высотаPixel² + ширинаPixels²)

то вы можете преобразовать значение пикселя в дюймы благодаря значению плотностиDPI:

inchDiag = diagonalPixel / densityDPI.

Надеюсь, что я здесь не ошибался, помните, что значения, которые вы получаете из classа DisplayMetrics, задаются конструктором, он появляется (в очень редких случаях), что они плохо настроены в соответствии с физическим материалом …

Это даст вам физический размер экрана, но, вероятно, не лучший способ управления несколькими макетами. Подробнее об этой теме

Другой путь:

• Создайте еще две папки: values-large + values-xlarge

• Поместите: LARGE в папку с большими значениями (strings.xml)

• Поместите: XLARGE в папку значений-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 дюймов

  }

Я хранили значение в папке значений, которая дает мне экран размером 7 дюймов или 10 дюймов, но мы можем сделать это для любого устройства, использующего папку значений.

например, создать папку с разными значениями для двух устройств. Но это зависит от требования.