Get screen width and height in Android

Question

How can I get the screen width and height and use this value in:

@Override protected void onMeasure(int widthSpecId, int heightSpecId) {
    Log.e(TAG, "onMeasure" + widthSpecId);
    setMeasuredDimension(SCREEN_WIDTH, SCREEN_HEIGHT - 
        game.findViewById(R.id.flag).getHeight());
}

Does this answer your question? How to get screen dimensions as pixels in Android — adamhurwitz.eth
– adamhurwitz.eth, Commented Aug 20, 2020 at 0:24
the update correct answer stackoverflow.com/a/67691009/4797289 — Rasoul Miri
– Rasoul Miri, Commented May 25, 2021 at 15:24

0xCursor · Accepted Answer · 2019-07-09 01:28:10Z

1240

Using this code, you can get the runtime display's width & height:

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

In a view you need to do something like this:

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

In some scenarios, where devices have a navigation bar, you have to check at runtime:

public boolean showNavigationBar(Resources resources)
{
    int id = resources.getIdentifier("config_showNavigationBar", "bool", "android");
    return id > 0 && resources.getBoolean(id);
}

If the device has a navigation bar, then count its height:

private int getNavigationBarHeight() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        DisplayMetrics metrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(metrics);
        int usableHeight = metrics.heightPixels;
        getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
        int realHeight = metrics.heightPixels;
        if (realHeight > usableHeight)
            return realHeight - usableHeight;
        else
            return 0;
    }
    return 0;
}

So the final height of the device is:

int height = displayMetrics.heightPixels + getNavigationBarHeight();

edited Jul 9, 2019 at 1:28

0xCursor

2,2784 gold badges18 silver badges35 bronze badges

answered Jan 20, 2011 at 7:28

Parag Chauhan

36k13 gold badges88 silver badges95 bronze badges

Sign up to request clarification or add additional context in comments.

18 Comments

Madeyedexter Over a year ago

Are the width and height swapped if the device is rotated?

Parag Chauhan Over a year ago

@Madeyedexter yes it will.

satur9nine Over a year ago

But you can no longer assume you are running on the default display.

Alex Over a year ago

or just simply use - getResources().getDisplayMetrics().heightPixels / getResources().getDisplayMetrics().widthPixels

Greelings Over a year ago

getDefaultDisplay() and getMetrics are deprecated

|

weigan · Accepted Answer · 2018-03-08 12:05:57Z

403

There is a very simple answer and without pass context

public static int getScreenWidth() {
    return Resources.getSystem().getDisplayMetrics().widthPixels;
}

public static int getScreenHeight() {
    return Resources.getSystem().getDisplayMetrics().heightPixels;
}

Note: if you want the height include navigation bar, use method below

WindowManager windowManager =
        (WindowManager) BaseApplication.getApplication().getSystemService(Context.WINDOW_SERVICE);
    final Display display = windowManager.getDefaultDisplay();
    Point outPoint = new Point();
    if (Build.VERSION.SDK_INT >= 19) {
        // include navigation bar
        display.getRealSize(outPoint);
    } else {
        // exclude navigation bar
        display.getSize(outPoint);
    }
    if (outPoint.y > outPoint.x) {
        mRealSizeHeight = outPoint.y;
        mRealSizeWidth = outPoint.x;
    } else {
        mRealSizeHeight = outPoint.x;
        mRealSizeWidth = outPoint.y;
    }

edited Mar 8, 2018 at 12:05

answered Jul 13, 2015 at 7:27

weigan

4,8151 gold badge15 silver badges14 bronze badges

6 Comments

Jaydev Over a year ago

How to get total screen height? This version of getScreenHeight excludes all bars.

L. Swifter Over a year ago

this works in most cases, but it can't get the real screen height if the navigation bar is visible. the height excludes the bar's height.

Carson Holzheimer Over a year ago

This produced unusual results for me in landscape mode

EpicPandaForce Over a year ago

This will cause trouble on screens with multiple displays (Foldables, Chrome OS laptops)

Hemant Aggarwal Over a year ago

The height of the navigation bar is not included in Android 4.4

|

dakshbhatt21 · Accepted Answer · 2013-07-19 06:28:30Z

48

