如何在安卓中以编程方式获取屏幕尺寸

Android将屏幕尺寸定义为普通大XLarge等。

它会自动在相应文件夹中的静态资源之间进行选择。我需要在我的 java 代码中提供有关当前设备的这些数据。DisplayMetrics仅提供有关当前设备密度的信息。没有关于屏幕尺寸的可用信息。

我确实在这里找到了 grep 代码中的 ScreenSize 枚举但是，对于 4.0 SDK，这似乎不适用于我。有没有办法获得这些信息？

将此代码复制并粘贴到您的Activity中，当它被执行时，它将Toast设备的屏幕尺寸类别。

int screenSize = getResources().getConfiguration().screenLayout &
        Configuration.SCREENLAYOUT_SIZE_MASK;
String toastMsg;
switch(screenSize) {
    case Configuration.SCREENLAYOUT_SIZE_LARGE:
        toastMsg = "Large screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_NORMAL:
        toastMsg = "Normal screen";
        break;
    case Configuration.SCREENLAYOUT_SIZE_SMALL:
        toastMsg = "Small screen";
        break;
    default:
        toastMsg = "Screen size is neither large, normal or small";
}
Toast.makeText(this, toastMsg, Toast.LENGTH_LONG).show();

private static String getScreenResolution(Context context)
{
    WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
    Display display = wm.getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    display.getMetrics(metrics);
    int width = metrics.widthPixels;
    int height = metrics.heightPixels;
    return "{" + width + "," + height + "}";
}

我认为这是一段非常简单的简单代码！

public Map<String, Integer> deriveMetrics(Activity activity) {
    try {
        DisplayMetrics metrics = new DisplayMetrics();
        if (activity != null) {
            activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
        }
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("screenWidth", Integer.valueOf(metrics.widthPixels));
        map.put("screenHeight", Integer.valueOf(metrics.heightPixels));
        map.put("screenDensity", Integer.valueOf(metrics.densityDpi));
        return map;
    } catch (Exception err) {
        ; // just use zero values
        return null;
    }
}

此方法现在可以在任何地方独立使用。无论您想在哪里获取有关设备屏幕的信息

，请执行以下操作：

        Map<String, Integer> map = deriveMetrics2(this);
        map.get("screenWidth");
        map.get("screenHeight");
        map.get("screenDensity");

希望这可能对那里的人有所帮助，并且可能会发现它更容易使用。如果我需要重新更正或改进，请不要犹豫，让我知道！:-)

干杯！！！

DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int width = displayMetrics.widthPixels;
int height = displayMetrics.heightPixels;

获取 DisplayMetrics 的方法：

val dm = activity.resources.displayMetrics

val dm = DisplayMetrics() 
activity.windowManager.defaultDisplay.getMetrics(dm)

val dm = DisplayMetrics（）val wm = context.getSystemService（Context.WINDOW_SERVICE） as WindowManager哼..defaultDisplay.getMetrics（dm）

然后得到

屏幕密度以每英寸点数表示。可能是DENSITY_LOW、DENSITY_MEDIUM或DENSITY_HIGH

dm.densityDpi

可用显示大小的绝对高度（以像素为单位）。

dm.heightPixels

可用显示大小的绝对宽度（以像素为单位）。

dm.widthPixels

X 维度中每英寸屏幕的确切物理像素。

dm.xdpi

Y 维度中每英寸屏幕的确切物理像素。

dm.ydpi

显示指标

您可以使用此代码获取以像素为单位的显示大小。

Display display = getWindowManager().getDefaultDisplay();
SizeUtils.SCREEN_WIDTH = display.getWidth();
SizeUtils.SCREEN_HEIGHT = display.getHeight();

带装饰（包括按钮栏）：

private static String getScreenResolution(Context context) {
    DisplayMetrics metrics = new DisplayMetrics();
    ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRealMetrics(metrics);
    return "{" + metrics.widthPixels + "," + metrics.heightPixels + "}";
}

无装饰：

private static String getScreenResolution(Context context) {
    DisplayMetrics metrics = new DisplayMetrics();
    ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getMetrics(metrics);
    return "{" + metrics.widthPixels + "," + metrics.heightPixels + "}";
}

区别在于 Display 类的方法 getMetrics（） 与 getRealMetrics（）。

代码将按以下格式为您提供结果：宽 x 高

String displayResolution = getResources().getDisplayMetrics().widthPixels + "x" + getResources().getDisplayMetrics().heightPixels;

Simon-

不同的

屏幕尺寸具有不同的像素密度。手机上的 4 英寸显示屏可能具有或多或少的像素，然后说 26 英寸电视。如果我理解正确，他想检测当前屏幕的尺寸组是小、正常、大和超大。我唯一能想到的是检测像素密度并使用它来确定屏幕的实际尺寸。

