关闭/隐藏android软键盘

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

在编辑字段中编写并单击之后Button，我想隐藏虚拟键盘。我假设这是一段简单的代码，但是在哪里可以找到示例呢？

在键盘外触摸时。

为了澄清这种疯狂，我首先要代表所有Android用户道歉，感谢Google对软键盘的彻底荒谬对待。对于同一个简单问题，答案之所以如此之多，是因为该API与Android中的许多其他API一样，都是经过可怕设计的。我认为没有礼貌的陈述方式。

我想隐藏键盘。我希望向Android提供以下声明：Keyboard.hide()。结束。非常感谢你。但是Android有一个问题。您必须使用InputMethodManager来隐藏键盘。好的，好的，这是Android键盘的API。但！您需要具有Context才能访问IMM。现在我们有一个问题。我可能想从没有使用或不需要的静态或实用程序类中隐藏键盘Context。或而且，更糟糕的是，IMM要求您指定要隐藏键盘FROM的内容View（或更糟糕的是，内容Window）。

这就是隐藏键盘如此具有挑战性的原因。亲爱的Google：当我在寻找蛋糕RecipeProvider的食谱时，除非我先回答谁将被蛋糕食用以及在哪里食用，否则地球上没有人会拒绝向我提供食谱！！

这个可悲的故事以一个丑陋的事实结尾：要隐藏Android键盘，您将需要提供2种形式的标识：a Context和a View或a Window。

我创建了一个静态实用程序方法，只要您从调用它，就可以非常可靠地完成工作Activity。

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！调用时，此实用程序方法才有效。上面的方法调用getCurrentFocus目标Activity以获取正确的窗口令牌。

但是，假设您要隐藏EditText主机中的键盘DialogFragment？您不能为此使用以上方法：

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

这将不起作用，因为您将传递对Fragment的host 的引用，该宿主Activity在Fragment显示时将没有焦点控制！哇！因此，为了隐藏键盘的片段，我求助于较低级别的，更常见的且更难看的：

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或可聚焦控件Activity。当然，InputMethod（通常是软键盘）将通过显示自身来响应焦点事件。的windowSoftInputMode属性AndroidManifest.xml设置为时stateAlwaysHidden，它指示键盘忽略此自动分配的初始焦点。

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

几乎令人难以置信的是，当您触摸控件时，它似乎无法阻止键盘打开（除非focusable="false"和/或focusableInTouchMode="false"已分配给控件）。显然，windowSoftInputMode设置仅适用于自动聚焦事件，不适用于由触摸事件触发的聚焦事件。

因此， stateAlwaysHidden确实的名字很差。也许应该ignoreInitialFocus改为调用它。

希望这可以帮助。

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

如果没有集中的视图（例如，如果您只是更改片段，可能会发生），那么其他视图将提供有用的窗口标记。

这些是上述代码的替代方法 if (view == null) view = new View(activity); 这些未明确引用您的活动。

在片段类内部：

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

给定一个片段fragment作为参数：

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

从内容主体开始：

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

更新2：如果从后台打开应用，请清除焦点以避免再次显示键盘

将此行添加到方法的末尾：

view.clearFocus();

您可以使用InputMethodManager强制Android隐藏虚拟键盘，调用hideSoftInputFromWindow，传入包含焦点视图的窗口的令牌。

// 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

Kotlin语法

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

对于隐藏软键盘也有用的是：

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

这可以用来抑制软键盘，直到用户实际触摸editText视图为止。

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

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

路过这里HIDE_IMPLICIT_ONLY时的位置showFlag，并0在该位置hiddenFlag。它将强制关闭软键盘。

Meier的解决方案也对我有用。在我的情况下，我的应用程序的顶层是tabHost，我想在切换选项卡时隐藏关键字-我从tabHost视图获取窗口令牌。

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

请尝试以下代码 onCreate()

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

更新： 我不知道为什么该解决方案不再起作用（我刚刚在Android 23上进行了测试）。请改用Saurabh Pareek的解决方案。这里是：

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
//Hide:
imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
//Show
imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);

旧答案：

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

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

如果此处的所有其他答案对您都不起作用，那么您可以使用另一种手动控制键盘的方法。

创建一个函数，该函数将管理的某些EditText属性：

public void setEditTextFocus(boolean isFocused) {
    searchEditText.setCursorVisible(isFocused);
    searchEditText.setFocusable(isFocused);
    searchEditText.setFocusableInTouchMode(isFocused);

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

然后，请确保EditText您的onFocus 打开/关闭键盘：

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);
            }
        }
    }
});

现在，每当您要手动打开键盘时，请调用：

setEditTextFocus(true);

对于结束通话：

setEditTextFocus(false);

到目前为止，Saurabh Pareek的答案是最好的。

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

/* 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);

实际使用示例

/* 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 ... */
}

