Обнаружение 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 и т.д. DPI scales

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-дюймовый планшет:

enter image description here

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

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

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