android - 如何以编程方式关闭/隐藏 Android 软键盘？

Question

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

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

score 4601 · Accepted Answer

您可以强制 Android 使用InputMethodManager隐藏虚拟键盘，调用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 语法

// Only runs if there is a view that is currently focused
this.currentFocus?.let { view ->
    val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
    imm?.hideSoftInputFromWindow(view.windowToken, 0)
}

score 2429 · Accepted Answer

为了帮助澄清这种疯狂，我想首先代表所有 Android 用户为谷歌对软键盘的荒谬处理表示歉意。对于同一个简单的问题，有这么多答案，每个答案都不同，原因是这个 API 和 Android 中的许多其他 API 一样，设计得很糟糕。我想不出有礼貌的说法。

我想隐藏键盘。我希望为 Android 提供以下声明：Keyboard.hide(). 结束。非常感谢你。但是安卓有问题。您必须使用InputMethodManager隐藏键盘。好的，好的，这是 Android 的键盘 API。但！您必须拥有一个Context才能访问 IMM。现在我们有一个问题。我可能想从一个没有用或不需要任何Context. 或者更糟糕的是，IMM 要求您指定要隐藏键盘的内容View（或更糟糕的是，什么）。Window

这就是隐藏键盘如此具有挑战性的原因。亲爱的谷歌：当我在查找蛋糕的食谱时，RecipeProvider地球上没有人会拒绝向我提供食谱，除非我先回答谁会吃蛋糕以及吃蛋糕的地方！

这个悲伤的故事以丑陋的事实结束：要隐藏 Android 键盘，您将需要提供 2 种形式的标识：aContext和 aView或 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

这将不起作用，因为您将传递对Fragmenthost的引用，在显示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();

score 840 · Accepted Answer

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

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

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

score 371 · Accepted Answer

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

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

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

score 165 · Accepted Answer

Meier 的解决方案也适用于我。就我而言，我的应用程序的顶层是选项卡主机，我想在切换选项卡时隐藏关键字 - 我从选项卡主机视图中获取窗口令牌。

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

score 158 · Accepted Answer

有很多方法可以以编程方式关闭/隐藏 Android 软键盘。您可以尝试以下代码 onCreate()

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

或者你可以试试下面的代码 onCreate()

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

score 146 · Accepted Answer

更新： 我不知道为什么这个解决方案不再起作用（我刚刚在 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);

score 101 · Accepted Answer

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

score 84 · Accepted Answer

如果此处的所有其他答案都无法如您所愿，那么还有另一种手动控制键盘的方法。

创建一个函数来管理的一些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);

score 71 · Accepted Answer

到目前为止，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 ... */
}

score 64 · Accepted Answer

从如此搜索中，我找到了一个适合我的答案

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

score 63 · Accepted Answer

简短的回答

在你的OnClick听众onEditorAction中调用EditTextwithIME_ACTION_DONE

button.setOnClickListener(new OnClickListener() {

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

向下钻取

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

检查这个相关的答案

score 49 · Accepted Answer

这应该有效：

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

score 48 · Accepted Answer

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

在 v3.2.4_r1setSoftInputShownOnFocus(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中添加 a ViewTreeObserver，然后检查键盘是否显示如下：

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

score 36 · Accepted Answer

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

score 32 · Accepted Answer

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

您可以在我的应用程序clean RPN中看到一个有效的实现。

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

暂时隐藏键盘。当用户关注一个新的文本字段时，它会再次出现。
在活动开始时显示键盘，并在活动上设置一个标志，指示它们的键盘应该始终可见。此标志只能在活动初始化时设置。
将活动标记为从不显示或允许使用键盘。此标志只能在活动初始化时设置。

对我来说，暂时隐藏键盘是不够的。在某些设备上，一旦聚焦新的文本字段，它就会重新出现。由于我的应用在一页上使用多个文本字段，因此聚焦一个新文本字段将导致隐藏的键盘再次弹出。

不幸的是，列表中的第 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);
    }
}

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

在 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() 并返回到设备主屏幕。

score 30 · Accepted Answer