Just to update the answer by parag and SpK to align with current SDK backward compatibility from deprecated methods:

int Measuredwidth = 0;  
int Measuredheight = 0;  
Point size = new Point();
WindowManager w = getWindowManager();

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)    {
    w.getDefaultDisplay().getSize(size);
    Measuredwidth = size.x;
    Measuredheight = size.y; 
}else{
    Display d = w.getDefaultDisplay(); 
    Measuredwidth = d.getWidth(); 
    Measuredheight = d.getHeight(); 
}

edited Jul 19, 2013 at 6:28

dakshbhatt21

3,6863 gold badges35 silver badges41 bronze badges

answered Jul 24, 2012 at 3:24

digiphd

2,3374 gold badges23 silver badges22 bronze badges

5 Comments

Sufian Over a year ago

@digiphd wouldn't Parang's code work on all API versions? All methods were introduced before API level 8 and I didn't find them deprecated at the android dev site.

Damien Diehl Over a year ago

@Sufian I had trouble getting non-0 return values from the getSize implementation on a Samsung Galaxy Mini (API 10) but the deprecated methods in this answer return correctly. So this is useful for older versions of Android.

Srishti Roy Over a year ago

@Sufian can we set new dimension to screen width and height?

cegprakash Over a year ago

this is depreciated now :(

LordWabbit Over a year ago

deprecated: the discouragement of use of some terminology, feature, design, or practice, typically because it has been superseded or is no longer considered efficient or safe, without completely removing it or prohibiting its use. depreciation: an actual reduction in the fair value of an asset or the allocation in accounting statements of the original cost of the assets to periods in which the assets are used

snipsnipsnip · Accepted Answer · 2022-12-27 00:51:39Z

36

Why not

DisplayMetrics displaymetrics = getResources().getDisplayMetrics();

Then use

displayMetrics.widthPixels

and

displayMetrics.heightPixels

edited Dec 27, 2022 at 0:51

snipsnipsnip

2,7232 gold badges38 silver badges41 bronze badges

answered Mar 25, 2014 at 6:47

wangqi060934

1,59116 silver badges23 bronze badges

4 Comments

Bram Stoker Over a year ago

On some devices widthPixels or heightPixels returns 0 in a Fragment's onViewCreated(). Really annoying if you want to calculate span count for GridLayoutManager.

JacksOnF1re Over a year ago

Because it won't give you the real screen size on most devices.

backspace83 Over a year ago

You need to add WindowInsets of system bars to get the real size in pixels on most devices

Luiz Felipe Apr 24 at 22:53

that's because a display is a display surface not a physical screen device, think of a foldable, or when you plug an external secondary display, the screen size of the fold is not the same as either of the split displays. there's only one case you need to full actual resolution, and that's when you're mirroring the display

Eric Aya · Accepted Answer · 2019-02-11 10:08:57Z

32

It’s very easy to get in Android:

int width  = Resources.getSystem().getDisplayMetrics().widthPixels;
int height = Resources.getSystem().getDisplayMetrics().heightPixels;

edited Feb 11, 2019 at 10:08

Eric Aya

70.2k36 gold badges190 silver badges266 bronze badges

answered Feb 11, 2019 at 10:04

Ness Tyagi

2,02826 silver badges18 bronze badges

2 Comments

jonadv Over a year ago

this returns 0 on an emulator

backspace83 Over a year ago

it won't give you the real screen size on most devices but just the area without window insets. I try it on a Google Pixel 4a and i get 2138px as height instead of the real one of 2340px. You need to add WindowInsets of system bars too

Rasoul Miri · Accepted Answer · 2021-05-25 15:23:40Z

32

You can get width and height from context

java:

  int width= context.getResources().getDisplayMetrics().widthPixels;
  int height= context.getResources().getDisplayMetrics().heightPixels;

kotlin

    val width: Int = context.resources.displayMetrics.widthPixels
    val height: Int = context.resources.displayMetrics.heightPixels

answered May 25, 2021 at 15:23

Rasoul Miri

12.3k1 gold badge75 silver badges84 bronze badges

1 Comment

android developer Over a year ago

Is it the available pixels, or it matches the resolution, or something else?

aminography · Accepted Answer · 2021-04-03 07:44:28Z

• `Kotlin Version` via `Extension Property`

If you want to know the size of the screen in pixels as well as dp, using these extension properties really helps:

DimensionUtils.kt

import android.content.Context
import android.content.res.Resources
import android.graphics.Rect
import android.graphics.RectF
import android.os.Build
import android.util.DisplayMetrics
import android.view.WindowManager
import kotlin.math.roundToInt

/**
 * @author aminography
 */

private val displayMetrics: DisplayMetrics by lazy { Resources.getSystem().displayMetrics }

/**
 * Returns boundary of the screen in pixels (px).
 */
val screenRectPx: Rect
    get() = displayMetrics.run { Rect(0, 0, widthPixels, heightPixels) }

/**
 * Returns boundary of the screen in density independent pixels (dp).
 */
val screenRectDp: RectF
    get() = screenRectPx.run { RectF(0f, 0f, right.px2dp, bottom.px2dp) }

/**
 * Returns boundary of the physical screen including system decor elements (if any) like navigation
 * bar in pixels (px).
 */
val Context.physicalScreenRectPx: Rect
    get() = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        (applicationContext.getSystemService(Context.WINDOW_SERVICE) as WindowManager)
            .run { DisplayMetrics().also { defaultDisplay.getRealMetrics(it) } }
            .run { Rect(0, 0, widthPixels, heightPixels) }
    } else screenRectPx

