How do I get the ScreenSize programmatically in android

Copy and paste this code into your Activity and when it is executed it will Toast the device's screen size category.

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

You can get display size in pixels using this code.

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

simon-

Different screen sizes have different pixel densities. A 4 inch display on your phone could have more or less pixels then say a 26 inch TV. If Im understanding correctly he wants to detect which of the size groups the current screen is, small, normal, large, and extra large. The only thing I can think of is to detect the pixel density and use that to determine the actual size of the screen.

I need this for a couple of my apps and the following code was my solution to the problem. Just showing the code inside onCreate. This is a stand alone app to run on any device to return the screen info.

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

And a simple XML file

<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"
/>

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

I think it is a pretty straight forward simple piece of code!

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

This method now can be used anywhere independently. Wherever you want to get information about device screen do it as follows:

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

Hope this might be helpful to someone out there and may find it easier to use. If I need to re-correct or improve please don't hesitate to let me know! :-)

Cheers!!!

DisplayMetrics displayMetrics = new DisplayMetrics();


getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);


int width = displayMetrics.widthPixels;


int height = displayMetrics.heightPixels;

If you are in a non-activity i.e. Fragment, Adapter, Model class or any other java class that do not extends Activity simply getResources() will not work. You can use getActivity() in fragment or use context that you pass to the corresponding class.

mContext.getResources()

I would recommend making a class say Utils that will have method/Methods for the common work. The benefit for this is you can get desired result with single line of code anywhere in the app calling this method.

The algorithm below can be used to identify which category will be used for picking between the static resources and also caters for the newer XX and XXX high densities

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

With decorations (including button bar):

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

Without decorations:

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

The difference is the method getMetrics() vs getRealMetrics() of the Display class.

Ways to get DisplayMetrics:

1.

val dm = activity.resources.displayMetrics

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

3. val dm = DisplayMetrics() val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager wm..defaultDisplay.getMetrics(dm)

then get

The screen density expressed as dots-per-inch. May be either DENSITY_LOW, DENSITY_MEDIUM, or DENSITY_HIGH

dm.densityDpi

The absolute height of the available display size in pixels.

dm.heightPixels

The absolute width of the available display size in pixels.

dm.widthPixels

The exact physical pixels per inch of the screen in the X dimension.

dm.xdpi

The exact physical pixels per inch of the screen in the Y dimension.

dm.ydpi

DisplayMetrics

Get screen resolution or screen size in 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)
}

The code will give you the result in the following format: width x height

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