作为全方位解决方案的替代方案，如果您想从任何地方关闭软键盘而不引用用于打开键盘的 (EditText) 字段，但如果该字段已聚焦，则仍想这样做，您可以使用这（来自活动）：

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

score 29 · Accepted Answer

感谢上帝11 年后得到官方支持

首先添加依赖implementation 'androidx.core:core-ktx:1.7.0'到app gradle

这是github上的简单项目

import android.app.Activity
import android.content.Context
import android.view.View
import androidx.core.view.WindowInsetsCompat
import androidx.core.view.WindowInsetsControllerCompat
import androidx.fragment.app.Fragment
import androidx.fragment.app.FragmentActivity


fun View.showKeyboard() = (this.context as? Activity)?.showKeyboard()
fun View.hideKeyboard() = (this.context as? Activity)?.hideKeyboard()

fun Fragment.showKeyboard() = activity?.let(FragmentActivity::showKeyboard)
fun Fragment.hideKeyboard() = activity?.hideKeyboard()

fun Context.showKeyboard() = (this as? Activity)?.showKeyboard()
fun Context.hideKeyboard() = (this as? Activity)?.hideKeyboard()

fun Activity.showKeyboard() = WindowInsetsControllerCompat(window, window.decorView).show(WindowInsetsCompat.Type.ime())
fun Activity.hideKeyboard() = WindowInsetsControllerCompat(window, window.decorView).hide(WindowInsetsCompat.Type.ime())

score 26 · Accepted Answer

多亏了这个 SO answer，我得出了以下内容，在我的情况下，在滚动 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);
    }
}

score 22 · Accepted Answer

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

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

score 21 · Accepted Answer

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

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

我将“后退按钮”放在引号中，因为上述内容不会触发onBackPressed()相关活动。它只是关闭键盘。

确保在继续之前暂停一会儿，因为关闭后退按钮需要一点时间，因此后续点击 Views 等，直到短暂暂停后才会注册（1 秒足够长 ime ）。

score 19 · Accepted Answer

现在，差不多 12 年后，我们终于有了一种官方的、向后兼容的方式来使用AndroidX Core 1.5+做到这一点：

fun View.hideKeyboard() = ViewCompat.getWindowInsetsController(this)
    ?.hide(WindowInsetsCompat.Type.ime())

或专门用于片段：

fun Fragment.hideKeyboard() = ViewCompat.getWindowInsetsController(requireView())
    ?.hide(WindowInsetsCompat.Type.ime())

score 18 · Accepted Answer

这是你在 Mono for Android (AKA MonoDroid) 中的操作方法

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

score 17 · Accepted Answer

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

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

score 16 · Accepted Answer

简单易用的方法，只需调用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);
}

score 15 · Accepted Answer

只需在您的活动中使用此优化代码：

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

score 15 · Accepted Answer

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

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

score 15 · Accepted Answer

•`Kotlin Version`通过`Extension Function`

使用 kotlin 扩展功能，显示和隐藏软键盘会如此简单。

扩展函数.kt

import android.app.Activity
import android.view.View
import android.view.inputmethod.InputMethodManager
import android.widget.EditText
import androidx.fragment.app.Fragment

fun Activity.hideKeyboard(): Boolean {
    return (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow((currentFocus ?: View(this)).windowToken, 0)
}

fun Fragment.hideKeyboard(): Boolean {
    return (context?.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow((activity?.currentFocus ?: View(context)).windowToken, 0)
}

fun EditText.hideKeyboard(): Boolean {
    return (context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .hideSoftInputFromWindow(windowToken, 0)
}

fun EditText.showKeyboard(): Boolean {
    return (context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager)
        .showSoftInput(this, 0)
}

• 用法

现在在您的ActivityorFragment中，hideKeyboard()可以清楚地访问以及从EditText类似的实例中调用它：

editText.hideKeyboard()

score 14 · Accepted Answer

我有这种情况，我的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 );
}

score 14 · Accepted Answer

对于开放式键盘：

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

对于关闭/隐藏键盘：

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

score 14 · Accepted Answer

每次都像魔术一样工作

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

score 12 · Accepted Answer

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

score 12 · Accepted Answer

用这个

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

score 11 · Accepted Answer

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

使用 InputMethodManager 并没有关闭键盘。我必须 clearFocus 并将搜索视图的焦点设置为 false：

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

score 11 · Accepted Answer

我几乎尝试了所有这些答案，我遇到了一些随机问题，尤其是三星 Galaxy 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);
}