/**
 * Returns boundary of the physical screen including system decor elements (if any) like navigation
 * bar in density independent pixels (dp).
 */
val Context.physicalScreenRectDp: RectF
    get() = physicalScreenRectPx.run { RectF(0f, 0f, right.px2dp, bottom.px2dp) }

/**
 * Converts any given number from pixels (px) into density independent pixels (dp).
 */
val Number.px2dp: Float
    get() = this.toFloat() / displayMetrics.density

/**
 * Converts any given number from density independent pixels (dp) into pixels (px).
 */
val Number.dp2px: Int
    get() = (this.toFloat() * displayMetrics.density).roundToInt()

Usage:

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val widthPx = screenRectPx.width()
        val heightPx = screenRectPx.height()
        println("[PX] screen width: $widthPx , height: $heightPx")

        val widthDp = screenRectDp.width()
        val heightDp = screenRectDp.height()
        println("[DP] screen width: $widthDp , height: $heightDp")

        println()
        
        val physicalWidthPx = physicalScreenRectPx.width()
        val physicalHeightPx = physicalScreenRectPx.height()
        println("[PX] physical screen width: $physicalWidthPx , height: $physicalHeightPx")

        val physicalWidthDp = physicalScreenRectDp.width()
        val physicalHeightDp = physicalScreenRectDp.height()
        println("[DP] physical screen width: $physicalWidthDp , height: $physicalHeightDp")
    }
}

Result:

When the device is in portrait orientation:

[PX] screen width: 1440 , height: 2392
[DP] screen width: 360.0 , height: 598.0

[PX] physical screen width: 1440 , height: 2560
[DP] physical screen width: 360.0 , height: 640.0

When the device is in landscape orientation:

[PX] screen width: 2392 , height: 1440
[DP] screen width: 598.0 , height: 360.0

[PX] physical screen width: 2560 , height: 1440
[DP] physical screen width: 640.0 , height: 360.0

This code fails to take into account the height of the navigation bar.
@AndroidDev: Thank you for reporting the issue. Please use Context.physicalScreenRectPx and Context.physicalScreenRectDp to get the real dimension of the screen.

Sergio · Accepted Answer · 2022-02-22 14:54:28Z

21

Some methods, applicable for retrieving screen size, are deprecated in API Level 31, including Display.getRealMetrics() and Display.getRealSize(). Starting from API Level 30 we can use WindowManager#getCurrentWindowMetrics(). The clean way to get screen size is to create some Compat class, e.g.:

