关闭/隐藏Android软键盘

Close/hide the Android Soft Keyboard

我的布局中有一个EditText和一个Button

在编辑字段中写入内容并单击Button之后,我想隐藏虚拟键盘。我假设这是一段简单的代码,但是在哪里可以找到它的一个例子呢?


您可以使用inputMethodManager强制android隐藏虚拟键盘,调用hideSoftInputFromWindow,并传递包含焦点视图的窗口令牌。

1
2
3
4
5
6
// Check if no view has focus:
View view = this.getCurrentFocus();
if (view != null) {  
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

这将强制键盘在所有情况下都隐藏。在某些情况下,您希望传入InputMethodManager.HIDE_IMPLICIT_ONLY作为第二个参数,以确保仅在用户没有明确强制键盘出现时(通过按住菜单)隐藏键盘。

注意:如果要在Kotlin中执行此操作,请使用:context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

科特林语法

1
2
3
4
5
6
// Check if no view has focus:
 val view = this.currentFocus
 view?.let { v ->
  val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
  imm?.let { it.hideSoftInputFromWindow(v.windowToken, 0) }
 }


为了澄清这种疯狂,我首先代表所有安卓用户为谷歌对软键盘的彻底荒谬处理道歉。对于同一个简单的问题,有如此多的答案,每个答案都不一样,因为这个API和安卓系统中的许多其他API一样,设计得非常糟糕。我想不出有礼貌的说法。

我想把键盘藏起来。我希望向Android提供以下声明:Keyboard.hide()。结束。非常感谢你。但Android有问题。您必须使用InputMethodManager隐藏键盘。好吧,好吧,这是安卓的键盘API。但是!您需要有一个Context才能访问IMM。现在我们有个问题。我可能想将键盘隐藏起来,以防静态类或实用类对任何Context都没有使用或需要。或者更糟的是,IMM要求您指定要隐藏键盘的View(或者更糟的是,指定Window)。

这就是隐藏键盘如此具有挑战性的原因。亲爱的谷歌:当我在寻找蛋糕的配方时,地球上没有任何一个RecipeProvider会拒绝给我提供这个配方,除非我首先回答谁会吃蛋糕,在哪里吃蛋糕!!

这个可悲的故事以丑陋的事实结束:为了隐藏安卓键盘,你需要提供两种身份证明:一种是Context,另一种是ViewWindow

我已经创建了一个静态实用程序方法,只要您从一个Activity调用它,就可以非常稳定地完成这项工作。

1
2
3
4
5
6
7
8
9
10
public static void hideKeyboard(Activity activity) {
    InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
    //Find the currently focused view, so we can grab the correct window token from it.
    View view = activity.getCurrentFocus();
    //If no view currently has focus, create a new one, just so we can grab a window token from it
    if (view == null) {
        view = new View(activity);
    }
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

请注意,此实用程序方法仅在从Activity调用时有效!上述方法调用目标ActivitygetCurrentFocus来获取适当的窗口令牌。

但是假设您想将键盘隐藏在一个托管在一个DialogFragment中的EditText上?您不能使用上述方法:

1
hideKeyboard(getActivity()); //won't work

这不起作用,因为您将传递一个对Fragment的主机Activity的引用,当显示Fragment时,该主机将没有焦点控制!真的!因此,为了避免键盘碎片,我求助于更低级、更常见和更丑的版本:

1
2
3
4
public static void hideKeyboardFrom(Context context, View view) {
    InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
}

以下是从追求此解决方案浪费的更多时间中收集到的一些附加信息:

关于windowsoftinputmode

还有另一个争论点需要注意。默认情况下,android会自动将初始焦点分配给您的EditText中的第一个EditText或focusable控件(10)。自然而然地,inputmethod(通常是软键盘)将通过显示自身来响应焦点事件。当设置为stateAlwaysHidden时,AndroidManifest.xml中的windowSoftInputMode属性指示键盘忽略自动分配的初始焦点。

1
2
3
<activity
    android:name=".MyActivity"
    android:windowSoftInputMode="stateAlwaysHidden"/>

几乎令人难以置信的是,当您触摸控件时,似乎没有采取任何措施来阻止键盘打开(除非focusable="false"和/或focusableInTouchMode="false"被分配给控件)。显然,windowsoftinputmode设置只适用于自动对焦事件,而不适用于由触摸事件触发的对焦事件。

因此,stateAlwaysHidden的名字确实很差。它应该被称为ignoreInitialFocus

希望这有帮助。

更新:获取窗口令牌的更多方法

如果没有焦点视图(例如,如果您刚刚更改了片段,则可能发生这种情况),则还有其他视图将提供有用的窗口标记。

这些是上面代码if (view == null) view = new View(activity);的替代代码,这些代码并不明确地指代您的活动。

在片段类中:

1
view = getView().getRootView().getWindowToken();

给定一个片段Fragment作为参数:

1
view = fragment.getView().getRootView().getWindowToken();

从内容主体开始:

1
view = findViewById(android.R.id.content).getRootView().getWindowToken();

更新2:清除焦点以避免在后台打开应用程序时再次显示键盘

将此行添加到方法末尾:

view.clearFocus();


隐藏软键盘也很有用:

1
2
3
getWindow().setSoftInputMode(
    WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
);

这可用于抑制软键盘,直到用户实际接触到EditText视图。


我还有一个隐藏键盘的解决方案:

1
2
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

这里在showFlag的位置通过HIDE_IMPLICIT_ONLY,在hiddenFlag的位置通过0。它将强制关闭软键盘。


迈尔的解决方案对我也适用。在我的例子中,我的应用程序的顶层是一个tabhost,我想在切换选项卡时隐藏关键字-我从tabhost视图中获取窗口令牌。

1
2
3
4
5
6
tabHost.setOnTabChangedListener(new OnTabChangeListener() {
    public void onTabChanged(String tabId) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0);
    }
}


请在onCreate()中尝试以下代码

1
2
EditText edtView=(EditText)findViewById(R.id.editTextConvertValue);
edtView.setInputType(0);


更新:我不知道为什么这个解决方案不再有效(我刚在android 23上测试过)。请使用Saurabh Pareek的溶液代替。这里是:

1
2
3
4
5
InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

老回答:

1
2
3
4
//Show soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
//hide keyboard :
 getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);