score 11 · Accepted Answer

在某些情况下，除了所有其他方法之外，此方法也可以使用。这节省了我的一天:)

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

score 8 · Accepted Answer

您还可以考虑在 EditText 上使用setImeOption。

我只是有一个非常相似的情况，我的布局包含一个 EditText 和一个搜索按钮。当我发现我可以在我的 editText 上将 ime 选项设置为“actionSearch”时，我意识到我什至不再需要搜索按钮了。软键盘（在此模式下）有一个搜索图标，可用于启动搜索（键盘会按照您的预期自行关闭）。

score 8 · Accepted Answer

有时你想要的只是输入按钮来折叠你有属性keyboard 的盒子EditText

 android:imeOptions="actionDone"

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

score 8 · Accepted Answer

只需调用以下方法，它会在显示时隐藏您的键盘。

public void hideKeyboard() {
    try {
        InputMethodManager inputmanager = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (inputmanager != null) {
            inputmanager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
        }
    } catch (Exception var2) {
    }

}

score 7 · Accepted Answer

使用 AndroidX，我们将获得一种显示/隐藏键盘的惊人方式。阅读发行说明 - 1.5.0-alpha02。现在如何隐藏/显示键盘

val controller = view.windowInsetsController

// Show the keyboard
controller.show(Type.ime())
// Hide the keyboard
controller.hide(Type.ime())

链接我自己的答案如何检查 Android 软件键盘的可见性？和一个惊人的博客，其中包含更多的这种变化（甚至更多）。

score 6 · Accepted Answer

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

score 6 · Accepted Answer

这个对我有用..

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

把下面的代码行放在 onClick()

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

当我们单击按钮时隐藏键盘，当我们触摸 EditText 键盘时将显示。

（或者）

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

score 6 · Accepted Answer

有时您可以拥有一个包含列表视图的活动，其中包含包含 editText 的行，因此您必须在清单中进行设置，SOFT_INPUT_ADJUST_PAN然后它们的键盘会显示出来，这很烦人。

如果您将以下解决方法放在onCreate

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

score 6 · Accepted Answer

6

AndroidManifest.xml在下<activity..>集_ android:windowSoftInputMode="stateAlwaysHidden"

于 2015-12-14T09:33:26.260 回答

score 6 · Accepted Answer

如果要使用 Java 代码隐藏键盘，请使用以下命令：

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

或者，如果您想始终隐藏键盘，请在您的 AndroidManifest 中使用它：

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

score 6 · Accepted Answer

试试这个

很简单，你可以调用你的Activity

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

在你的MainActivitiy电话中

 hideKeyboardwithoutPopulate(MainActivity.this);

score 6 · Accepted Answer

这是工作..

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

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

score 6 · Accepted Answer

如果有人感兴趣，我已经为 Kotlin 编写了小扩展，但没有对其进行太多测试：

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 是存储在 Application 中的静态“this”Application 对象

更新：在某些情况下 windowToken 为空。我添加了额外的关闭键盘的方法，使用反射来检测键盘是否关闭

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

score 6 · Accepted Answer

如果你使用 Kotlin 来开发你的应用程序，那真的很容易做到。

添加此扩展功能：

对于活动：

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

对于片段：

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

现在你可以简单地调用你的 Fragment 或 Activity：

 hideKeyboard()

score 6 · Accepted Answer

对于 kotlin 爱好者。我创建了两个扩展函数。对于 hideKeyboard 的乐趣，您可以将 edittext 的实例作为视图传递。

fun Context.hideKeyboard(view: View) {
    (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager)?.apply {
        hideSoftInputFromWindow(view.windowToken, 0)
    }
}

fun Context.showKeyboard() {
    (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager)?.apply {
        toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY)
    }
}

score 5 · Accepted Answer