object ScreenMetricsCompat {
    private val api: Api =
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) ApiLevel30()
        else Api()

    /**
     * Returns screen size in pixels.
     */
    fun getScreenSize(context: Context): Size = api.getScreenSize(context)

    @Suppress("DEPRECATION")
    private open class Api {
        open fun getScreenSize(context: Context): Size {
            val display = context.getSystemService(WindowManager::class.java).defaultDisplay
            val metrics = if (display != null) {
                DisplayMetrics().also { display.getRealMetrics(it) }
            } else {
                Resources.getSystem().displayMetrics
            }
            return Size(metrics.widthPixels, metrics.heightPixels)
        }
    }

    @RequiresApi(Build.VERSION_CODES.R)
    private class ApiLevel30 : Api() {
        override fun getScreenSize(context: Context): Size {
            val metrics: WindowMetrics = context.getSystemService(WindowManager::class.java).currentWindowMetrics
            return Size(metrics.bounds.width(), metrics.bounds.height())
        }
    }
}

Calling ScreenMetricsCompat.getScreenSize(this).height in Activity we can get a screen height.

edited Feb 22, 2022 at 14:54

answered Nov 23, 2021 at 20:27

Sergio

31k22 gold badges143 silver badges159 bronze badges

1 Comment

Islam Khaled Over a year ago

In class Api you can use ContextCompat.getSystemService(context, WindowManager::class.java)?.defaultDisplay not context.getSystemService(WindowManager::class.java).defaultDisplay to target APIs less than 23 safely

duggu · Accepted Answer · 2013-09-26 04:43:55Z

14

Try below code :-

1.

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
int width = size.x;
int height = size.y;

2.

Display display = getWindowManager().getDefaultDisplay(); 
int width = display.getWidth();  // deprecated
int height = display.getHeight();  // deprecated

or

int width = getWindowManager().getDefaultDisplay().getWidth(); 
int height = getWindowManager().getDefaultDisplay().getHeight();

3.

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

metrics.heightPixels;
metrics.widthPixels;

edited Sep 26, 2013 at 4:43

answered May 7, 2013 at 10:24

duggu

38.5k12 gold badges121 silver badges114 bronze badges

3 Comments

Mohit Over a year ago

don't you think 2 = 4

Mohit Over a year ago

Means your method 2 is equal to method 4

android developer Over a year ago

Is it possible to get the "natural" resolution of the device? meaning that no matter if you rotate the screen, you will get the same values for width&height, and that if it's a tablet that's meant to be used horizontally, it will return the width as the large one instead of the height ?

Mattia Ferigutti · Accepted Answer · 2022-03-09 14:25:29Z

12

I suggest you create extension functions.

/**
 * Return the width and height of the screen
 */
val Context.screenWidth: Int
  get() = resources.displayMetrics.widthPixels

val Context.screenHeight: Int
  get() = resources.displayMetrics.heightPixels

/**
 * Pixel and Dp Conversion
 */
val Float.toPx get() = this * Resources.getSystem().displayMetrics.density
val Float.toDp get() = this / Resources.getSystem().displayMetrics.density

val Int.toPx get() = (this * Resources.getSystem().displayMetrics.density).toInt()
val Int.toDp get() = (this / Resources.getSystem().displayMetrics.density).toInt()

answered Mar 9, 2022 at 14:25

Mattia Ferigutti

3,8482 gold badges22 silver badges25 bronze badges

Comments

Micer · Accepted Answer · 2015-12-17 11:48:43Z

11

DisplayMetrics lDisplayMetrics = getResources().getDisplayMetrics();
int widthPixels = lDisplayMetrics.widthPixels;
int heightPixels = lDisplayMetrics.heightPixels;

edited Dec 17, 2015 at 11:48

Micer

9,0193 gold badges84 silver badges78 bronze badges

answered Dec 17, 2015 at 10:12

Shubham

5314 silver badges11 bronze badges

Comments

Patrick · Accepted Answer · 2025-04-25 05:51:19Z

11

As getMetrics and getRealMetrics are deprecated, Google recommends to determine the screen width and height as follows:

WindowMetrics windowMetrics = getActivity().getWindowManager().getMaximumWindowMetrics();
Rect bounds = windowMetrics.getBounds();
int widthPixels = bounds.width();
int heightPixels = bounds.height();

However, I've figured out another method that gives me the same results:

Display display = requireActivity().getDisplay()
Display.Mode mode = display.getMode();
int widthPixels = mode.getPhysicalWidth();
int heightPixels = mode.getPhysicalHeight();

edited Apr 25 at 5:51

answered Jul 9, 2021 at 21:02

Patrick

