Tutorial :Height of status bar in Android


What's the height of the status bar in Android? Is it always the same?

From my measurements it seems that it's 25dp, but I'm not sure if it has the same height on all platforms.

(I want to know this to properly implement a fade transition from an activity that doesn't have status bar to one that does)


this question was answered before... Height of statusbar?


Current method:

ok, the height of the status bar depends on the screen size, for example in a device with 240 X 320 screen size the status bar height is 20px, for a device with 320 X 480 screen size the status bar height is 25px, for a device with 480 x 800 the status bar height must be 38px

so i recommend to use this script to get the status bar height

Rect rectangle = new Rect();  Window window = getWindow();  window.getDecorView().getWindowVisibleDisplayFrame(rectangle);  int statusBarHeight = rectangle.top;  int contentViewTop =       window.findViewById(Window.ID_ANDROID_CONTENT).getTop();  int titleBarHeight= contentViewTop - statusBarHeight;       Log.i("*** Elenasys :: ", "StatusBar Height= " + statusBarHeight + " , TitleBar Height = " + titleBarHeight);   

(old Method) to get the Height of the status bar on the onCreate() method of your Activity, use this method:

public int getStatusBarHeight() {         int result = 0;        int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");        if (resourceId > 0) {            result = getResources().getDimensionPixelSize(resourceId);        }         return result;  }   


Out of all the code samples I've used to get the height of the status bar, the only one that actually appears to work in the onCreate method of an Activity is this:

public int getStatusBarHeight() {      int result = 0;      int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");      if (resourceId > 0) {          result = getResources().getDimensionPixelSize(resourceId);      }      return result;  }  

Apparently the actual height of the status bar is kept as an Android resource. The above code can be added to a ContextWrapper class (e.g. an Activity).

Found at http://mrtn.me/blog/2012/03/17/get-the-height-of-the-status-bar-in-android/


On MDPI devices, the status bar is 25px. We can use this as the base and multiply it by the density (rounded up) to get the status bar height on any device:

int statusBarHeight = Math.ceil(25 * context.getResources().getDisplayMetrics().density);  

For reference: ldpi=.75, mdpi=1, hdpi=1.5, xhdpi=2


Hardcoding the size or using reflection to get the value of status_bar_height is considered bad practice. Chris Banes talked about this in at the Droidcon New York. The recommended way of getting the status bar size is via the OnApplyWindowInsetsListener:

myView.setOnApplyWindowInsetsListener { view, insets -> {    val statusBarSize = insets.systemWindowInsetTop    return insets  }  

This was added in API 20 and is also backported via ViewAppCompat.


I've merged some solutions together:

public static int getStatusBarHeight(final Context context) {      final Resources resources = context.getResources();      final int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");      if (resourceId > 0)          return resources.getDimensionPixelSize(resourceId);      else          return (int) Math.ceil((VERSION.SDK_INT >= VERSION_CODES.M ? 24 : 25) * resources.getDisplayMetrics().density);      }  

another alternative:

    final View view = findViewById(android.R.id.content);      runJustBeforeBeingDrawn(view, new Runnable() {          @Override          public void run() {              int statusBarHeight = getResources().getDisplayMetrics().heightPixels - view.getMeasuredHeight();          }      });  

EDIT: Alternative to runJustBeforeBeingDrawn: https://stackoverflow.com/a/28136027/878126


According to Google design guidelines; height of status bar is 24 dp.

If you want get status bar height in pixels you can use below method:

private static int statusBarHeight(android.content.res.Resources res) {      return (int) (24 * res.getDisplayMetrics().density);  }  

which can be called from activity with:



this also work with the refrence link

public int getStatusBarHeight() {    int result = 0;    int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");    if (resourceId > 0) {        result = getResources().getDimensionPixelSize(resourceId);    }    return result;  }  


I have the same problem of having to get the status bar height in an onCreate. This works for me.

private static final int LOW_DPI_STATUS_BAR_HEIGHT = 19;    private static final int MEDIUM_DPI_STATUS_BAR_HEIGHT = 25;    private static final int HIGH_DPI_STATUS_BAR_HEIGHT = 38;  

Inside the onCreate:

DisplayMetrics displayMetrics = new DisplayMetrics();  ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getMetrics(displayMetrics);    int statusBarHeight;    switch (displayMetrics.densityDpi) {      case DisplayMetrics.DENSITY_HIGH:          statusBarHeight = HIGH_DPI_STATUS_BAR_HEIGHT;          break;      case DisplayMetrics.DENSITY_MEDIUM:          statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT;          break;      case DisplayMetrics.DENSITY_LOW:          statusBarHeight = LOW_DPI_STATUS_BAR_HEIGHT;          break;      default:          statusBarHeight = MEDIUM_DPI_STATUS_BAR_HEIGHT;  }  


http://developer.android.com/reference/android/util/DisplayMetrics.html http://developer.android.com/guide/practices/ui_guidelines/icon_design.html


Official height is 24dp, as is stated officially by Google on Android Design webpage.


Yes when i try it with View it provides the result of 25px. Here is the whole code :

public class SpinActivity extends Activity {      @Override      public void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);          LinearLayout lySpin = new LinearLayout(this);          lySpin.setOrientation(LinearLayout.VERTICAL);                 lySpin.post(new Runnable()          {              public void run()              {                  Rect rect = new Rect();                  Window window = getWindow();                  window.getDecorView().getWindowVisibleDisplayFrame(rect);                  int statusBarHeight = rect.top;                  int contentViewTop =                       window.findViewById(Window.ID_ANDROID_CONTENT).getTop();                  int titleBarHeight = contentViewTop - statusBarHeight;                  System.out.println("TitleBarHeight: " + titleBarHeight                       + ", StatusBarHeight: " + statusBarHeight);              }          }      }  }  


The default height used to be 25dp. With Android Marshmallow (API 23) the height was reduced to 24dp.


240x320 - 20px

320x480 - 25px

480x800+ - 38px


Try this:

    Rect rect = new Rect();      Window win = this.getWindow();      win.getDecorView().getWindowVisibleDisplayFrame(rect);      int statusBarHeight = rect.top;      int contentViewTop = win.findViewById(Window.ID_ANDROID_CONTENT).getTop();      int titleBarHeight = contentViewTop - statusBarHeight;      Log.d("ID-ANDROID-CONTENT", "titleBarHeight = " + titleBarHeight );  

it didn't work for me in the onCreate method for the activity, but did when I put it in an onClickListener and gave me a measurement of 25


the height of the status bar is 24dp in android 6.0

 <!-- Height of the status bar -->   <dimen name="status_bar_height">24dp</dimen>   <!-- Height of the bottom navigation / system bar. -->   <dimen name="navigation_bar_height">48dp</dimen>  

you can find the answer in the source code: frameworks\base\core\res\res\values\dimens.xml


To solve this, I used a combination approach. This is necessary as on tablets the system bar already subtracts it's pixels when display.getHeight() is called. So I first check if a system bar is present, and then Ben Claytons approach, which works fine on phones.

public int getStatusBarHeight() {      int statusBarHeight = 0;        if (!hasOnScreenSystemBar()) {          int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");          if (resourceId > 0) {              statusBarHeight = getResources().getDimensionPixelSize(resourceId);          }      }        return statusBarHeight;  }    private boolean hasOnScreenSystemBar() {      Display display = getWindowManager().getDefaultDisplay();      int rawDisplayHeight = 0;      try {          Method getRawHeight = Display.class.getMethod("getRawHeight");          rawDisplayHeight = (Integer) getRawHeight.invoke(display);      } catch (Exception ex) {      }        int UIRequestedHeight = display.getHeight();        return rawDisplayHeight - UIRequestedHeight > 0;  }  


Toggled Fullscreen Solution:

This solution may look like a workaround, but it actually accounts for whether your app is fullscreen (aka hiding the status bar) or not:

Display display = getWindowManager().getDefaultDisplay();  Point size = new Point(); display.getSize(size);  int barheight = size.y - findViewById(R.id.rootView).getHeight();  

This way, if your app is currently fullscreen, barheight will equal 0.

Personally I had to use this to correct absolute TouchEvent coordinates to account for the status bar as so:

@Override  public boolean onTouch(View view,MotionEvent event) {      Display display = getWindowManager().getDefaultDisplay();      Point size = new Point(); display.getSize(size);      int YCoord = (int)event.getRawY() - size.y + rootView.getHeight());  }  

And that will get the absolute y-coordinate whether the app be fullscreen or not.



On Android 4.1 and higher, you can set your application's content to appear behind the status bar, so that the content doesn't resize as the status bar hides and shows. To do this, use SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN. You may also need to use SYSTEM_UI_FLAG_LAYOUT_STABLE to help your app maintain a stable layout.

When you use this approach, it becomes your responsibility to ensure that critical parts of your app's UI (for example, the built-in controls in a Maps application) don't end up getting covered by system bars. This could make your app unusable. In most cases you can handle this by adding the android:fitsSystemWindows attribute to your XML layout file, set to true. This adjusts the padding of the parent ViewGroup to leave space for the system windows. This is sufficient for most applications.

In some cases, however, you may need to modify the default padding to get the desired layout for your app. To directly manipulate how your content lays out relative to the system bars (which occupy a space known as the window's "content insets"), override fitSystemWindows(Rect insets). The fitSystemWindows() method is called by the view hierarchy when the content insets for a window have changed, to allow the window to adjust its content accordingly. By overriding this method you can handle the insets (and hence your app's layout) however you want.

form: https://developer.android.com/training/system-ui/status.html#behind


If you know exactly the size VS height


for example in a device with 320 X 480 screen size the status bar height is 25px, for a device with 480 x 800 the status bar height must be 38px

then you can just get the width of your view / the screen size you can just use an if else statement to get the height of status bar


The reason why the top answer does not work for some people is because you cannot get the dimensions of a view until it is ready to render. Use an OnGlobalLayoutListener to get said dimensions when you actually can:

@Override  protected void onCreate(Bundle savedInstanceState) {      super.onCreate(savedInstanceState);      setContentView(R.layout.activity_main);        final ViewGroup decorView = (ViewGroup) this.getWindow().getDecorView();      decorView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {          @Override          public void onGlobalLayout() {              if (Build.VERSION.SDK_INT >= 16) {                  decorView.getViewTreeObserver().removeOnGlobalLayoutListener(this);              } else {                  // Nice one, Google                  decorView.getViewTreeObserver().removeGlobalOnLayoutListener(this);              }              Rect rect = new Rect();              decorView.getWindowVisibleDisplayFrame(rect);              rect.top; // This is the height of the status bar          }      }  }  

This is the most reliable method.


Thanks to @Niklas +1 this is the correct way to do it.

public class MyActivity extends Activity implements android.support.v4.View.OnApplyWindowInsetsListener {        Rect windowInsets;        @Override      public void onCreate(Bundle savedInstanceState) {          super.onCreate(savedInstanceState);            setContentView(R.layout.my_activity);            View rootview = findViewById(android.R.id.content);            android.support.v4.View.ViewCompat.setOnApplyWindowInsetsListener(rootview, this);      }        android.support.v4.View.WindowInsetsCompat android.support.v4.View.OnApplyWindowInsetsListener.OnApplyWindowInsets(View v, android.support.v4.View.WindowInsetsCompat insets)      {          windowInsets = new Rect();          windowInsets.set(insets.getSystemWindowInsetLeft(), insets.getSystemWindowInsetTop(), insets.getSystemWindowInsetRight(), insets.getSystemWindowInsetBottom());          //StatusBarHeight = insets.getSystemWindowInsetTop();            //Refresh/Adjust view accordingly            return insets;      }  }  

Please excuse me if the code isn't 100% correct, converted it from Xamarin C# but this is the just of it. Works with Notches, etc.


This issue recently became relevant for me because of the notch in my Pixel 3XL. I really liked android developer's solution, but I wanted to be able to get the status bar height at will, since it was specifically necessary for a full screen animation that I needed to play. The function below enabled a reliable query:

private val DEFAULT_INSET = 96  fun getInsets(view: View?): Int {       var inset = DEFAULT_INSET       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {//Safe because only P supports notches            inset = view?.rootWindowInsets?.stableInsetTop ?: DEFAULT_INSET       }       return inset  }    fun blurView(rootView: View?, a: SpacesActivity?) {      val screenBitmap = getBitmapFromView(rootView!!)      val heightDifference = getInsets(rootView)      val croppedMap = Bitmap.createBitmap(                      screenBitmap, 0, heightDifference,                      screenBitmap.width,                      screenBitmap.height - heightDifference)      val blurredScreen = blurBitmap(croppedMap)      if (blurredScreen != null) {           val myDrawable = BitmapDrawable(a!!.resources, blurredScreen)           a.errorHudFrameLayout?.background = myDrawable           a.appBarLayout?.visibility = View.INVISIBLE     }  }  

And then in the activity class:

fun blurView() {      this.runOnUiThread {          Helper.blurView(this)      }  }  

You will of course want to make pass a weak reference of the activity to the static Helper class method parameter, but for the sake of brevity I refrained in this example. The blurBitmapand errorHudFrameLayout are omitted for the same reason, since they don't directly pertain to obtaining the height of the status bar.

Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com
Next Post »