实际上，Android 权威总是在提供新的更新，但他们没有处理所有 Android 开发人员在开发过程中面临的旧缺陷，默认情况下这应该由 Android 权威处理，从 EditText 更改焦点时应该隐藏/显示软输入键盘选项。但是很抱歉，他们没有管理。好吧，别说了。

以下是在 Activity 或 Fragment 中显示/隐藏/切换键盘选项的解决方案。

显示视图的键盘：

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

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

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

显示带有片段上下文的键盘：

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

隐藏视图的键盘：

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

使用 Activity 上下文隐藏键盘：

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

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

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

切换键盘：

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

score 5 · Accepted Answer

在科特林

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

score 5 · Accepted Answer

当您想在按钮单击操作上手动隐藏键盘时：

/**
 * 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之外单击屏幕的任何位置隐藏键盘时，请 在您的活动中覆盖此方法：

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

score 5 · Accepted Answer

这是隐藏和显示方法。

科特林

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

爪哇

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

score 5 · Accepted Answer

调用该方法隐藏软键盘

public void hideKeyBoard() {
    View view1 = this.getCurrentFocus();
    if(view!= null){
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(view1.getWindowToken(), 0);
    }
}

score 5 · Accepted Answer

只需在特定活动的 AndroidManifest 中添加以下行。

<activity
        android:name=".MainActivity"
        android:screenOrientation="portrait"
        android:windowSoftInputMode="adjustPan"/>

score 5 · Accepted Answer

片段中的 KOTLIN 解决方案：

fun hideSoftKeyboard() {
        val view = activity?.currentFocus
        view?.let { v ->
            val imm =
                activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager // or context
            imm.hideSoftInputFromWindow(v.windowToken, 0)
        }
}

检查您的清单没有与您的活动关联的此参数：

android:windowSoftInputMode="stateAlwaysHidden"

score 4 · Accepted Answer

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

score 4 · Accepted Answer

试试这个

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

score 4 · Accepted Answer

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

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

score 4 · Accepted Answer

简单的方法家伙：试试这个......

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

score 4 · Accepted Answer

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

score 4 · Accepted Answer

这里有最好的解决方案

解决方案 1) 将 inputType 设置为“text”</p>

<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）。

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

解决方案 2) 使用 InputMethodManager.hideSoftInputFromWindow()

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

或者

InputMethodManager imm = (InputMethodManager) 
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 
InputMethodManager.HIDE_NOT_ALWAYS);

score 4 · Accepted Answer

很简单的方法

我在所有项目中都这样做，并且像梦想一样工作。在您的声明中layout.xml，只需添加这一行：

android:focusableInTouchMode="true"

完整代码示例：

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

score 4 · Accepted Answer

当从一个片段移动到另一个片段时

fun hideKeyboard(activity: Activity?): Boolean {
    val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    if (inputManager != null) {
        val currentFocus = activity?.currentFocus
        if (currentFocus != null) {
            val windowToken = currentFocus.windowToken
            if (windowToken != null) {
                return inputManager.hideSoftInputFromWindow(windowToken, 0)
            }
        }
    }
    return false
}

fun showKeyboard(editText: EditText) {
    val imm = editText.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    imm.hideSoftInputFromWindow(editText.windowToken, 0)
    imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0)
    editText.requestFocus()
}

score 3 · Accepted Answer

这对我有用。

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

score 3 · Accepted Answer

你可以简单地在你想隐藏软键盘的地方添加这个代码”

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

score 3 · Accepted Answer

在 Android 中，要通过 InputMethodManage 隐藏 Vkeyboard，您可以通过传入包含焦点视图的窗口令牌来调用 hideSoftInputFromWindow。

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_ONLY 甚至可以工作

score 3 · Accepted Answer

如果您的应用程序面向API 级别 21 或更高级别，则可以使用默认方法：

editTextObj.setShowSoftInputOnFocus(false);

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

<EditText  
    ....
    android:enabled="true"
    android:focusable="true" />

score 3 · Accepted Answer

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

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

    }

}

使用一行代码从任何地方调用上述方法。

CustomSnackbar.hideKeyboard(view, this@ActivityName)

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

score 3 · Accepted Answer

只需在 BaseActivity 和 BaseFragment 中为整个应用程序创建通用方法

在onCreate()初始化inputMethodManager

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

使此方法隐藏和显示键盘

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

score 3 · Accepted Answer

我使用 Kotlin 扩展来显示和隐藏键盘。

fun View.showKeyboard() {
  this.requestFocus()
  val inputMethodManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
  inputMethodManager.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
}

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

score 3 · Accepted Answer

通过将 Generic 方法添加到 Utility 或 Helper 类。通过调用自己，您可以隐藏和显示键盘

fun AppCompatActivity.hideKeyboard() {
            val view = this.currentFocus
            if (view != null) {
                val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
                imm.hideSoftInputFromWindow(view.windowToken, 0)
            }
           window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN)

        }


 fun AppCompatActivity.showKeyboard() {
            val view = this.currentFocus
            if (view != null) {
                val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
                imm.hideSoftInputFromWindow(view.windowToken, 0)
            }                     window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN)

        }

score 3 · Accepted Answer

如果您需要在片段中隐藏键盘，则此方法有效。

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

对于视图，只需传入

getView() method

score 3 · Accepted Answer

在 Kotlin 中只需使用这两种方法来显示和隐藏键盘。

fun showKeyboard() =
    (context.getSystemService(AppCompatActivity.INPUT_METHOD_SERVICE) as? InputMethodManager)!!
        .toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)

fun hideKeyboard(view: View) =
    (context.getSystemService(AppCompatActivity.INPUT_METHOD_SERVICE) as? InputMethodManager)!!
        .hideSoftInputFromWindow(view.windowToken, 0)

这view是你目前的看法，

score 3 · Accepted Answer

当您在编辑文本之外或其他任何地方触摸时，此代码将帮助您隐藏键盘。您需要在您的活动中添加此代码，或者您可以在项目的父活动中编写，它还会在 webview 中隐藏您的键盘。

@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    View v = getCurrentFocus();

    if (v != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && v instanceof EditText &&
            !v.getClass().getName().startsWith("android.webkit.")) {
        int[] sourceCoordinates = new int[2];
        v.getLocationOnScreen(sourceCoordinates);
        float x = ev.getRawX() + v.getLeft() - sourceCoordinates[0];
        float y = ev.getRawY() + v.getTop() - sourceCoordinates[1];

        if (x < v.getLeft() || x > v.getRight() || y < v.getTop() || y > v.getBottom()) {
            hideKeyboard(this);
        }

    }
    return super.dispatchTouchEvent(ev);
}

private void hideKeyboard(Activity activity) {
    if (activity != null && activity.getWindow() != null) {
        activity.getWindow().getDecorView();
        InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
        if (imm != null) {
            imm.hideSoftInputFromWindow(activity.getWindow().getDecorView().getWindowToken(), 0);
        }
    }
}

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

score 2 · Accepted Answer

我部分地从 xml 创建了一个布局，部分地从自定义布局引擎创建了一个布局，这一切都是在代码中处理的。唯一对我有用的是跟踪键盘是否打开，并使用键盘切换方法如下：

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

score 2 · Accepted Answer

绝望地在这里尝试了所有方法，结合了所有方法，当然键盘在 Android 4.0.3 中不会关闭（它在 Honeicomb AFAIR 中确实有效）。

然后突然间我发现了一个明显获胜的组合：

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

结合你平时的食谱

blahblaj.hideSoftInputFromWindow ...

希望这能阻止某人自杀……我已经接近了。当然，我不知道它为什么会起作用。

score 2 · Accepted Answer

这种方法将始终不惜一切代价。只要在你想隐藏键盘的地方使用它

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

像这样使用它：

不管是安卓版本。这种方法肯定会奏效

score 2 · Accepted Answer

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"设置

score 2 · Accepted Answer

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

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

这是 ActionBar 中的 SearchView 搜索框，当提交查询中的文本（用户按下Enter键或搜索按钮/图标）时，InputMethodManager代码会被激活并使您的软键盘按下。这段代码放在我的onCreateOptionsMenu(). searchItem是来自MenuItem哪个是默认代码的一部分onCreateOptionsmenu()。感谢@mckoss 提供了这段代码的一大块！

score 2 · Accepted Answer

private void hideSoftKeyboard() {
    View view = getView();
    if (view != null) {
        InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
                .getSystemService(Activity.INPUT_METHOD_SERVICE);
        inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
}

score 2 · Accepted Answer

尽管有所有这些答案，但为了简单起见，我写了一个通用的方法来做到这一点：

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

score 2 · Accepted Answer

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

score 2 · Accepted Answer

您可以为任何视图创建扩展功能

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

与 Activity 一起使用的示例

window.decorView.hideKeyboard();

与视图一起使用的示例

etUsername.hideKeyboard();

快乐的编码...

score 2 · Accepted Answer

Kotlin 中的 Wiki 答案：

1 - 在文件中创建一个顶级函数（例如一个包含所有顶级函数的文件）：

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 - 然后在您需要的任何活动中调用它：

this.hideKeyboard()

score 2 · Accepted Answer

对于 kotlin 用户来说，这里有一个适用于我的用例的 kotlin 扩展方法：

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

把它放在一个名为 ViewExtensions （或者你有什么）的文件中，然后像普通方法一样在你的视图上调用它。

score 2 · Accepted Answer

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

score 2 · Accepted Answer

首先，您应该从 XML 文件中添加android:imeOptions字段并将其值更改为actionUnspecified|actionGo，如下所示

 <android.support.design.widget.TextInputEditText
                    android:id="@+id/edit_text_id"
                    android:layout_width="fill_parent"
                    android:layout_height="@dimen/edit_text_height"
                    android:imeOptions="actionUnspecified|actionGo"
                    />

然后在 java 类中添加一个setOnEditorActionListener并添加 InputMethodManager 如下

enterOrderNumber.setOnEditorActionListener(new TextView.OnEditorActionListener() {

    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_GO) {
            InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
            imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
            return true;
        }
        return false;
    }
});

score 2 · Accepted Answer

这对我来说是工作。它在 Kotlin 中用于隐藏键盘。

private fun hideKeyboard() {
        val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
        val focusedView = activity?.currentFocus
        if (focusedView != null) {
            inputManager.hideSoftInputFromWindow(focusedView.windowToken,
                    InputMethodManager.HIDE_NOT_ALWAYS)
        }
    }

score 2 · Accepted Answer

一个简单的解决方法就是editText.setEnabled(false);editText.setEnabled(true);在您的 ButtononClick()方法中。

score 2 · Accepted Answer

科特林

class KeyboardUtils{
    
    companion object{
        fun hideKeyboard(activity: Activity) {
            val imm: InputMethodManager = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager
            var view: View? = activity.currentFocus
            if (view == null) {
                view = View(activity)
            }
            imm.hideSoftInputFromWindow(view.windowToken, 0)
        }
    }
}

然后在需要的地方调用它

碎片

KeyboardUtils.hideKeyboard(requireActivity())

活动

 KeyboardUtils.hideKeyboard(this)

score 2 · Accepted Answer

这个对我有用，你只需要传递里面的元素。

InputMethodManager imm=(InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.hideSoftInputFromWindow(AutocompleteviewDoctorState.getWindowToken(), 0);

score 1 · Accepted Answer

用try catch包围它，这样键盘已经关闭，应用程序不会崩溃：

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

score 1 · Accepted Answer

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

您可以使用

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

score 1 · Accepted Answer

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

 android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

它会起作用。

score 1 · Accepted Answer

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

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

所以我在做类似的事情：

    dialogBuilder = new AlertDialog.Builder(activity);

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

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

在完成所有视图（TextView、ImageView、EditText 等）的设置后，我做了：

        alertDialog = dialogBuilder.create();

        alertDialog.show();

在玩弄了所有答案之后，我发现如果您知道在哪里提出请求，它们中的大多数都可以工作......这就是所有问题的关键。

所以，诀窍是把它放在创建对话框之前alertDialog.show()：在我的例子中，这就像魅力：

        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 开发团队的一个小要求：

我认为所有这一切都是不必要的，因为您可以看到来自世界各地的成千上万的程序员正在处理这个荒谬而微不足道的问题，而它的解决方案应该是干净和简单的：恕我直言，如果我得到requestFocus()一个面向输入的视图（例如EditText)，键盘应该自动打开，除非用户要求不要，所以，我认为 requestFocus() 方法是这里的关键，应该接受 boolean showSoftKeyboard 默认值为true：View.requestFocus(boolean showSoftKeyboard);

希望这会帮助像我这样的其他人。

score 1 · Accepted Answer

Kotlin 版本

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

score 1 · Accepted Answer

一些科特林代码：

从活动中隐藏键盘：

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

score 1 · Accepted Answer

我正在使用以下 Kotlin Activity 扩展：

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

score 1 · Accepted Answer

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

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

score 1 · Accepted Answer

对于 Xamarin.Android：

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

score 1 · Accepted Answer

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

score 1 · Accepted Answer

嗨，如果您使用 Kotlin，这很简单，我相信您也可以轻松地将代码转换为 Java，首先在您的活动中使用此函数，当您的活动加载时，例如在 onCreate() 调用中。

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 文件中的活动中，就像这样......

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

score 1 · Accepted Answer

此代码段可以提供帮助：

    final InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);
    if (inputMethodManager != null && inputMethodManager.isActive()) {
        if (getCurrentFocus() != null) {
            inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);
        }
    }

可以根据需要用不同的方法调用（例如onPause、onResume、onRestart ...）

score 1 · Accepted Answer

Try This Force 完全 android 软输入键盘

在 Helper 类中创建方法。

InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    if (imm != null)
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

score 1 · Accepted Answer

适用于 Android 10 (API 29) 的片段

val activityView = activity?.window?.decorView?.rootView
activityView?.let {
    val imm = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
    imm?.hideSoftInputFromWindow(it.windowToken, 0)
}

score 1 · Accepted Answer

您也可以使用此代码片段在 Kotlin 中隐藏键盘。

 fun hideKeyboard(activity: Activity?) {
    val inputManager: InputMethodManager? = 
    activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as? 
    InputMethodManager
    // check if no view has focus:
    val v = activity?.currentFocus ?: return
    inputManager?.hideSoftInputFromWindow(v.windowToken, 0)
 }

score 1 · Accepted Answer

Android 11 中有一个新的 API WindowInsetsController，应用程序可以从任何视图访问控制器，我们可以通过它使用hide()和show()方法

val controller = view.windowInsetsController

// Show the keyboard (IME)
controller.show(Type.ime())

// Hide the keyboard
controller.hide(Type.ime())

见https://developer.android.com/reference/android/view/WindowInsetsController

score 1 · Accepted Answer

 //In Activity
        View v = this.getCurrentFocus();
        if (v != null) {
            InputMethodManager im = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
            im.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }


//In Fragment
        View v = getActivity().getCurrentFocus();
        if (v != null) {
            InputMethodManager im = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
            im.hideSoftInputFromWindow(view.getWindowToken(), 0);
        }
```

score 1 · Accepted Answer

如果你在你的.xmlandroid:focused="true" 中设置，那么他将无法工作，因为它是一个不可更改的集合。

所以解决方案： android:focusedByDefault="true"

比他设置一次，可以隐藏/显示键盘

score 1 · Accepted Answer

有很多答案，如果毕竟没有任何效果，那么这里有一个提示 :)，您可以制作一个 EditText 并且，

edittext.setAlpha(0f);

由于 alpha 方法，此编辑文本将不会被看到，现在使用上面的答案来了解如何使用 EditText 显示/隐藏软键盘。

score 1 · Accepted Answer

这是使用 Kotlin 隐藏软键盘的最简单方法：

//hides soft keyboard anything else is tapped( screen, menu bar, buttons, etc. )
override fun dispatchTouchEvent( ev: MotionEvent? ): Boolean {
    if ( currentFocus != null ) {
        val imm = getSystemService( Context.INPUT_METHOD_SERVICE ) as InputMethodManager
        imm.hideSoftInputFromWindow( currentFocus!!.windowToken, 0 )
    }
    return super.dispatchTouchEvent( ev )
}

score 1 · Accepted Answer

不要忘记：在智能手机的系统设置中是“输入法和语言 -> 物理键盘 -> 显示屏幕键盘 -> 开/关”。此设置“干扰”所有此处的编程解决方案！我也必须禁用/启用此设置才能完全隐藏/显示屏幕键盘！因为我正在为设备 MC2200 进行开发，所以我使用“EMDK 配置文件管理 -> Ui 管理器 -> 虚拟键盘状态 -> 显示/隐藏”来完成它

score 1 · Accepted Answer

public final class UtilsKeyboard {
/**
 * Sets the cursor at the end of this edit text and shows a keyboard
 */