2143 silver badges13 bronze badges

5 Comments

Kumar Over a year ago

This is the only answer that works in Android R

Matthew Nantes Over a year ago

Where did you get display.getMode()?

Patrick Over a year ago

You will get it from here: developer.android.com/reference/android/view/Display#getMode()

desgraci Over a year ago

Still doesn't explain where did the display comes from.

Luiz Felipe Apr 24 at 23:02

display comes from the Activity, requireActivity returns the activity class, that code was made to be used from a Fragment.

EpicPandaForce · Accepted Answer · 2018-11-12 09:43:56Z

9

None of the answers here work correctly for Chrome OS multiple displays, or soon-to-come Foldables.

When looking for the current configuration, always use the configuration from your current activity in getResources().getConfiguration(). Do not use the configuration from your background activity or the one from the system resource. The background activity does not have a size, and the system's configuration may contain multiple windows with conflicting sizes and orientations, so no usable data can be extracted.

So the answer is

val config = context.getResources().getConfiguration()
val (screenWidthPx, screenHeightPx) = config.screenWidthDp.dp to config.screenHeightDp.dp

answered Nov 12, 2018 at 9:43

EpicPandaForce

81.7k28 gold badges269 silver badges451 bronze badges

Comments

Silvia H · Accepted Answer · 2019-11-25 15:29:36Z

8

For kotlin user's

fun Activity.displayMetrics(): DisplayMetrics {
   val displayMetrics = DisplayMetrics()
   windowManager.defaultDisplay.getMetrics(displayMetrics)
   return displayMetrics
}

And in Activity you could use it like

     resources.displayMetrics.let { displayMetrics ->
        val height = displayMetrics.heightPixels
        val width = displayMetrics.widthPixels
    }

Or in fragment

    activity?.displayMetrics()?.run {
        val height = heightPixels
        val width = widthPixels
    }

edited Nov 25, 2019 at 15:29

Silvia H

8,3977 gold badges32 silver badges33 bronze badges

answered Nov 20, 2018 at 7:27

Ali mohammadi

1,89926 silver badges27 bronze badges

Comments

android developer · Accepted Answer · 2023-01-18 19:54:18Z

Full way to do it, that returns the true resolution (including when the user has changed the resolution) is to use "getRealSize".

I've noticed that all other available functions, including the ones the docs say to use instead of this - have some cases that the result is smaller.

Here's the code to do it:

            WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
            Point size = new Point();
            wm.getDefaultDisplay().getRealSize(size);
            final int width = size.x, height = size.y;

And since this can change on different orientation, here's a solution (in Kotlin), to get it right no matter the orientation:

/**
 * returns the natural orientation of the device: Configuration.ORIENTATION_LANDSCAPE or Configuration.ORIENTATION_PORTRAIT .<br></br>
 * The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalOrientation(context: Context): Int {
    //based on : http://stackoverflow.com/a/9888357/878126
    val windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val config = context.resources.configuration
    val rotation = windowManager.defaultDisplay.rotation
    return if ((rotation == Surface.ROTATION_0 || rotation == Surface.ROTATION_180) && config.orientation == Configuration.ORIENTATION_LANDSCAPE || (rotation == Surface.ROTATION_90 || rotation == Surface.ROTATION_270) && config.orientation == Configuration.ORIENTATION_PORTRAIT)
        Configuration.ORIENTATION_LANDSCAPE
    else
        Configuration.ORIENTATION_PORTRAIT
}

/**
 * returns the natural screen size (in pixels). The result should be consistent no matter the orientation of the device
 */
@JvmStatic
fun getScreenNaturalSize(context: Context): Point {
    val screenNaturalOrientation = getScreenNaturalOrientation(context)
    val wm = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    val point = Point()
    wm.defaultDisplay.getRealSize(point)
    val currentOrientation = context.resources.configuration.orientation
    if (currentOrientation == screenNaturalOrientation)
        return point
    else return Point(point.y, point.x)
}

SMBiggs · Accepted Answer · 2023-01-30 21:08:00Z

7

After trying lots of versions above, I figured out an answer in Kotlin. It accurately returns the resolutions that are advertised for the devices. Please let me know if this does not work on older devices--I only have relatively new ones at the moment.

