Есть ли способ определить физическую высоту экрана андроида в сантиметрах или дюймах?

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

Есть ли где-нибудь метод в Android API для этого?

Источник

8 ответов

Решение

Используйте следующее:

    DisplayMetrics dm = new DisplayMetrics();
    getWindowManager().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);

Когда mWidthPixels и mHeightPixels взяты из кода ниже

private void setRealDeviceSizeInPixels()
{
    WindowManager windowManager = getWindowManager();
    Display display = windowManager.getDefaultDisplay();
    DisplayMetrics displayMetrics = new DisplayMetrics();
    display.getMetrics(displayMetrics);


    // since SDK_INT = 1;
    mWidthPixels = displayMetrics.widthPixels;
    mHeightPixels = displayMetrics.heightPixels;

    // includes window decorations (statusbar bar/menu bar)
    if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17)
    {
        try
        {
            mWidthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(display);
            mHeightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(display);
        }
        catch (Exception ignored)
        {
        }
    }

    // includes window decorations (statusbar bar/menu bar)
    if (Build.VERSION.SDK_INT >= 17)
    {
        try
        {
            Point realSize = new Point();
            Display.class.getMethod("getRealSize", Point.class).invoke(display, realSize);
            mWidthPixels = realSize.x;
            mHeightPixels = realSize.y;
        }
        catch (Exception ignored)
        {
        }
    }

См. Этот пост для справки: получить размеры экрана в пикселях

Источник

Для получения текущего размера используйте Math.round в конце.

 DisplayMetrics dm = new DisplayMetrics();
    getWindowManager().getDefaultDisplay().getMetrics(dm);
    double x = Math.pow(dm.widthPixels/dm.xdpi,2);
    double y = Math.pow(dm.heightPixels/dm.ydpi,2);
    double screenInches = Math.sqrt(x+y);
    Log.d("debug","Screen inches : " + screenInches);

screenInches=  (double)Math.round(screenInches * 10) / 10;
Источник

Android-разработчики экрана информации.

использование xdpi * widthPixels а также ydpi * heightPixels я могу получить то, что ты хочешь.

Источник

Следующий фрагмент кода поможет вам получить размер экрана в дюймах

public static double getScreenSizeInches(Activity activity){
    WindowManager windowManager = activity.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)
    if (Build.VERSION.SDK_INT >= 14 && Build.VERSION.SDK_INT < 17) {
        try{
            mWidthPixels = (Integer) Display.class.getMethod("getRawWidth").invoke(display);
            mHeightPixels = (Integer) Display.class.getMethod("getRawHeight").invoke(display);
        } catch (Exception ignored) {}
    }

    // includes window decorations (statusbar bar/menu bar)
    if (Build.VERSION.SDK_INT >= 17) {
        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();
    activity.getWindowManager().getDefaultDisplay().getMetrics(dm);
    double x = Math.pow(mWidthPixels / dm.xdpi, 2);
    double y = Math.pow(mHeightPixels / dm.ydpi, 2);
    return Math.sqrt(x + y);
}

Надеюсь, это поможет.

Источник

Я использовал это, чтобы получить реальный размер

final DisplayMetrics metrics = new DisplayMetrics();
final WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
    windowManager.getDefaultDisplay().getRealMetrics(metrics);
}
else {
    windowManager.getDefaultDisplay().getMetrics(metrics);
}
int realHeight = metrics.heightPixels; // This is real height
int realWidth = metrics.widthPixels; // This is real width
Источник

Я пробовал большинство способов, упомянутых в других ответах, но эти методы не работают на определенных устройствах. Вот небольшой мой вклад в решение этой проблемы. Код написан на Котлине

Получите объект DisplayMetrics:

    val manager = mContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val displayMetrics = DisplayMetrics()
    manager.getDefaultDisplay().getMetrics(displayMetrics)

Рассчитайте ширину экрана в дюймах следующим образом:

    val widthInDotPoints : Double = (displayMetrics.widthPixels * (160 * 1.0 /displayMetrics.densityDpi))
    val widthInInches : Double = width / displayMetrics.xdpi

Здесь я рассчитал ширину устройства в точках (dp), используя widthPixels, а затем преобразовал ее в ширину в дюймах. Я использовал 160 .ie DisplayMetrics.DENSITY_MEDIUM в качестве коэффициента преобразования для преобразования widthPixels в widthInDotPoints.

Точно так же рассчитайте высоту экрана в дюймах:

    val heightInDotPoints : Double = (displayMetrics.heightPixels * (160 * 1.0 /displayMetrics.densityDpi))
    val heightInInches : Double = height / displayMetrics.ydpi
Источник

Некоторые устройства, такие как пиксель, возвращают xdpi, ydpi неверен. Таким образом, вы можете рассчитать основу плотности.

      fun getScreenSizeInInches(context: Context): Float {
    try {
        val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
        val display = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            context.display
        } else {
            windowManager.defaultDisplay
        }

        val metrics = DisplayMetrics()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            display?.getRealMetrics(metrics)
        } else {
            display?.getMetrics(metrics)
        }
        // Calculate the diagonal size in inches using Pythagorean theorem
        var xdpi = metrics.xdpi
        if (xdpi < 160) {
            xdpi = getDPIFromDensity(metrics.density)
        }
        var ydpi = metrics.ydpi
        if (ydpi < 160) {
            ydpi = getDPIFromDensity(metrics.density)
        }
        val widthInInches = metrics.widthPixels / xdpi
        val heightInInches = metrics.heightPixels / ydpi
        val diagonalInInches = sqrt(widthInInches.pow(2) + heightInInches.pow(2))
        Log.d("diagonalInInches", metrics.toString() + "\n" + diagonalInInches.toString())
        return diagonalInInches
    } catch (e: Exception) {
        return 6.0f
    }
}

/*
* Some device pixel return xdpi, ydpi not correct.
* */
private fun getDPIFromDensity(density: Float): Float {
    val dpi = 160 * density
    Log.d("getDPIFromDensity", dpi.toString())
    return dpi
}
Источник

Вы должны использовать плотность экрана, чтобы рассчитать это.

Context.getResources().getDisplayMetrics().density

Согласно документации:

Логическая плотность дисплея. Это коэффициент масштабирования для модуля, независимого от плотности пикселей, где один DIP - это один пиксель на экране с разрешением приблизительно 160 точек на дюйм (например, экран 240x320, 1,5"x2"), обеспечивающий базовую линию отображения системы. Таким образом, на экране с разрешением 160 точек на дюйм это значение плотности будет 1; на экране с разрешением 120 точек на дюйм это будет 0,75; и т.п.

Это значение не совсем соответствует реальному размеру экрана (как указано в xdpi и ydpi, а скорее используется для масштабирования размера общего пользовательского интерфейса в шагах на основе грубых изменений в dpi дисплея. Например, экран 240x320 будет иметь плотность равна 1, даже если его ширина составляет 1,8", 1,3" и т. д. Однако, если разрешение экрана увеличится до 320x480, а размер экрана останется 1,5"x2", плотность будет увеличена (вероятно, до 1,5).

Источник
Другие вопросы по тегам