How to show and hide the Android soft keyboard

1. Introduction

If there is a need for input, there is usually a need to automatically pop up or close the soft keyboard. To be clear at the beginning, this article will talk about some details of popping up and closing the soft keyboard, and finally analyze it from the source code.

To operate the soft keyboard, you need to use InputMethodManager, which is a system service that can be obtained using Context.getSystemService(). Many key logic codes are implemented in InputMethodManagerService.

Special note: All the source codes analyzed in this article are based on the source code of Android 26.

2. Operating the soft keyboard

2.1 InputMethodManager

As mentioned earlier, if you want to operate the soft keyboard, you need to use InputMethodManager, which is a system service. If you want to get it, you can use getSystemService() to get it.

After all, it is a system service. For safety reasons, it is still necessary to judge it as null when using it to avoid null pointers.

2.2 Displaying the soft keyboard

In InputMethodManager, there are two methods showSoftInput() and showSoftInputFromInputMethod(), but in fact, only showSoftInput() is valid.

It has two overloaded methods, and we usually use its two-parameter method.

Here we only need to pass two parameters. It first needs a View. The soft keyboard is used for input, and input requires a View that receives the input content. Here, the View that receives the input is an EditText (but this is not necessary).

The second parameter flags is a flag. From the documentation on the method signature in the screenshot above, we can see that it accepts two parameters, 0 or SHOW_INPYT_IMPLICIT, but in fact, it has a third parameter, the other one is SHOW_FORCED.

You can see that 1 and 2 have special meanings. In fact, they do not affect the display. There are only some restrictions when hiding. These will be discussed later when you look at the source code. Generally, if there is no special need, we can just pass 0.

Now, let's briefly summarize the key points at which calling showSoftInput() will take effect:

1. The first parameter is EditText or its subclass.

Considering that the soft keyboard is for input, EditText is a control that receives input. However, this is not absolute. If it is not an EditText, the View must have two attributes: android:focusable="true" and android:focusableInTouchMode="true".

2. The first parameter must be focusable and has currently acquired the focus.

By default, EditText is allowed to get focus, but if there are multiple controls that can get focus in the layout, we need to let the View passed in get focus in advance. To get focus, you can use the requestFocus() method.

3. The layout must be loaded.

In onCreate(), if you call showSoftInput() immediately, it will not work. If you want to pop up the keyboard as soon as the page starts, you can set the android:windowSoftInputMode attribute on the Activity to complete it, or do a delayed loading, View.postDelayed() is also a solution.

So in the end, the complete code for displaying the soft keyboard is as follows.

2.3 Hide the soft keyboard

Although the showSoftInput() method is valid, there is no corresponding hideSoftInput() method if you want to hide the soft keyboard. However, there is a hideSoftInputFromWindow() method that can be used to hide the soft keyboard.

Let's first look at the signature of this method. It also has two methods that can be called.

It receives two parameters, the first one is an IBinder, you can directly pass a windowToken object of View.getWindowToken(). The second parameter is the flag to hide the soft keyboard, if there is no special requirement, just pass 0.

Note that although in principle you need to pass the windowToken of the View that was passed when the keyboard popped up, the actual situation is that you only need to pass the windowToken of any View that exists in the current layout ViewTree.

This is what the code for the final hidden software looks like.

2.4 Switching the keyboard pop-up and hidden

In InputMethodManager, a toggleSoftInput() method is also provided. As its name suggests, it can switch the soft keyboard between display and hiding.

This method receives two flags, which are the flags for controlling show and hide. Their meanings are the same as those of showSoftInput() and hideSoftInputFromWindow() introduced earlier, so there are no special requirements and just pass 0.

The toggleSoftInput() method does not require a View or windowToken to be passed, so it does not have some of the limitations of showSoftInput(), but it still needs to be called after the layout is drawn to have an effect.

Although this method has few restrictions, we basically don't use it. The main reason is that it is a switch method that will do the opposite operation according to the current state. This often leads to the fact that we cannot directly determine the current display state of the soft keyboard according to the method provided by InputMethodManager in the code, so we cannot determine the effect when calling it.

3. Source Code Analysis

3.1 Flag details

Some of the previous methods require passing a flag value, which is not described in detail in the document. Let's analyze the meaning of these flags from the perspective of the source code.

Let's first look at the showSoftInput() method.

It will eventually call the mService.showSoftInput() method. To find the final source code, you need to look at the code in InputMethodManagerService. The showSoftInput() method will eventually call showCurrentInputLocked().

The code of this method is very long, and we only care about the code related to flag.

As you can see, flag affects two fields, mShowExplicitlyRequested and mShowForced, and SHOW_FORCED is more aggressive.

The hideSoftInputFromWindow() method will eventually call the hideCurrentInputLocked() method in InputMethodManagerService.

The meaning can be seen from the log output when DEBUG == true. Here, the two flags passed for display and hiding are compared. In other words, if the flag is not used correctly, it may directly return false here, and the soft keyboard cannot be hidden. These details are clear when comparing the code, so I will not repeat them in the article.

So this is why it was mentioned earlier that if there is no special requirement, just pass 0 to circumvent this limitation.

3.2 How to determine whether the soft keyboard pops up

Since toggleSoftInput() can perform different operations depending on the current state of the soft keyboard, there must be a way to determine the current state of the soft keyboard.

Then let's continue tracking the source code of toggleSoftInput() method.

This method will eventually call the onToggleSoftInput() method of InputMethodService.

In this method, the isInputViewShow() method is used to determine whether the current soft keyboard is in the pop-up display state. However, we have no way to interact directly with the InputMethodService, so we have no way to directly get whether the current keyboard is displayed.

If you want to monitor the pop-up and retraction of the keyboard, you can use ViewTreeObserver.OnGlobalLayoutListener to monitor the layout adjustment and determine the pop-up and hide of the keyboard. We will talk about these details later.

4. KeyboardUtils

Now that we know the details of how to collapse and pop up the soft keyboard, let's write a helper class to solve this problem.

Here are the Java version and the Kotlin version.

4.1 Java version

 public class KeyboardUtils { 
 
 public   static void showKeyboard( View   view ) {
        InputMethodManager imm = (InputMethodManager) view .getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);
 if (imm != null ) {
 view .requestFocus();
            imm.showSoftInput( view , 0);
 }
 } 
 
 public   static void hideKeyboard( View   view ){
        InputMethodManager imm = (InputMethodManager) view .getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);
 if (imm != null ) {
            imm.hideSoftInputFromWindow( view .getWindowToken(),0);
 }
 }
 public   static void toggleSoftInput( View   view ){
        InputMethodManager imm = (InputMethodManager) view .getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);
 if (imm != null ) {
            imm.toggleSoftInput(0,0);
 }
 }
 }

4.2 Kotlin version

 object KeyboardktUtils{
    fun showKeyboard( view : View ) {
        val imm = view .context
                .getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
 if (imm != null ) {
 view .requestFocus()
            imm.showSoftInput( view , 0)
 }
 } 
 
    fun hideKeyboard( view : View ) {
        val imm = view .context
                .getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm?.hideSoftInputFromWindow( view .windowToken, 0)
 } 
 
    fun toggleSoftInput( view : View ) {
        val imm = view .context
                .getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm?.toggleSoftInput(0, 0)
 }
 }