This solution uses no deprecated functions (as of Jan 2023).

private fun getScreenHeight() : Int {
    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        val windowMetrics = windowManager.currentWindowMetrics
        val rect = windowMetrics.bounds
        rect.bottom
    } else {
        resources.displayMetrics.heightPixels
    }
}

answered Jan 30, 2023 at 21:08

SMBiggs

11.8k6 gold badges74 silver badges91 bronze badges

6 Comments

kallis Over a year ago

This gave me 2030 but actual is 2160. Android 9

SMBiggs Over a year ago

@kallis Really? Which device are you using? I'd like to chase this down and figure out the details. It's a shame that something so basic has always been such a pain on Android.

kallis Over a year ago

The device is Redmi Note 5 pro

SMBiggs Over a year ago

That looks like a nice phone. But unfortunately I don't have access to it or anything similar. Do any of the other techniques listed above give you the correct screen height? To be off by 130 pixels feels like there is some navigation/status/app bar that is not being calculated. Hmmm.

kallis Over a year ago

I ended up using val outPoint = Point() view.display.getRealSize(outPoint) . It is working consistently over all device. I took this from google's github project that was last updated on 17 Apr, but the doc says this method is deprecated. Maybe they are not even sure about themselves.

|

Cristiana Chavez · Accepted Answer · 2013-12-18 10:28:49Z

6

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

answered Dec 18, 2013 at 10:28

Cristiana Chavez

11.6k5 gold badges58 silver badges56 bronze badges

Comments

Pang · Accepted Answer · 2018-02-05 06:58:52Z

6

Get the value of screen width and height.

Display display = getWindowManager().getDefaultDisplay();
Point size = new Point();
display.getSize(size);
width = size.x;
height = size.y;

edited Feb 5, 2018 at 6:58

Pang

10.2k146 gold badges87 silver badges126 bronze badges

answered Jan 21, 2015 at 0:38

Anil Singhania

84513 silver badges10 bronze badges

Comments

Mohit Yadav · Accepted Answer · 2020-09-15 15:24:28Z

6

As an android official document said for the default display use Context#getDisplay() because this method was deprecated in API level 30.

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

This code given below is in kotlin and is written accodring to the latest version of Android help you determine width and height:

fun getWidth(context: Context): Int {
    var width:Int = 0
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        val displayMetrics = DisplayMetrics()
        val display: Display? = context.getDisplay()
        display!!.getRealMetrics(displayMetrics)
        return displayMetrics.widthPixels
    }else{
        val displayMetrics = DisplayMetrics()
        this.windowManager.defaultDisplay.getMetrics(displayMetrics)
        width = displayMetrics.widthPixels
        return width
    }
}

fun getHeight(context: Context): Int {
    var height: Int = 0
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
        val displayMetrics = DisplayMetrics()
        val display = context.display
        display!!.getRealMetrics(displayMetrics)
        return displayMetrics.heightPixels
    }else {
        val displayMetrics = DisplayMetrics()
        this.windowManager.defaultDisplay.getMetrics(displayMetrics)
        height = displayMetrics.heightPixels
        return height
    }
}

edited Sep 15, 2020 at 15:24

answered Sep 15, 2020 at 14:50

Mohit Yadav

1571 gold badge3 silver badges12 bronze badges

3 Comments

dilshan Over a year ago

Can you give a complete example for this

Mohit Yadav Over a year ago

u can copy the code and call the functions like var one= getHeight(this) and the value of the display's height will be stored in the variable one as the functions return the height and width values when called.

VSim Jul 30 at 20:45

getRealMetrics is also deprecated.

DevWM · Accepted Answer · 2021-07-20 09:40:24Z

6

fun Activity.getRealScreenSize(): Pair<Int, Int> { //<width, height>
return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
    val size = Point()
    display?.getRealSize(size)
    Pair(size.x, size.y)
} else {
    val size = Point()
    windowManager.defaultDisplay.getRealSize(size)
    Pair(size.x, size.y)

}}

This is an extension function and you can use in your activity in this way:

 override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    val pair = getRealScreenSize()
    pair.first //to get width
    pair.second //to get height
}

edited Jul 20, 2021 at 9:40

answered Jul 15, 2021 at 19:50

DevWM

1141 silver badge6 bronze badges