public static void focusKeyboard(@NonNull EditText editText) {
    editText.requestFocus();
    editText.setSelection(editText.getText().length());
    showKeyboard(editText);
}

private static void showKeyboard(@NonNull View view) {
    final InputMethodManager manager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    if (manager != null) {
        manager.showSoftInput(view, InputMethodManager.SHOW_FORCED);
    }
}

public static boolean hideKeyboard(@NonNull Window window) {
    View view = window.getCurrentFocus();
    return hideKeyboard(window, view);
}

private static boolean hideKeyboard(@NonNull Window window, @Nullable View view) {
    if (view == null) {
        return false;
    }
    InputMethodManager inputMethodManager = (InputMethodManager) window.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    if (inputMethodManager != null) {
        return inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
    return false;
}

public static boolean hideKeyboard(@Nullable View view) {
    if (view == null) {
        return false;
    }
    InputMethodManager inputMethodManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
    if (inputMethodManager != null) {
        return inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0);
    }
    return false;
}

/**
 * This will hide the keyboard and unfocus any focused view.
 */
public static void unfocusKeyboard(@NonNull Window window) {
    // When showing the bottom menu, make sure the keyboard isn't and that no view has focus
    hideKeyboard(window);
    final View focused = window.getCurrentFocus();
    if (focused != null) focused.clearFocus();
}}

