Is there any way in Android to get the height of virtual keyboard of device

The question:

Is there any way in Android to get the height of the virtual keyboard displayed on the device in run time? Actually I want to show a text box above the keyboard.

The Solutions:

Below are the methods you can try. The first solution is probably the best. Try others if the first one doesn’t work. Senior developers aren’t just copying/pasting – they read the methods carefully & apply them wisely to each case.

Method 1

To solve this I have written a keyboardHeightProvider which can calculate the height of a floating soft keyboard. The Activity can be set to adjustNone or adjustPan in the AndroidManifest.xml.


Method 2

I tried many suggested methods for this, but none seemed to work for Android SDL. I think this is either because the SDL display is “full screen” or that it sits within an “AbsoluteLayout” and therefore the height of the “View” never actually changes. This method worked for me:

Getting the dimensions of the soft keyboard

Window mRootWindow = getWindow();
View mRootView = mRootWindow.getDecorView().findViewById(;
    new ViewTreeObserver.OnGlobalLayoutListener() {
    public void onGlobalLayout(){
        Rect r = new Rect();
        View view = mRootWindow.getDecorView();
        // r.left,, r.right, r.bottom

Method 3

Yes you can, with the help of Viewtree Observer and global layout listener, just try below mentioned steps

  1. Get the root view of your layout
  2. get the Viewtree observer for this root, and add a global layout listener on top of this.

now whenever soft keyboard is displayed android will re-size your screen and you will receive call on your listener. That’s it only thing you now need to do is calculate difference between height which your root view has after re-size and original size. If difference is more then 150 consider this as a keyboard has been inflated.

Below is a sample code

root.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener(){
     public void onGlobalLayout(){
           int heightDiff = root.getRootView().getHeight()- root.getHeight();
           // IF height diff is more then 150, consider keyboard as visible.  


Method 4

put the text box as parent bottom.


and in the manifest file make the soft input adjustresize


then the text box will move up when the keyboard appears.

Method 5

This method works with adjustNothing or any windowSoftInputMode on your activity.

<activity android:name=".MainActivity"

Using a PopupWindow, you can have separate “keyboard behaviour” for it, and it will notify you what the size of the keyboard is. The PopupWindow has the height of the screen, but 0px width, so you won’t see it, it won’t affect your activity, but will provide you with the information you need.

Create a class called KeyboardHeightProvider and add the following code:

public class KeyboardHeightProvider extends PopupWindow {
    public KeyboardHeightProvider(Context context, WindowManager windowManager, View parentView, KeyboardHeightListener listener) {

        LinearLayout popupView = new LinearLayout(context);
        popupView.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        popupView.getViewTreeObserver().addOnGlobalLayoutListener(() -> {
            DisplayMetrics metrics = new DisplayMetrics();

            Rect rect = new Rect();

            int keyboardHeight = metrics.heightPixels - (rect.bottom -;
            int resourceID = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
            if (resourceID > 0) {
                keyboardHeight -= context.getResources().getDimensionPixelSize(resourceID);
            if (keyboardHeight < 100) {
                keyboardHeight = 0;
            boolean isLandscape = metrics.widthPixels > metrics.heightPixels;
            boolean keyboardOpen = keyboardHeight > 0;
            if (listener != null) {
                listener.onKeyboardHeightChanged(keyboardHeight, keyboardOpen, isLandscape);


        setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE | WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        setBackgroundDrawable(new ColorDrawable(0)); -> showAtLocation(parentView, Gravity.NO_GRAVITY, 0, 0));

    public interface KeyboardHeightListener {
        void onKeyboardHeightChanged(int keyboardHeight, boolean keyboardOpen, boolean isLandscape);

Notice how the PopupWindow has its own setSoftInputMode(...), so it doesn’t matter what you set your activity to, the PopupWindow will still be affected by the keyboard opening or closing and will provide the parent activity of the height. If the height is >= 100 you can assume the keyboard is open.

To use it, simply instantiate it in your Activity’s onCreate(...) method after setContentView(...):

protected void onCreate(@Nullable Bundle savedInstanceState) {

    LinearLayout llRoot = findViewById(; //The root layout (Linear, Relative, Contraint, etc...)

    new KeyboardHeightProvider(this, getWindowManager(), llRoot, new KeyboardHeightProvider.KeyboardHeightListener() {
        public void onKeyboardHeightChanged(int keyboardHeight, boolean keyboardOpen, boolean isLandscape) {
            Log.i("keyboard listener", "keyboardHeight: " + keyboardHeight + " keyboardOpen: " + keyboardOpen + " isLandscape: " + isLandscape);

            //Do what you want or have to with the parameters..


Method 6

You can’t tell. No, really: you simply can’t tell.

The keyboard does not need to be any particular shape. It does not have to be placed at the bottom of the screen (many of the most popular options are not), it does not have to keep its current size when you change text fields (almost none do depending on the flags). It does not even have to be rectangular. It may also just take over the entire screen.

(copy of my answer on a similar question, Getting the dimensions of the soft keyboard )

Method 7

I’ve created a library project get android keyboard height, even when activities don’t use the adjustResize input mode.

Method 8

My solution is the combination of all above solutions. This solution is also hacky but solve the problem (atleast for me).

  1. I have places on temporary view with transparent background at the bottom of the screen.
  2. I have added android:windowSoftInputMode="adjustResize" flag in activity tag in manifest like @bill suggests.
  3. Now main story is in onGlobalLayout(). There i calculate the difference between the y axis of temp view and height of root view

    final View view = findViewById(;
    view.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
        public void onGlobalLayout() {
            int rootViewHeight = view.getRootView().getHeight();
            View tv = findViewById(;
            int location[] = new int[2];
            int height = (int) (location[1] + tv.getMeasuredHeight());
            deff = rootViewHeight - height;
            // deff is the height of soft keyboard

But anyways to solve the problem of @zeeshan0026 only a single flag in manifest android:windowSoftInputMode="adjustResize" is enough.

Method 9

I have used this to get keyboard height programmatically in android and tested it, please try this once:

myLayout.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {

                public void onGlobalLayout() {
                    // TODO Auto-generated method stub
                    Rect r = new Rect();

                    int screenHeight = parent.getRootView().getHeight();
                    int heightDifference = screenHeight - (r.bottom -;
                    Log.d("Keyboard Size", "Size: " + heightDifference);

                    //boolean visible = heightDiff > screenHeight / 3;

Thank you.

Method 10

As the navigation bars, keyboard, etc are added to the window, you can measure these insets to check if the keyboard is open or not. With Android R, you can measure the keyboard directly, but you can fall back to calculating the keyboard size from the insets for prior versions.

This works on Lollipop and up.

               .setOnApplyWindowInsetsListener(new View.OnApplyWindowInsetsListener() {
                   public WindowInsets onApplyWindowInsets(View v, WindowInsets insets) {
                       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                           mKeyboardShowing =
                                   insets.getInsets(WindowInsets.Type.ime()).bottom > 0;
                           if (mKeyboardShowing) {
                                       insets.getInsets(WindowInsets.Type.ime()).bottom -
                       } else {
                           mKeyboardShowing = getNavigationBarHeight() !=
                           if (mKeyboardShowing) {
                               setKeyboardHeight(insets.getSystemWindowInsetBottom() -
                       return v.onApplyWindowInsets(insets);

                   public int getNavigationBarHeight() {
                       boolean hasMenuKey = ViewConfiguration.get(MainActivity.this)
                       int resourceId = getResources().getIdentifier("navigation_bar_height",
                       if (resourceId > 0 && !hasMenuKey) {
                           return getResources().getDimensionPixelSize(resourceId);
                       return 0;

Method 11

Look no more!
I’ve been looking for a solution for this for a long time. After days of trying all the tricks suggested on SOF, I found the perfect solution that actually works.

This GitHub project demonstrates it the best way possible:

Have fun!

Method 12

I finally found the solution to get the height of soft/virtual keyboard. I cannot say this works on all devices, but I tried on some devices both real and emulator devices and it works. I tried on devices from Android API 16 to 29. It is a little bit tricky. Here is my analysis.

First, I tried to subtract between the height of the screen and height of visible frame on top of soft/virtual keyboard by using function of getHeightDifference() such as below. I found that at the first time the layout is created, right before the keyboard open on EditText’s focus, the difference height will depend on Android System Navigation Bar, either the Navigation Bar is shown inside the device screen or not. So, the value of heightDifference will be 0 if the Nav Bar outside the screen or greater than 0 if it is inside the screen. I’m using a variable of systemNavigationBarHeight with Integer object (instead of using primitive int data) to save the first value of that height difference with only one initialization, which I assume that is the height of Nav Bar.

And then in next code block, I check if next height difference is greater than the height of actual Navigation Bar in Android system (or 100 is default just in case if there is no Navigation Bar in Android system), then I subtract again with the value of systemNavigationBarHeight to get the real height of soft/virtual keyboard.

Hope this will help on someone who look up another answer.

public class MyActivity extends AppCompatActivity {

    protected void onCreate(Bundle savedInstanceState) {
                .addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
                    private Integer systemNavigationBarHeight = null;
                    public void onGlobalLayout() {
                        int heightDifference = getHeightDifference();
                        if (heightDifference > 0) {
                            if (systemNavigationBarHeight == null) {
                                /* Get layout height when the layout was created at first time */
                                systemNavigationBarHeight = heightDifference;
                        } else {
                            systemNavigationBarHeight = 0;

                        if (heightDifference > getDefaultNavigationBarHeight()) {
                            /* Keyboard opened */
                            int keyBoardHeight = heightDifference - systemNavigationBarHeight;
                        } else {
                            /* Keyboard closed */
    private int getHeightDifference() {
        Point screenSize = new Point();
        } else {

        Rect rect = new Rect();
        return screenSize.y - rect.bottom;
    private int getDefaultNavigationBarHeight() {
        int resourceId = getResources().getIdentifier("navigation_bar_height", "dimen", "android");
        if (resourceId > 0) {
            return getResources().getDimensionPixelSize(resourceId);
        return 100;

Method 13

A solution that I’ve found excellent for me, was to store a global bottom value, then to add a TreeView Observer and compare the new bottom value with the stored one. Using android:windowSoftInputMode="adjustResize"

private var bottom: Int = 0

override fun onCreate(savedInstanceState: Bundle?) {
    val rect = Rect()
    this.bottom = rect.bottom

    this.window.decorView.viewTreeObserver.addOnGlobalLayoutListener {
        val newRect = Rect()
        // the answer
        val keyboardHeight = this.bottom - newRect.bottom

        // also
        if (newRect.bottom < this.bottom) {
            //keyboard is open
        } else {
            //keyboard is hide

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Comment