2 Comments

Taslim Oseni Over a year ago

Code-only answers are low quality answers.

DevWM Over a year ago

@TaslimOseni I updated my answer by example to use

Harsha · Accepted Answer · 2019-12-13 08:46:21Z

5

I use the following code to get the screen dimensions

getWindow().getDecorView().getWidth()
getWindow().getDecorView().getHeight()

answered Dec 13, 2019 at 8:46

Harsha

1,7662 gold badges20 silver badges24 bronze badges

1 Comment

hordurh Over a year ago

This is not technically the screen dimensions but this is helpful since these dimensions do not contain stuff like status- and bottom bar

RelativeGames · Accepted Answer · 2021-06-02 09:36:52Z

5

Seems like all these answers fail for my Galaxy M51 with Android 11. After doing some research around I found this code :

WindowMetrics windowmetrics = MainActivity.getWindowManager().getCurrentWindowMetrics();
Rect rect = windowmetrics.getBounds();
int width = rect.right;
int height =rect.bottom;

shows my true device resolution of 1080x2400, the rest only return 810x1800.

answered Jun 2, 2021 at 9:36

RelativeGames

1,5932 gold badges20 silver badges29 bronze badges

1 Comment

user1608385 Over a year ago

Requires API 30

Tunaki · Accepted Answer · 2016-03-20 14:35:24Z

4