score 1 · Accepted Answer

    hide soft keyboard in Kotlin using globally using method. For using globally in Kotlin you need to create Singletone class. In Kotlin we are using object keyword for creating Singletone class.
    
    
    object Extensions {
    
      fun View.hideKeyboard() {
            val inputMethodManager =                                                 
            context.getSystemService(AppCompatActivity.INPUT_METHOD_SERVICE)           
            as InputMethodManager
            inputMethodManager.hideSoftInputFromWindow(windowToken, 0)
        }
    }

In your activity of fragment class where you need to hide the keyboard you can call this function with mainlayout id like below

//constraintEditLayout is my main view layout, if you are using other layout like relative or linear layouts you can call with that layout id
constraintEditLayout.hideKeyboard()

score 0 · Accepted Answer

我已经尝试了所有的解决方案，但没有解决方案对我有用，所以我找到了我的解决方案：你应该有布尔变量，比如：

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

在您调用的触摸屏事件中：

@Override
public boolean onTouchEvent(MotionEvent event) {
    if(keyboardShowing==true){
        inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0);
        keyboardShowing = false;
    }
    return super.onTouchEvent(event);
}

在 EditText 中是在任何地方：

yourEditText.setOnClickListener(new OnClickListener() {

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

        }
    });

score 0 · Accepted Answer

在 Kotlin 中试试这个

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

在 Java 中试试这个

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

这对我有用

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if (imm.isActive())
        imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);

score -1 · Accepted Answer

您的简单方法是在您的 EditText 视图中设置以下属性。

android:imeOptions="actionDone"

score -5 · Accepted Answer

这对我有用：

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

score -8 · Accepted Answer

-8

只需在您的视图中添加此属性EditTect即可隐藏键盘。

android:focusable="false"

于 2019-12-28T13:45:08.813 回答

android - 如何以编程方式关闭/隐藏 Android 软键盘？

123 回答 123

简短的回答

向下钻取

•Kotlin Version通过Extension Function

• 用法

试试这个

科特林

爪哇

科特林

碎片

活动

Related

Reference

•`Kotlin Version`通过`Extension Function`