1
2
3
4
protected void hideSoftKeyboard(EditText input) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(input.getWindowToken(), 0);    
}


如果这里的所有其他答案都不能像您希望的那样为您工作,那么还有另一种手动控制键盘的方法。

创建一个用于管理EditText的一些属性的函数:

1
2
3
4
5
6
7
8
9
public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);

    if (isFocused) {
        searchEditText.requestFocus();
    }
}

然后,确保打开/关闭键盘时EditText的焦点:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (v == searchEditText) {
            if (hasFocus) {
                // Open keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED);
            } else {
                // Close keyboard
                ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0);
            }
        }
    }
});

现在,只要您想手动打开键盘,请拨打:

1
setEditTextFocus(true);

对于结束通话:

1
setEditTextFocus(false);


到目前为止,苏拉巴·帕列克有最好的答案。

不过,也可以使用正确的标志。

1
2
3
4
5
6
7
/* hide keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

/* show keyboard */
((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
    .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

实际使用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* click button */
public void onClick(View view) {      
  /* hide keyboard */
  ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
      .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

  /* start loader to check parameters ... */
}

/* loader finished */
public void onLoadFinished(Loader<Object> loader, Object data) {
    /* parameters not valid ... */

    /* show keyboard */
    ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE))
        .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY);

    /* parameters valid ... */
}


通过这样的搜索,我找到了一个适合我的答案。

1
2
3
4
5
6
// Show soft-keyboard:
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

// Hide soft-keyboard:
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

简短的回答

在你的OnClick听者中,用IME_ACTION_DONE呼叫EditTextonEditorAction

1
2
3
4
5
6
7
button.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)
    }
});

下钻

我觉得这个方法更好,更简单,更符合安卓的设计模式。在上面的简单示例中(通常在大多数常见情况下),您将得到一个具有焦点的EditText,并且通常也是首先调用键盘的那个(在许多常见情况下,它肯定能够调用它)。以同样的方式,它应该是一个释放键盘,通常可以由一个ImeAction完成。看看一个EditTextandroid:imeOptions="actionDone"的行为,你想用同样的方法达到同样的行为。

检查相关答案


这应该有效:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class KeyBoard {

    public static void show(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
    }

    public static void hide(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
    }

    public static void toggle(Activity activity){
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        if (imm.isActive()){
            hide(activity);
        } else {
            show(activity);
        }
    }
}

KeyBoard.toggle(activity);


我正在使用自定义键盘输入十六进制数,因此无法显示i m m键盘…

在v3.2.4中,添加了"r1 EDOCX1"(11)以控制天气或在文本视图获得焦点时不显示键盘,但它仍然隐藏,因此必须使用反射:

1
2
3
4
5
6
7
8
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
    try {
        Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class);
        method.invoke(mEditText, false);
    } catch (Exception e) {
        // Fallback to the second method
    }
}

对于旧版本,我使用OnGlobalLayoutListener,在根视图的帮助下添加了ViewTreeObserver,然后检查键盘是否显示如下:

1
2
3
4
5
6
7
8
9
10
@Override
public void onGlobalLayout() {
    Configuration config = getResources().getConfiguration();

    // Dont allow the default keyboard to show up
    if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);
    }
}

最后一个解决方案可能会在一瞬间显示键盘,并干扰选择手柄。

当键盘进入全屏时,ongloballayout不会被调用。要避免这种情况,请使用textview setimeoptions(int)或在textview xml声明中:

1
android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi"

更新:刚刚找到了对话框用来从不显示键盘和在所有版本中工作的内容:

1
2
getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
        WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);


1
2
3
4
5
6
7
8
public void setKeyboardVisibility(boolean show) {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(show){
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    }else{
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0);
    }
}

我花了两天多的时间研究所有在线程中发布的解决方案,发现它们在某种程度上是缺乏的。我的确切要求是有一个按钮,将100%的可靠性显示或隐藏屏幕键盘。当键盘处于隐藏状态时,无论用户点击什么输入字段,都不应重新显示。当键盘处于可见状态时,不管用户点击什么按钮,键盘都不应该消失。这需要在Android 2.2+上一直工作到最新的设备。

您可以在我的应用程序clean rpn中看到此方法的有效实现。