Display display = ((WindowManager) this.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
int mWidthScreen = display.getWidth();
int mHeightScreen = display.getHeight();

edited Mar 20, 2016 at 14:35

Tunaki

138k46 gold badges370 silver badges443 bronze badges

answered Mar 20, 2016 at 14:21

Rahul Yadav

1436 bronze badges

1 Comment

deyanm Over a year ago

Deprecated, use DisplayMetrics()

Satendra · Accepted Answer · 2017-11-29 05:29:40Z

4

public class DisplayInfo {
    int screen_height=0, screen_width=0;
    WindowManager wm;
    DisplayMetrics displaymetrics;

    DisplayInfo(Context context) {
        getdisplayheightWidth(context);
    }

    void getdisplayheightWidth(Context context) {
        wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        displaymetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(displaymetrics);
        screen_height = displaymetrics.heightPixels;
        screen_width = displaymetrics.widthPixels;
    }

    public int getScreen_height() {
        return screen_height;
    }

    public int getScreen_width() {
        return screen_width;
    }
}

edited Nov 29, 2017 at 5:29

Satendra

6,8554 gold badges29 silver badges48 bronze badges

answered Jan 31, 2017 at 14:53

Habibur Rahman Ovie

2812 silver badges6 bronze badges

Comments

Hemant Shori · Accepted Answer · 2015-05-13 12:09:04Z

3

Methods shown here are deprecated/outdated but this is still working.Require API 13

check it out

Display disp= getWindowManager().getDefaultDisplay();
Point dimensions = new Point();
disp.getSize(size);
int width = size.x;
int height = size.y;

edited May 13, 2015 at 12:09

answered Jan 19, 2015 at 6:11

Hemant Shori

2,5031 gold badge24 silver badges20 bronze badges

Comments

Kishan Donga · Accepted Answer · 2020-08-20 11:17:17Z

3

As an android official document said for the default display use Context#getDisplay() because this method was deprecated in API level 30.

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

This bowl of code help to determine width and height.

public static int getWidth(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    Display display = context.getDisplay();
    if (display != null) {
        display.getRealMetrics(displayMetrics);
        return displayMetrics.widthPixels;
    }
    return -1;
}

For the Height:

public static int getHeight(Context context) {
    DisplayMetrics displayMetrics = new DisplayMetrics();
    Display display = context.getDisplay();
    if (display != null) {
        display.getRealMetrics(displayMetrics);
        return displayMetrics.heightPixels;
    }
    return -1;
}

answered Aug 20, 2020 at 11:17

Kishan Donga

3,2133 gold badges26 silver badges39 bronze badges

3 Comments

dilshan Over a year ago

Does this require special permission in AndroidManifiest.xml

Kishan Donga Over a year ago

No there is not any special permission required for the same.

dilshan Over a year ago

@Krishan Donga Thank you so much for your quick reply....

NAP-Developer · Accepted Answer · 2018-06-05 08:44:12Z

2

Try this code for Kotlin

 val display = windowManager.defaultDisplay
 val size = Point()
 display.getSize(size)
 var DEVICE_WIDTH = size.x
 var DEVICE_HEIGHT = size.y

answered Jun 5, 2018 at 8:44

NAP-Developer

3,7962 gold badges27 silver badges41 bronze badges

Comments

Tim · Accepted Answer · 2017-08-18 10:32:46Z

1

Just use the function below that returns width and height of the screen size as an array of integers

private int[] getScreenSIze(){
        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        int h = displaymetrics.heightPixels;
        int w = displaymetrics.widthPixels;

        int[] size={w,h};
        return size;

    }

On your onCreate function or button click add the following code to output the screen sizes as shown below

 int[] screenSize= getScreenSIze();
        int width=screenSize[0];
        int height=screenSize[1];
        screenSizes.setText("Phone Screen sizes \n\n  width = "+width+" \n Height = "+height);

edited Aug 18, 2017 at 10:32

Tim

43.6k19 gold badges138 silver badges152 bronze badges

answered Jan 20, 2017 at 7:44

Daniel Nyamasyo

2,3221 gold badge28 silver badges28 bronze badges

Comments

ChrisF · Accepted Answer · 2021-05-21 17:56:26Z

1

I updated answer for Kotlin language!

For Kotlin: You should call Window Manager and get metrics. After that easy way.

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

How can we use it effectively in independent activity way with Kotlin language?

Here, I created a method in general Kotlin class. You can use it in all activities.

private val T_GET_SCREEN_WIDTH:String = "screen_width"
private val T_GET_SCREEN_HEIGHT:String = "screen_height"

private fun getDeviceSizes(activity:Activity, whichSize:String):Int{

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

    return when (whichSize){
        T_GET_SCREEN_WIDTH -> displayMetrics.widthPixels
        T_GET_SCREEN_HEIGHT -> displayMetrics.heightPixels
        else -> 0 // Error
    }
}

edited May 21, 2021 at 17:56

ChrisF

138k31 gold badges265 silver badges335 bronze badges

answered Feb 24, 2020 at 14:53

Caner Kaşeler

7,86860 silver badges45 bronze badges

1 Comment

Micer Over a year ago

Maybe even better solution would be to create an extension function for Activity class.

Deniz Babat · Accepted Answer · 2022-11-22 08:03:43Z

1

val displayMetrics = DisplayMetrics()
windowManager.defaultDisplay.getMetrics(displayMetrics)

var width = displayMetrics.widthPixels
var height = displayMetrics.heightPixels

answered Nov 22, 2022 at 8:03

Deniz Babat

3142 silver badges6 bronze badges

2 Comments

Aman Thakur Over a year ago

defaultDisplay is deprecated, but it works for now.

Luiz Felipe Apr 24 at 22:55

it is deprecated now because display is a display surface not a physical screen device, think of a foldable, or when you plug an external secondary display, the screen size of the fold is not the same as either of the split displays. I think it will cause confusion and that's why you should get the display from the context, not from the windowmanager

Collectives™ on Stack Overflow

Get screen width and height in Android

37 Answers 37

18 Comments

6 Comments

5 Comments

4 Comments

2 Comments

1 Comment

• `Kotlin Version` via `Extension Property`

DimensionUtils.kt

Usage:

Result:

2 Comments

1 Comment

3 Comments

Comments

Comments

5 Comments

Comments

Comments

Comments

6 Comments

Comments

Comments

3 Comments

2 Comments

1 Comment

1 Comment

1 Comment

Comments

Comments

3 Comments

Comments

Comments

1 Comment

2 Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

37 Answers 37

18 Comments

6 Comments

5 Comments

4 Comments

2 Comments

1 Comment

• Kotlin Version via Extension Property

Usage:

Result:

2 Comments

1 Comment

3 Comments

Comments

Comments

5 Comments

Comments

Comments

Comments

6 Comments

Comments

Comments

3 Comments

2 Comments

1 Comment

1 Comment

1 Comment

Comments

Comments

3 Comments

Comments

Comments

1 Comment

2 Comments

Linked

Related

• `Kotlin Version` via `Extension Property`