通过这样的搜索，我在这里找到了适合我的答案

// 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听众拨打onEditorAction的EditText用IME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

下钻

我觉得这种方法更好，更简单并且更符合Android的设计模式。在上面的简单示例中（通常在大多数常见情况下），您将拥有一个EditText具有/具有焦点的对象，并且通常也是首先要调用键盘的人（肯定可以在许多情况下调用它）常见情况）。用同样的方式释放键盘也应该是这样的，通常可以通过来完成ImeAction。刚看到一个EditText与android:imeOptions="actionDone"行为，您就想通过相同的方式实现相同的行为。

检查此相关答案

这应该工作：

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);

我正在使用自定义键盘输入十六进制数字，因此无法显示IMM键盘...

在v3.2.4_r1中setSoftInputShownOnFocus(boolean show)已添加了控件，以控制天气或在TextView获得焦点时不显示键盘，但该控件仍处于隐藏状态，因此必须使用反射：

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
    }
}

对于较旧的版本，使用a获得了很好的效果（但远非完美）OnGlobalLayoutListener，并在ViewTreeObserver根视图中借助a 进行了添加，然后检查键盘是否显示如下：

@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声明中：

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

更新：刚刚找到了用于从不显示键盘的对话框，并且可以在所有版本中使用：

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

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及更高版本上运行，直到最新的设备。

您可以在我的应用程序干净RPN中看到此功能的有效实现。

在许多不同的手机（包括froyo和姜饼设备）上测试了许多建议的答案后，很明显，Android应用程序可以可靠地：

1. 暂时隐藏键盘。当用户聚焦新的文本字段时，它将再次出现。
2. 活动开始时显示键盘，并在活动上设置一个标志，指示它们的键盘应始终可见。仅当活动正在初始化时才可以设置此标志。
3. 将活动标记为永不显示或不允许使用键盘。仅当活动正在初始化时才可以设置此标志。

对我来说，暂时隐藏键盘是不够的。在某些设备上，它将在新文本字段聚焦后立即重新出现。当我的应用程序在一页上使用多个文本字段时，聚焦新的文本字段将使隐藏的键盘再次弹出。

不幸的是，列表2和3仅在开始活动时才具有可靠性。活动可见后，您将无法永久隐藏或显示键盘。技巧是在用户按下键盘切换按钮时实际上重新启动您的活动。在我的应用程序中，当用户按下切换键盘按钮时，将运行以下代码：

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);
    }
}

这将导致当前活动的状态保存到Bundle中，然后通过一个布尔值启动活动，该布尔值指示应该显示还是隐藏键盘。

在onCreate方法中，运行以下代码：

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。

这种方法可以在我测试过的所有设备上可靠地运行-从运行android 2.2的4年旧HTC手机到运行4.2.2的nexus 7。这种方法的唯一缺点是您需要小心处理后退按钮。由于我的应用程序基本上只有一个屏幕（它有一个计算器），因此我可以覆盖onBackPressed（）并返回到设备主屏幕。

或者到这一切它的解决方案，如果你想关闭软键盘从任何地方，而不必是用于打开键盘（EditText上）字段的引用，但仍然希望这样做，如果该领域的重点，你可以使用这（来自一个活动）：

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

由于有了这个SO答案，我得到了以下内容，在我的情况下，当滚动浏览ViewPager的片段时，效果很好。

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);
    }
}

上面的答案适用于不同的情况，但是 如果您想将键盘隐藏在视图中并努力获取正确的上下文，请尝试以下操作：

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);
    }
}

并从构造函数中获取上下文：）

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

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

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

我将“后退按钮”用引号引起来，因为上述操作不会触发所onBackPressed()讨论活动的。它只是关闭键盘。

请确保暂停一会儿再继续，因为关闭后退按钮需要一点时间，因此随后的对“视图”等的单击只有在短暂的暂停后才会注册（1秒钟足够长的动画）。

这是您在Android版Mono（AKA MonoDroid）中的操作方法

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

这对于我所有奇怪的键盘行为都有效

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);
    }
}

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

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

简单易用的方法，只需调用hideKeyboardFrom（YourActivity.this）; 隐藏键盘

/**
 * 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);
}

只需在您的活动中使用以下优化代码即可：

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

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

之后在onTouchListener上调用：

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

用这个

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

就我而言，我在操作栏中使用了SearchView。用户执行搜索后，键盘将再次弹出打开。

使用InputMethodManager不会关闭键盘。我必须清除focus并将搜索视图的focusable设置为false：

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

我的情况是，我的EditText位置也可以位于AlertDialog，所以解雇时应该关闭键盘。以下代码似乎可以在任何地方运行：

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 );
}

我几乎尝试了所有这些答案，但我遇到了一些随机问题，尤其是三星s5。

我最终要强迫显示和隐藏，并且效果很好：

/**
 * 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);
}