在许多不同的手机(包括Froyo和Gingerbread设备)上测试了许多建议的答案之后,很明显Android应用程序能够可靠地:

  • 暂时隐藏键盘。当用户聚焦新文本字段。
  • 活动开始时显示键盘并在活动上设置一个标志,指示他们的键盘应该始终可见。只有当活动初始化。
  • 将活动标记为从不显示或允许使用键盘。只有当活动初始化。
  • 对我来说,暂时隐藏键盘是不够的。在某些设备上,只要聚焦新的文本字段,它就会重新出现。当我的应用程序在一个页面上使用多个文本字段时,聚焦一个新的文本字段将导致隐藏的键盘再次弹出。

    不幸的是,列表中的第2项和第3项仅在活动开始时工作可靠。一旦活动可见,就不能永久隐藏或显示键盘。诀窍是当用户按下键盘切换按钮时,实际重新启动您的活动。在我的应用程序中,当用户按下切换键盘按钮时,会运行以下代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    private void toggleKeyboard(){

        if(keypadPager.getVisibility() == View.VISIBLE){
            Intent i = new Intent(this, MainActivity.class);
            i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
            Bundle state = new Bundle();
            onSaveInstanceState(state);
            state.putBoolean(SHOW_KEYBOARD, true);
            i.putExtras(state);

            startActivity(i);
        }
        else{
            Intent i = new Intent(this, MainActivity.class);
            i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
            Bundle state = new Bundle();
            onSaveInstanceState(state);
            state.putBoolean(SHOW_KEYBOARD, false);
            i.putExtras(state);

            startActivity(i);
        }
    }

    这将使当前活动的状态保存到一个包中,然后启动该活动,并通过一个布尔值来指示是否应显示或隐藏键盘。

    在onCreate方法内部运行以下代码:

    1
    2
    3
    4
    5
    6
    7
    8
    if(bundle.getBoolean(SHOW_KEYBOARD)){
        ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0);
        getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
    else{
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,
                WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
    }

    如果应该显示软键盘,则会通知InputMethodManager显示键盘,并指示窗口使软输入始终可见。如果应隐藏软键盘,则设置windowManager.layoutParams.flag_alt_focusable_im。

    这种方法在我测试过的所有设备上都能可靠地工作——从运行Android2.2的4岁HTC手机到运行4.2.2的Nexus7。这种方法的唯一缺点是您需要小心处理后退按钮。由于我的应用程序基本上只有一个屏幕(它是一个计算器),我可以覆盖onbackpressed()并返回设备主屏幕。


    除此全面解决方案外,如果您想从任何地方关闭软键盘,而不需要引用用于打开键盘的(edittext)字段,但仍想在该字段被聚焦时执行此操作,则可以使用此(来自活动):

    1
    2
    3
    4
    if (getCurrentFocus() != null) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }

    多亏了这个答案,我得出了以下结论,在我的例子中,当滚动浏览viewpager的片段时,它可以很好地工作…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    private void hideKeyboard() {  
        // Check if no view has focus:
        View view = this.getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }

    private void showKeyboard() {  
        // Check if no view has focus:
        View view = this.getCurrentFocus();
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
            inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
        }
    }

    上面的答案适用于不同的场景,但如果您想将键盘隐藏在视图中,并努力获得正确的上下文,请尝试以下方法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            hideSoftKeyBoardOnTabClicked(v);
        }
    }

    private void hideSoftKeyBoardOnTabClicked(View v) {
        if (v != null && context != null) {
            InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }

    并从构造函数中获取上下文:)

    1
    2
    3
    4
    5
    public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        this.context = context;
        init();
    }

    如果要在单元测试或功能测试期间关闭软键盘,可以通过单击测试中的"后退按钮"来关闭软键盘:

    1
    2
    // Close the soft keyboard from a Test
    getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK);

    我在引号中加了"后退按钮",因为上面的内容不会触发所讨论活动的onBackPressed()。它只是关闭键盘。

    确保在继续之前暂停一会儿,因为关闭"后退"按钮需要一点时间,所以随后单击视图等,直到短暂暂停(1秒足够长的时间)之后才会注册。


    以下是你在Android的Mono(也叫MonoDroid)中的操作方法。

    1
    2
    3
    InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager;
    if (imm != null)
        imm.HideSoftInputFromWindow (searchbox.WindowToken , 0);


    添加到清单文件中的活动android:windowSoftInputMode="stateHidden"。例子:

    1
    2
    3
    4
    <activity
                android:name=".ui.activity.MainActivity"
                android:label="@string/mainactivity"
                android:windowSoftInputMode="stateHidden"/>

    这对我的键盘行为很奇怪

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    private boolean isKeyboardVisible() {
        Rect r = new Rect();
        //r will be populated with the coordinates of your view that area still visible.
        mRootView.getWindowVisibleDisplayFrame(r);

        int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top);
        return heightDiff > 100; // if more than 100 pixels, its probably a keyboard...
    }

    protected void showKeyboard() {
        if (isKeyboardVisible())
            return;
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        if (getCurrentFocus() == null) {
            inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
        } else {
            View view = getCurrentFocus();
            inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
        }
    }

    protected void hideKeyboard() {
        if (!isKeyboardVisible())
            return;
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        View view = getCurrentFocus();
        if (view == null) {
            if (inputMethodManager.isAcceptingText())
                inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0);
        } else {
            if (view instanceof EditText)
                ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug
            inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        }
    }


    只需在活动中使用此优化代码:

    1
    2
    3
    4
    if (this.getCurrentFocus() != null) {
        InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }


    对于我的案例,我使用的是ActionBar中的搜索视图。用户执行搜索后,键盘将再次弹出打开。

    使用InputMethodManager未关闭键盘。我必须清除Focus并将搜索视图的Focusable设置为false:

    1
    2
    mSearchView.clearFocus();
    mSearchView.setFocusable(false);


    在某些情况下,除了所有其他方法外,这种方法都可以工作。这节省了我的一天:)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public static void hideSoftKeyboard(Activity activity) {
        if (activity != null) {
            InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
            if (activity.getCurrentFocus() != null && inputManager != null) {
                inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
                inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0);
            }
        }
    }

    public static void hideSoftKeyboard(View view) {
        if (view != null) {
            InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            if (inputManager != null) {
                inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
            }
        }
    }

    简单易用的方法,只需调用hidekeyboardfrom(youreactivity.this);隐藏键盘

    1
    2
    3
    4
    5
    6
    7
    8
    /**
     * This method is used to hide keyboard
     * @param activity
     */
    public static void hideKeyboardFrom(Activity activity) {
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
    }

    我几乎尝试过所有这些答案,我有一些随机问题,特别是三星Galaxy S5。

    我最后要做的是强迫演出和隐藏,而且效果很好:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /**
     * Force show softKeyboard.
     */
    public static void forceShow(@NonNull Context context) {
        InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
    }

    /**
     * Force hide softKeyboard.
     */
    public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) {
        if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) {
            editText.requestFocus();
        }
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
        activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }

    用这个

    1
    2
    this.getWindow().setSoftInputMode(
                WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

    1
    2
    3
    4
    public static void hideSoftKeyboard(Activity activity) {
        InputMethodManager inputMethodManager = (InputMethodManager)  activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
    }

    在呼叫OnTouchlistener之后:

    1
    2
    3
    4
    5
    6
    7
    findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            Utils.hideSoftKeyboard(activity);
            return false;
        }
    });


    我有这种情况,我的EditText也可以位于AlertDialog中,因此键盘应在关闭时关闭。以下代码似乎在任何地方都有效:

    1
    2
    3
    4
    5
    6
    7
    8
    public static void hideKeyboard( Activity activity ) {
        InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE );
        View f = activity.getCurrentFocus();
        if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) )
            imm.hideSoftInputFromWindow( f.getWindowToken(), 0 );
        else
            activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );
    }


    每次都像魔术一样

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    private void closeKeyboard() {
        InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);

    }

    private void openKeyboard() {
        InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        if(imm != null){
            imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
        }
    }

    对于打开的键盘:

    1
    2
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT);

    对于关闭/隐藏键盘:

    1
    2
     InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
     imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0);


    您还可以研究在edittext上使用setimeoption。

    我只是有一个非常模拟的情况,我的布局包含一个编辑文本和一个搜索按钮。当我发现我可以在我的edittext上将IME选项设置为"actionsearch"时,我意识到我甚至不再需要搜索按钮了。软键盘(在此模式下)有一个搜索图标,可用于启动搜索(键盘会按预期自动关闭)。


    有时您只需要按Enter键即可折叠keyboard。给EditText框你有属性

    1
     android:imeOptions="actionDone"

    这会将Enter按钮更改为Done按钮,该按钮将关闭键盘。


    有时,您可以有一个活动,其中包含一个列表视图,其中的行包含edittext,因此您必须在清单SOFT_INPUT_ADJUST_PAN中设置,然后它们的键盘就会出现,这很烦人。

    如果你把它放在onCreate的末尾,下面的工作就可以了。

    1
    2
    3
    4
    5
    6
    7
    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    new Handler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
                }
            },100);

    试试这个

    • 很简单,你可以打电话到你的Activity
    1
    2
    3
    4
    5
    6
    7
     public static void hideKeyboardwithoutPopulate(Activity activity) {
        InputMethodManager inputMethodManager =
                (InputMethodManager) activity.getSystemService(
                        Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(
                activity.getCurrentFocus().getWindowToken(), 0);
    }
    • 在你的MainActivitiy里,叫这个
    1
     hideKeyboardwithoutPopulate(MainActivity.this);

    它对我有效……

    1
    EditText editText=(EditText)findViewById(R.id.edittext1);

    在onclick()中的代码行下放置

    1
    2
    editText.setFocusable(false);
    editText.setFocusableInTouchMode(true);

    这里隐藏键盘当我们点击按钮和当我们触摸编辑文本键盘将显示。

    (或)

    1
    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);

    我为Kotlin写了一个小的扩展名,如果有人感兴趣的话,我不会对它进行太多的测试:

    1
    2
    3
    4
    5
    6
    7
    fun Fragment.hideKeyboard(context: Context = App.instance) {
        val windowToken = view?.rootView?.windowToken
        windowToken?.let {
            val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
            imm.hideSoftInputFromWindow(windowToken, 0)
        }
    }

    app.instance是静态的"this"应用程序对象,存储在应用程序中

    更新:在某些情况下,WindowToken为空。我增加了另外一种关闭键盘的方法,使用反射来检测键盘是否关闭。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    /**
     * If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed
     *
     * @param useReflection - whether to use reflection in case of no window token or not
     */
    fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) {
        val windowToken = view?.rootView?.windowToken
        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        windowToken?.let {
            imm.hideSoftInputFromWindow(windowToken, 0)
        } ?: run {
            if (useReflection) {
                try {
                    if (getKeyboardHeight(imm) > 0) {
                        imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS)
                    }
                } catch (exception: Exception) {
                    Timber.e(exception)
                }
            }
        }
    }

    fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int

    这是有效的……

    只需在函数中传递当前活动实例

    1
    2
    3
    4
    5
    6
    7
    8
     public void isKeyBoardShow(Activity activity) {
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        if (imm.isActive()) {
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide
        } else {
            imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show
        }
    }

    1
    2
    3
    4
    public static void hideSoftKeyboard(Activity activity) {
        InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
    }


    下的AndroidManifest.xml中设置android:windowSoftInputMode="stateAlwaysHidden"


    如果你想用Java代码隐藏键盘,那么使用这个:

    1
    2
      InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
      imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0);

    或者如果你总是想隐藏键盘,那么在你的AndroidManifest中使用它:

    1
    2
    3
     <activity
     android:name=".activities.MyActivity"
     android:configChanges="keyboardHidden"  />


    实际上,Android授权机构总是提供新的更新,但他们没有处理所有Android开发人员在开发过程中所面临的旧缺陷。默认情况下,Android授权机构应处理这一问题,在改变EditText的焦点时,应隐藏/显示软输入键盘选项。但很抱歉,他们没有管理。好吧,离开它。

    下面是在活动或片段中显示/隐藏/切换键盘选项的解决方案。

    显示视图键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * open soft keyboard.
     *
     * @param context
     * @param view
     */
    public static void showKeyBoard(Context context, View view) {
        try {
            InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.showSoftInput(view, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    显示带有活动上下文的键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
     * open soft keyboard.
     *
     * @param mActivity context
     */
    public static void showKeyBoard(Activity mActivity) {
        try {
            View view = mActivity.getCurrentFocus();
            if (view != null) {
                InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
                keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    用片段上下文显示键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /**
     * open soft keyboard.
     *
     * @param mFragment context
     */
    public static void showKeyBoard(Fragment mFragment) {
        try {
            if (mFragment == null || mFragment.getActivity() == null) {
                return;
            }
            View view = mFragment.getActivity().getCurrentFocus();
            if (view != null) {
                InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
                keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    隐藏视图键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * close soft keyboard.
     *
     * @param context
     * @param view
     */
    public static void hideKeyBoard(Context context, View view) {
        try {
            InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
            keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    使用活动上下文隐藏键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    /**
     * close opened soft keyboard.
     *
     * @param mActivity context
     */
    public static void hideSoftKeyboard(Activity mActivity) {
        try {
            View view = mActivity.getCurrentFocus();
            if (view != null) {
                InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
                inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    使用片段上下文隐藏键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    /**
     * close opened soft keyboard.
     *
     * @param mFragment context
     */
    public static void hideSoftKeyboard(Fragment mFragment) {
        try {
            if (mFragment == null || mFragment.getActivity() == null) {
                return;
            }
            View view = mFragment.getActivity().getCurrentFocus();
            if (view != null) {
                InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
                inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    切换键盘:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /**
     * toggle soft keyboard.
     *
     * @param context
     */
    public static void toggleSoftKeyboard(Context context) {
        try {
            InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    简单代码:在onCreate()中使用此代码

    1
    2
    3
    getWindow().setSoftInputMode(
        WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN
    );

    如果你使用KOTLIN来开发你的应用程序,它真的很容易做到。

    添加此扩展功能:

    活动:

    1
    2
    3
    4
    5
    6
    7
    fun Activity.hideKeyboard() {
        val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        val view = currentFocus
        if (view != null) {
            inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }

    片段:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    fun Fragment.hideKeyboard() {
        activity?.let {
            val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            val view = it.currentFocus
            if (view != null) {
                inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
            }
        }
    }

    现在你可以简单地调用你的片段或活动:

    1
     hideKeyboard()

    以下是隐藏和显示方法。

    科特林

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    fun hideKeyboard(activity: Activity) {
        val v = activity.currentFocus
        val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        assert(v != null)
        imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
    }

    private fun showKeyboard(activity: Activity) {
        val v = activity.currentFocus
        val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        assert(v != null)
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)
    }

    爪哇

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    public static void hideKeyboard(Activity activity) {
        View v = activity.getCurrentFocus();
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        assert imm != null && v != null;
        imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }

    private static void showKeyboard(Activity activity) {
        View v = activity.getCurrentFocus();
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        assert imm != null && v != null;
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
    }

    非常简单的方法

    我在所有的项目中都这样做,并且像做梦一样工作。在你的声明中,只需加上这一行:

    1
    android:focusableInTouchMode="true"

    完整代码示例:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <?xml version="1.0" encoding="utf-8"?>
    <android.support.constraint.ConstraintLayout
        xmlns:app="http://schemas.android.com/apk/res-auto"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:focusableInTouchMode="true">

        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content" />

        <ListView
            android:layout_width="match_parent"
            android:layout_height="wrap_content">

        </ListView>

    </android.support.constraint.ConstraintLayout>


    试试这个

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public void disableSoftKeyboard(final EditText v) {
        if (Build.VERSION.SDK_INT >= 11) {
            v.setRawInputType(InputType.TYPE_CLASS_TEXT);
            v.setTextIsSelectable(true);
        } else {
            v.setRawInputType(InputType.TYPE_NULL);
            v.setFocusable(true);
        }
    }

    简单方法:试试这个…

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    private void closeKeyboard(boolean b) {

            View view = this.getCurrentFocus();

            if(b) {
                if (view != null) {
                    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
                }
            }
            else {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(view, 0);
            }
        }

    以下是最佳解决方案

    解决方案1)将输入类型设置为"文本"

    1
    2
    3
    4
    5
    6
    <EditText
    android:id="@+id/my_edit_text"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="Tap here to type"
    android:inputType="text" />

    这也可以通过编程方式完成。方法setInputType()(从textView继承)。

    1
    2
    3
    EditText editText = (EditText) findViewById(R.id.my_edit_text);
    editText.setRawInputType(InputType.TYPE_CLASS_TEXT |
    InputType.TYPE_TEXT_VARIATION_NORMAL);

    解决方案2)使用inputmethodmanager.hideSoftinputfromWindow()。

    1
    2
    3
    InputMethodManager imm =
    (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0);

    1
    2
    3
    4
    InputMethodManager imm = (InputMethodManager)
    getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(myEditText.getWindowToken(),
    InputMethodManager.HIDE_NOT_ALWAYS);

    如果要手动隐藏键盘上的按钮操作,请单击:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    /**
     * Hides the already popped up keyboard from the screen.
     *
     */
    public void hideKeyboard() {
        try {
            // use application level context to avoid unnecessary leaks.
            InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE);
            assert inputManager != null;
            inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    当您想隐藏键盘时,除了edittext,您在屏幕上单击的位置在活动中重写此方法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        View view = getCurrentFocus();
        if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("android.webkit.")) {
            int scrcoords[] = new int[2];
            view.getLocationOnScreen(scrcoords);
            float x = ev.getRawX() + view.getLeft() - scrcoords[0];
            float y = ev.getRawY() + view.getTop() - scrcoords[1];
            if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom())
                ((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0);
        }
        return super.dispatchTouchEvent(ev);
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);
            llLogin.setOnTouchListener(
                    new View.OnTouchListener() {
                        @Override
                        public boolean onTouch(View view, MotionEvent ev) {
                            InputMethodManager imm = (InputMethodManager) this.getSystemService(
                                    Context.INPUT_METHOD_SERVICE);
                            imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
                            return false;
                        }
                    });

    1
    2
    3
    4
    5
    6
    public static void hideSoftKeyboard(Activity activity) {
        InputMethodManager inputMethodManager = (InputMethodManager) activity
                .getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus()
                .getWindowToken(), 0);
    }


    我创建了一个布局,一部分来自XML,另一部分来自一个定制的布局引擎,这些都是用代码处理的。唯一对我有用的是跟踪键盘是否打开,并使用键盘切换方法如下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    public class MyActivity extends Activity
    {
        /** This maintains true if the keyboard is open. Otherwise, it is false. */
        private boolean isKeyboardOpen = false;

        @Override
        public void onCreate(Bundle savedInstanceState)
        {
            super.onCreate(savedInstanceState);
            LayoutInflater inflater;
            inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
            View contentView = inflater.inflate(context.getResources().getIdentifier("main","layout", getPackageName()), null);

            setContentView(contentView);
            contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener()
            {
                public void onGlobalLayout()
                {
                    Rect r = new Rect();
                    contentView.getWindowVisibleDisplayFrame(r);
                    int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top);
                    if (heightDiff > 100)
                        isKeyboardVisible = true;
                    else
                        isKeyboardVisible = false;
                 });
             }
        }

        public void closeKeyboardIfOpen()
        {
            InputMethodManager imm;
            imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            if (isKeyboardVisible)
                imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
        }  
    }

    下面的代码将帮助您生成可以从任何地方调用的通用函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import android.app.Activity
    import android.content.Context
    import android.support.design.widget.Snackbar
    import android.view.View
    import android.view.inputmethod.InputMethodManager

    public class KeyboardHider {
        companion object {

            fun hideKeyboard(view: View, context: Context) {
                val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
                inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)
            }

        }

    }

    使用一行代码从任意位置调用上述方法。

    1
    CustomSnackbar.hideKeyboard(view, this@ActivityName)

    视图可以是任何东西,例如活动的根布局。


    在android中,要通过inputmethodmanage隐藏vkeyboard,您可以通过传递包含您的焦点视图的窗口标记来校准hideSoftinputfromWindow。

    1
    2
    3
    4
    5
    6
    View view = this.getCurrentFocus();
    if (view != null) {  
    InputMethodManager im =
    (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
    im.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }

    通过调用edittext.clearfocus(),然后调用inputmethodmanager.hide_implicit_,甚至可以


    这种方法总是以任何代价工作。只要在你想隐藏键盘的地方使用它

    1
    2
    3
    4
    5
    6
    public static void hideSoftKeyboard(Context mContext,EditText username){
            if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){
                InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.hideSoftInputFromWindow(username.getWindowToken(), 0);
            }
        }

    这样使用:

    无论Android的版本是什么。这种方法肯定有效


    您只需将此代码添加到要隐藏软键盘的位置即可。"

    1
    2
    3
    4
    5
    6
                            // Check if no view has focus:
                                View view = getCurrentFocus();
                                if (view != null) {
                                    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                                    imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
                                }

    在Kotlin

    1
    2
    3
    4
    5
    fun hideKeyboard(activity: BaseActivity) {
            val view = activity.currentFocus?: View(activity)
            val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
            imm.hideSoftInputFromWindow(view.windowToken, 0)
        }

    这对我有用。

    1
    2
    3
    4
    5
    6
    7
    8
    public static void hideKeyboard(Activity act, EditText et){
        Context c = act.getBaseContext();
        View v = et.findFocus();
        if(v == null)
            return;
        InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE);
        inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
    }

    调用此方法隐藏软键盘

    1
    2
    3
    4
    5
    6
    7
    public void hideKeyBoard() {
        View view1 = this.getCurrentFocus();
        if(view!= null){
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
        }
    }

    另一种使用SearchView的方法是使用以下代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    searchView = (SearchView) searchItem.getActionView();    
    searchView.setOnQueryTextListener(new OnQueryTextListener() {
        @Override
        public boolean onQueryTextSubmit(String query) {
            InputMethodManager imm = (InputMethodManager)
            getSystemService(getApplicationContext().INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0);
        }
    }

    这是操作栏中的SearchView搜索框,当提交查询的文本时(用户按Enter键或搜索按钮/图标),则激活InputMethodManager代码并使软键盘向下。这个代码放在我的onCreateOptionsMenu()中。searchItem来自MenuItem,它是onCreateOptionsMenu()的默认代码的一部分。感谢@mckoss提供了大量这段代码!


    您可以为任何视图创建扩展函数

    1
    2
    3
    4
    fun View.hideKeyboard() = this.let {
        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(windowToken, 0)
    }

    与活动一起使用的示例

    1
    window.decorView.hideKeyboard();

    示例与视图一起使用

    1
    etUsername.hideKeyboard();

    快乐编码…


    在这里绝望地尝试了所有的方法,结合所有的方法,当然键盘不会关闭在Android4.0.3(它确实在Honeicomb Afair工作)。

    突然,我发现了一个明显获胜的组合:

    1
    textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL);

    结合你的常规食谱

    1
    blahblaj.hideSoftInputFromWindow ...

    希望这能阻止某人自杀。我离它很近。当然,我不知道它为什么会起作用。


    为了简单起见,我写了一个通用的方法来做这件事:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    /**
     * hide soft keyboard in a activity
     * @param activity
     */
    public static void hideKeyboard (Activity activity){
        activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
        if (activity.getCurrentFocus() != null) {
            InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0);
        }
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public static void closeInput(final View caller) {  
        caller.postDelayed(new Runnable() {
            @Override
            public void run() {
                InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
            }
        }, 100);
    }

    此方法通常有效,但有一个条件:不能设置android:windowSoftInputMode="any_of_these"


    嗨,这很简单,如果你和Kotlin一起工作,我相信你也可以很容易地把代码转换成Java,首先在你的活动中,当你的活动在OnCeCATE()调用它时,使用这个函数。

    1
    2
    3
    4
    5
    fun hideKeybord (){
    val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    if (inputManager.isAcceptingText){
        inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)
    }

    }

    正如我在oncreate()方法中提到的,调用这个函数,然后将这个android:windowSoftInputMode="stateAlwaysHidden"行添加到manafest.xml文件中的活动中,如下所示…

    1
    2
    3
    4
    5
    <activity
        android:name=".Activity.MainActivity"
        android:label="@string/app_name"
        android:theme="@style/AppTheme.NoActionBar"
        android:windowSoftInputMode="stateAlwaysHidden">

    对于外面的Kotlin用户,这里有一个适用于我的用例的Kotlin扩展方法:

    1
    2
    3
    4
    fun View.hideKeyboard() {
        val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(windowToken, 0)
    }

    把它放在一个名为VIEW扩展的文件中(或者你有什么),就像正常的方法那样在你的视图上调用它。


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    there are two ways to do so...

    method 1:in manifest file

    define the line **android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below...

    <activity
                android:name="packagename.youactivityname"
                android:screenOrientation="portrait"
                android:windowSoftInputMode="adjustPan|stateAlwaysHidden" />

    Method 2 : in Activity or Java class

     if(getCurrentFocus()!=null) {
                InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`;
                inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
            }

    它会起作用的……@ask


    在Kotlin中的wiki答案:

    1-在文件中创建顶级函数(例如包含所有顶级函数的文件):

    1
    2
    3
    4
    5
    6
    fun Activity.hideKeyboard(){
        val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
        var view = currentFocus
        if (view == null) { view = View(this) }
        imm.hideSoftInputFromWindow(view.windowToken, 0)
    }

    2-然后在任何需要的活动中调用它:

    1
    this.hideKeyboard()

    1
    2
    3
    4
    5
     fun hideKeyboard(appCompatActivity: AppCompatActivity) {
            val view = appCompatActivity.currentFocus
            val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            imm.hideSoftInputFromWindow(view.windowToken, 0)
        }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public void hideKeyboard()
    {
        if(getCurrentFocus()!=null)
        {
            InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }
    }


    public void showKeyboard(View mView) {
        InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
        mView.requestFocus();
        inputMethodManager.showSoftInput(mView, 0);
    }

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    /**
     *
     *   Hide I Said!!!
     *
     */
    public static boolean hideSoftKeyboard(@NonNull Activity activity) {
        View currentFocus = activity.getCurrentFocus();
        if (currentFocus == null) {
            currentFocus = activity.getWindow().getDecorView();
            if (currentFocus != null) {
                return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null);
            }
        }
        return false;
    }

    public static boolean hideSoftKeyboard(@NonNull Context context) {
       if(Activity.class.isAssignableFrom(context.getClass())){
           return hideSoftKeyboard((Activity)context);
       }
       return false;
    }

    public static InputMethodManager getSoftInput(@NonNull Context context) {
        return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE);
    }


    一些Kotlin代码:

    隐藏键盘以防活动:

    1
    2
    3
    (currentFocus ?: View(this))
                .apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
                            .hideSoftInputFromWindow(windowToken, 0) }

    如果应用程序的目标API级别为21或更高,则需要使用默认方法:

    1
    editTextObj.setShowSoftInputOnFocus(false);

    确保在EditTextxml标记中设置了以下代码。

    1
    2
    3
    4
    <EditText  
        ....
        android:enabled="true"
        android:focusable="true" />

    Kotlin版本

    1
    2
    3
    4
    5
    val imm: InputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
    //Hide:
    imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
    //Show
    imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);


    在阅读了上面和另一篇文章中的所有答案之后,我仍然没有成功地让键盘自动打开。

    在我的项目中,我动态地创建了一个对话框(AlertDialog(通过在不使用或使用最少所需XML的情况下对其进行编程)。

    所以我做了如下的事情:

    1
    2
    3
    4
    5
    6
    7
    8
        dialogBuilder = new AlertDialog.Builder(activity);

        if(dialogBuilder==null)
            return false; //error

        inflater      = activity.getLayoutInflater();
        dialogView    = inflater.inflate(layout, null);
        ...

    在完成所有视图(textview、imageview、edittext等)的设置之后,我做了:

    1
    2
    3
            alertDialog = dialogBuilder.create();

            alertDialog.show();

    在讨论了所有的答案之后,我发现如果你知道把请求放在哪里的话,大多数答案都是有效的。这是所有人的关键。

    所以,诀窍是把它放在对话产生之前:在我的例子中,这就像魅力:

    1
    2
    3
    4
    5
    6
    7
    8
            alertDialog = dialogBuilder.create();          
            alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

            //And only when everything is finished - let's bring up the window -
            alertDialog.show();

            //Viola... keyboard is waiting for you open and ready...
            //Just don't forget to request focus for the needed view (i.e. EditText..)

    我很确定这个原则在所有窗口中都是一样的,所以请注意"ShowKeyboard"代码的位置——它应该在窗口启动之前。

    来自Android SDK开发团队的一个小请求:

    我认为所有这些都是不必要的,正如您所看到的,来自世界各地的成千上万的程序员正在处理这个荒谬和琐碎的问题,而它的解决方案应该是干净和简单的:imho如果我让requestFocus()进入一个面向输入的视图(如EditText视图),键盘应该自动打开,除非用户要求不打开,所以我认为这里的键是requestFocus()方法,并且应该接受默认值为true的Boolean ShowSoftKeyboard:View.requestFocus(boolean showSoftKeyboard);

    希望这能帮助像我这样的人。


    您只需要在清单活动标记内写一行

    1
     android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

    它会起作用的。


    我正在使用以下Kotlin活动扩展:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    /**
     * Hides soft keyboard if is open.
     */
    fun Activity.hideKeyboard() {
        currentFocus?.windowToken?.let {
            (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                    ?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }

    /**
     * Shows soft keyboard and request focus to given view.
     */
    fun Activity.showKeyboard(view: View) {
        view.requestFocus()
        currentFocus?.windowToken?.let {
            (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?)
                    ?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
        }
    }

    用Try-Catch包围它,这样键盘就已经关闭了,应用程序不会崩溃:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    try{

    View view = this.getCurrentFocus();
    if (view != null) {  
        InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
    }catch (Exception e)
    {
      e.printStackTrace();
    }

    只需在baseActivity和baseFragment中对整个应用程序进行通用方法

    onCreate()中,初始化inputMethodManager

    1
    inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);

    使用此方法隐藏和显示键盘

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    public void hideKeyBoard(View view) {
         if (view != null) {
             inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
          }
     }

    public void showKeyboard(View view, boolean isForceToShow) {
          if (isForceToShow)
             inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
          else if (view != null)
               inputMethodManager.showSoftInput(view, 0);
    }

    1
    2
    3
    4
    5
    6
    7
    8
    private void hideSoftKeyboard() {
        View view = getView();
        if (view != null) {
            InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                    .getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
    }

    要在应用程序启动时显示键盘:

    1
    2
    3
    4
    5
    6
    7
            getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
            view.requestFocus();
            new Handler().postDelayed(new Runnable() {
                public void run() {
                    getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);
                }
            }, 1000);


    对于xamarin.android:

    1
    2
    3
    4
    5
    6
    public void HideKeyboard()
    {
        var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>();
        var view = activity.CurrentFocus ?? new View(activity);
        imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None);
    }

    1
    use Text watcher instead of EditText.and after you finished entering the input

    你可以使用

    1
    2
    InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view.getWindowToken(), 0);

    在科特林试试这个

    1
    2
    3
    4
     private fun hideKeyboard(){
        val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager
        imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0)
    }

    用Java试试

    1
    2
    3
    4
     private void hideKeyboard(){
      InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);
      imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
    }

    我已经尝试了所有的解决方案,但没有一个解决方案对我有效,所以我找到了我的解决方案:您应该有如下布尔变量:

    1
    2
    3
    public static isKeyboardShowing = false;
    InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

    在触摸屏事件中,您可以拨打:

    1
    2
    3
    4
    5
    6
    7
    8
    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if(keyboardShowing==true){
            inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
            keyboardShowing = false;
        }
        return super.onTouchEvent(event);
    }

    在edittext中,在任何地方:

    1
    2
    3
    4
    5
    6
    7
    8
    yourEditText.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                yourClass.keyboardShowing = true;

            }
        });

    这对我很有用:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
     @Override
     public boolean dispatchTouchEvent(MotionEvent event) {
    View v = getCurrentFocus();
    boolean ret = super.dispatchTouchEvent(event);

    if (v instanceof EditText) {
        View w = getCurrentFocus();
        int scrcoords[] = new int[2];
        w.getLocationOnScreen(scrcoords);
        float x = event.getRawX() + w.getLeft() - scrcoords[0];
        float y = event.getRawY() + w.getTop() - scrcoords[1];

        Log.d("Activity",
               "Touch event" + event.getRawX() +"," + event.getRawY()
                        +"" + x +"," + y +" rect" + w.getLeft() +","
                        + w.getTop() +"," + w.getRight() +","
                        + w.getBottom() +" coords" + scrcoords[0] +","
                        + scrcoords[1]);
        if (event.getAction() == MotionEvent.ACTION_UP
                && (x < w.getLeft() || x >= w.getRight() || y < w.getTop() || y > w
                        .getBottom())) {

            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(getWindow().getCurrentFocus()
                    .getWindowToken(), 0);
        }
    }
    return ret;
    }