我的几个应用程序都需要这个，以下代码是我解决问题的方法。只是在onCreate中显示代码。这是一个独立的应用程序，可在任何设备上运行以返回屏幕信息。

setContentView(R.layout.activity_main);
    txSize = (TextView) findViewById(R.id.tvSize);
    density = (TextView) findViewById(R.id.density);
    densityDpi = (TextView) findViewById(R.id.densityDpi);
    widthPixels = (TextView) findViewById(R.id.widthPixels);
    xdpi = (TextView) findViewById(R.id.xdpi);
    ydpi = (TextView) findViewById(R.id.ydpi);
    Configuration config = getResources().getConfiguration();
    if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_LARGE) {
        Toast.makeText(this, "Large screen", Toast.LENGTH_LONG).show();
        txSize.setText("Large screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_NORMAL) {
        Toast.makeText(this, "Normal sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Normal sized screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_SMALL) {
        Toast.makeText(this, "Small sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Small sized screen");
    } else if ((getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
        Toast.makeText(this, "xLarge sized screen", Toast.LENGTH_LONG)
                .show();
        txSize.setText("Small sized screen");
    } else {
        Toast.makeText(this,
                "Screen size is neither large, normal or small",
                Toast.LENGTH_LONG).show();
        txSize.setText("Screen size is neither large, normal or small");
    }
    Display display = getWindowManager().getDefaultDisplay();
    DisplayMetrics metrics = new DisplayMetrics();
    display.getMetrics(metrics);
    Log.i(TAG, "density :" + metrics.density);
    density.setText("density :" + metrics.density);
    Log.i(TAG, "D density :" + metrics.densityDpi);
    densityDpi.setText("densityDpi :" + metrics.densityDpi);
    Log.i(TAG, "width pix :" + metrics.widthPixels);
    widthPixels.setText("widthPixels :" + metrics.widthPixels);
    Log.i(TAG, "xdpi :" + metrics.xdpi);
    xdpi.setText("xdpi :" + metrics.xdpi);
    Log.i(TAG, "ydpi :" + metrics.ydpi);
    ydpi.setText("ydpi :" + metrics.ydpi);

和一个简单的 XML 文件

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity" >
<TextView
    android:id="@+id/tvSize"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/density"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/densityDpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/widthPixels"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/xdpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
     />
<TextView
    android:id="@+id/ydpi"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    />

如果您处于非活动状态，即片段，适配器，模型类或任何其他不扩展的java类Activity则getResources()将不起作用。可以在片段中使用getActivity()，也可以使用传递给相应类的context。

mContext.getResources()

我建议创建一个类，比如 Utils，它将具有用于共同工作的方法/方法。这样做的好处是，您可以在调用此方法的应用中的任何位置使用单行代码获得所需的结果。

下面的算法可用于确定哪个类别将用于在静态资源之间进行选择，并且还可以满足较新的XX和XXX高密度

    DisplayMetrics displayMetrics = new DisplayMetrics();
    activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
    mDensityDpi = displayMetrics.densityDpi;
    mDensity = displayMetrics.density;
    mDisplayWidth = displayMetrics.widthPixels;
    mDisplayHeight = displayMetrics.heightPixels;
    String densityStr = "Unknown";
    int difference, leastDifference = 9999;
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_LOW);
    if (difference < leastDifference) {
        leastDifference = difference;
        densityStr = "LOW";
    }
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_MEDIUM);
    if (difference < leastDifference) {
        leastDifference = difference;
        densityStr = "MEDIUM";
    }
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_HIGH);
    if (difference < leastDifference) {
        leastDifference = difference;
        densityStr = "HIGH";
    }
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_XHIGH);
    if (difference < leastDifference) {
        leastDifference = difference;
        densityStr = "XHIGH";
    }
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_XXHIGH);
    if (difference < leastDifference) {
        leastDifference = difference;
        densityStr = "XXHIGH";
    }
    difference = Math.abs(mDensityDpi - DisplayMetrics.DENSITY_XXXHIGH);
    if (difference < leastDifference) {
        densityStr = "XXXHIGH";
    }
    Log.i(TAG, String.format("Display [h,w]: [%s,%s] Density: %s Density DPI: %s [%s]", mDisplayHeight, mDisplayWidth, mDensity, mDensityDpi, densityStr));

在 Kotlin 中获取屏幕分辨率或屏幕尺寸

fun getScreenResolution(context: Context): Pair<Int, Int> {
    try {
        val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
        val display = wm.defaultDisplay
        val metrics = DisplayMetrics()
        display.getMetrics(metrics)
        val width = metrics.widthPixels
        val height = metrics.heightPixels
        //Log.d(AppData.TAG, "screenSize: $width, $height")
        return Pair(width, height)
    } catch (error: Exception) {
        Log.d(AppData.TAG, "Error : autoCreateTable()", error)
    }
    return Pair(0, 0)
}

相关内容

最新更新

热门标签：