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

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

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

1767552 次浏览
小开

您可以使用输入方法参数管理强制Android隐藏虚拟键盘，调用#0，传入包含您的焦点视图的窗口的令牌。

// 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作为第二个参数，以确保仅在用户没有显式强制键盘出现（通过按住菜单）时隐藏键盘。

备注：如果您想使用静态编程语言执行此操作，请使用：context?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager

静态编程语言语法

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

请在onCreate()中尝试下面的代码

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

对于隐藏软键盘也很有用：

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

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

小开

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

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

更新：我不知道为什么这个解决方案不再有效（我刚刚在Android 23上测试）。请改用SaurabhPareek的解决方案。它是：

InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE);//Hide:imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);//Showimm.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);
小开

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

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

我把“后退按钮”放在引号中，因为上面的操作不会触发有问题的活动的onBackPressed()。它只是关闭键盘。

请确保在继续前进之前暂停一段时间，因为关闭后退按钮需要一段时间，因此随后单击视图等，直到短暂暂停后才会注册（1秒足够长）。

小开

如果这里的所有其他答案都不适合您，那么还有另一种手动控制键盘的方法。

创建一个函数来管理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() {@Overridepublic 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);
小开

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

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

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

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

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

小开

我正在使用自定义键盘输入十六进制数，因此我无法显示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}}

对于旧版本，我用OnGlobalLayoutListener得到了非常好的结果（但远非完美），在我的根视图中的ViewTreeObserver的帮助下添加，然后检查键盘是否显示如下：

@Overridepublic void onGlobalLayout() {Configuration config = getResources().getConfiguration();
// Dont allow the default keyboard to show upif (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) {InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0);}}

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

当在键盘中进入全屏时，不会调用onGlobalLayout。为避免这种情况，请使用文本视图#se tIme选项（in t）或在TextView XML声明中：

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

更新时间：刚刚发现什么对话框用于永远不显示键盘，并在所有版本中工作：

getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM,WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
小开 
protected void hideSoftKeyboard(EditText input) {InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);imm.hideSoftInputFromWindow(input.getWindowToken(), 0);}
小开

以下是Mono for Android（又名MonoDroid）中的操作方式

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

您还可以考虑在EditText上使用设置任务。

我刚刚遇到了一个非常类似的情况，我的布局包含一个EditText和一个搜索按钮。当我发现我可以在我的editText上将ime选项设置为“actionSearch”时，我意识到我甚至不再需要搜索按钮了。软键盘（在这种模式下）有一个搜索图标，可以用来启动搜索（键盘会像你期望的那样自动关闭）。

小开

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

setOnClickListener(new OnClickListener() {@Overridepublic 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();}
小开

有时你想要的只是回车键来折叠keyboard给出EditText框，您有属性

 android:imeOptions="actionDone"

这会将回车按钮更改为完成按钮，从而关闭键盘。

小开

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

public class MyActivity extends Activity{/** This maintains true if the keyboard is open. Otherwise, it is false. */private boolean isKeyboardOpen = false;
@Overridepublic 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;elseisKeyboardVisible = false;});}}
public void closeKeyboardIfOpen(){InputMethodManager imm;imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);if (isKeyboardVisible)imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);}}
小开

对于我的情况，我在操作栏中使用了SearchView。用户执行搜索后，键盘会再次弹出打开。

使用输入方法管理器并没有关闭键盘。我必须清除Focus并将搜索视图的可聚焦设置为false：

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

SaurabhPareek是目前为止最好的答案。

不过，也可以使用正确的旗帜。

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

我花了两天多的时间研究了线程中发布的所有解决方案，发现它们缺乏这样或那样的方式。我的确切要求是有一个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);}

如果应该显示软键盘，则Input方法管理器被告知显示键盘，并指示窗口使软输入始终可见。如果应该隐藏软键盘，则设置WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM。

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

小开 
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() {@Overridepublic boolean onTouch(View v, MotionEvent event) {Utils.hideSoftKeyboard(activity);return false;}});
小开

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

然后我突然发现了一个明显的成功组合：

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

再加上你平常的食谱

blahblaj.hideSoftInputFromWindow ...

希望这能阻止有人自杀……我离它很近。当然，我不知道它为什么有效。

小开
最佳答案

为了帮助澄清这种疯狂，我想首先代表所有Android用户为Google对软键盘的彻头彻尾的荒谬处理道歉。对于同一个简单的问题有这么多答案，每个答案都不同的原因是这个API，就像Android中的许多其他API一样，设计得很糟糕。我想不出礼貌的方式来表达它。

我想隐藏键盘。我希望为Android提供以下语句：Keyboard.hide()。结束。非常感谢。但是Android有一个问题。您必须使用InputMethodManager来隐藏键盘。好吧，好吧，这是Android的键盘API。但是！您需要有Context才能访问IMM。现在我们有一个问题。我可能想从静态或实用程序类中隐藏键盘，这些类对任何Context都没有用或不需要。更糟糕的是，IMM要求您指定要隐藏键盘的View（甚至更糟，Window）。

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

这个悲伤的故事以丑陋的事实结束：要隐藏Android键盘，您需要提供两种形式的身份证明：Context和View或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 itif (view == null) {view = new View(activity);}imm.hideSoftInputFromWindow(view.getWindowToken(), 0);}

请注意，此实用方法仅在从Activity调用时有效！上述方法调用目标Activity的getCurrentFocus以获取正确的窗口令牌。

但是假设您想从DialogFragment中托管的EditText中隐藏键盘？您不能使用上面的方法：

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

这将不起作用，因为您将传递对Fragment的主机Activity的引用，当Fragment显示时，它将没有焦点控制！哇！所以，为了隐藏键盘片段，我求助于较低级别，更常见，更丑陋：

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

下面是一些额外的信息，从更多的时间浪费在追逐这个解决方案：

关于windows软输入模式

还有另一个需要注意的争论点。默认情况下，Android会自动将初始焦点分配给Activity中的第一个EditText或可聚焦控件。很自然地，Input方法（通常是软键盘）将通过显示自身来响应焦点事件。AndroidManifest.xml中的windowSoftInputMode属性，当设置为stateAlwaysHidden时，指示键盘忽略这个自动分配的初始焦点。

<activityandroid: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();

小开

使用此

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

或者这个全方位的解决方案，如果你想关闭软键盘从任何地方而不引用用于打开键盘的（EditText）字段，但如果字段聚焦，你仍然想这样做，你可以使用这个（来自一个活动）：

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

这应该工作：

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

这种方法总是不惜一切代价工作的只要在你想隐藏键盘的地方使用它

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。这种方法肯定会奏效

小开

这对我有用：

 @Overridepublic 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;}
小开

它为我工作…

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

在onClick（）中放置下面的代码行

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

这里隐藏键盘当我们点击按钮，当我们触摸EditText键盘将显示。

（或）

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

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

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 buginputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);}}
小开 
public static void closeInput(final View caller) {caller.postDelayed(new Runnable() {@Overridepublic 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"

小开

这对我有用。

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

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

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

使用SearchView的替代方法是使用以下代码：

searchView = (SearchView) searchItem.getActionView();searchView.setOnQueryTextListener(new OnQueryTextListener() {@Overridepublic 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提供了大量此代码！

小开

简短的回答

在你的OnClick监听器中，用IME_ACTION_DONE调用EditText中的onEditorAction

button.setOnClickListener(new OnClickListener() {
@Overridepublic void onClick(View v) {someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE)}});

下钻

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

看看这个相关答案

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

考虑所有这些答案，只是为了简单起见，我写了一个常见的方法来做到这一点：

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

我有这样的情况，我的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 );elseactivity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN );}
小开

试试这个

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

打开键盘：

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

我尝试了所有的解决方案，但没有一个解决方案适合我，所以我找到了我的解决方案：你应该有这样的布尔变量：

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

在触摸屏事件中，您可以调用：

@Overridepublic 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() {
@Overridepublic void onClick(View v) {yourClass.keyboardShowing = true;
}});
小开

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

感谢这个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);}}
小开

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

如果您将其放在onCreate的末尾，则以下工作区有效

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);new Handler().postDelayed(new Runnable() {@Overridepublic void run() {getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN);}},100);
小开

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

小开

简单代码：在onCreate（）返回值

中使用此代码 
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
小开

在某些情况下，除了所有其他方法外，此方法可以正常工作。这救了我的一天：）

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

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

<activityandroid:name=".ui.activity.MainActivity"android:label="@string/mainactivity"android:windowSoftInputMode="stateHidden"/>
小开 
/****   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);}
小开

简单的方法：试试这个…

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

如果您想使用Java代码隐藏键盘，请使用：

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

或者，如果您想始终隐藏键盘，请在Android清单中使用此选项：

 <activityandroid:name=".activities.MyActivity"android:configChanges="keyboardHidden"  />
小开

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

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

 android:windowSoftInputMode="stateAlwaysHidden|adjustPan"

它会奏效的。

小开

简单易用的方法，只需调用隐藏键盘从（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);}
小开 
final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main);llLogin.setOnTouchListener(new View.OnTouchListener() {@Overridepublic boolean onTouch(View view, MotionEvent ev) {InputMethodManager imm = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE);imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);return false;}});
小开

每次都像魔术般奏效

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

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

在我的项目中，我动态地创建了一个对话框（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();

在玩弄了所有的答案后，我发现他们中的大多数都在工作IF你知道在哪里把请求……这是所有人的关键。

所以，诀窍是把它之前对话框的创建：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），键盘应该自动打开，除非用户要求不，所以，我认为请求焦点（）方法是这里的关键，应该接受默认值为true的boolean showSoftKeyboard：View.requestFocus(boolean showSoftKeyboard);

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

小开

试试这个

  • 简单，你可以调用你的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);
小开

这是工作…

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

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

静态编程语言版本 

val imm: InputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager//Hide:imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);//Showimm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
小开

您可以简单地将此代码添加到要隐藏软键盘的位置”

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

以下是最佳解决方案

解决方案1）将inputType设置为“text”

<EditTextandroid: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);
小开

我写了静态编程语言的小扩展，如果有人感兴趣，没有测试它：

fun Fragment.hideKeyboard(context: Context = App.instance) {val windowToken = view?.rootView?.windowTokenwindowToken?.let {val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManagerimm.hideSoftInputFromWindow(windowToken, 0)}}

App.instance是静态的"this"Application对象存储在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?.windowTokenval imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerwindowToken?.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
小开

在Android中，要通过Input老兄Manage隐藏V键盘，您可以通过传入包含您的焦点视图的窗口的标记来调用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甚至工作

小开

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

editTextObj.setShowSoftInputOnFocus(false);

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

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

一些kotlin代码：

从活动中隐藏键盘：

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

很简单的方法

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

android:focusableInTouchMode="true"

完整代码示例：

<?xml version="1.0" encoding="utf-8"?><android.support.constraint.ConstraintLayoutxmlns:app="http://schemas.android.com/apk/res-auto"android:layout_width="match_parent"android:layout_height="match_parent"android:focusableInTouchMode="true">
<EditTextandroid:layout_width="match_parent"android:layout_height="wrap_content" />
<ListViewandroid:layout_width="match_parent"android:layout_height="wrap_content">
</ListView>
</android.support.constraint.ConstraintLayout>
小开

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

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

与活动一起使用的示例

window.decorView.hideKeyboard();

使用View的示例

etUsername.hideKeyboard();

编码愉快…

小开

实际上，总是Android权威机构提供新的更新，但他们没有处理所有Android开发人员在开发中面临的旧缺点，默认情况下，这应该由Android权威机构处理，从EditText更改焦点应该隐藏/显示软输入键盘选项。但对不起，他们没有管理。好的，离开它。

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

为视图显示键盘：

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

隐藏带有活动上下文的键盘：

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

静态编程语言

fun hideKeyboard(activity: BaseActivity) {val view = activity.currentFocus?: View(activity)val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManagerimm.hideSoftInputFromWindow(view.windowToken, 0)}
小开

我使用以下静态编程语言活动扩展：

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

当您想手动隐藏键盘按钮点击的动作：

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

当你想隐藏键盘，无论你点击屏幕除了编辑文本在您的活动中重写此方法：

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

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

        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：

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

这里有两个隐藏和显示方法。

静态编程语言

fun hideKeyboard(activity: Activity) {val v = activity.currentFocusval imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerassert(v != null)imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)}
private fun showKeyboard(activity: Activity) {val v = activity.currentFocusval imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerassert(v != null)imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT)}

Java

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

用静态编程语言试试这个

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

试试这个Java

 private void hideKeyboard(){InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE);imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0);}
小开 
 fun hideKeyboard(appCompatActivity: AppCompatActivity) {val view = appCompatActivity.currentFocusval imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerimm.hideSoftInputFromWindow(view.windowToken, 0)}
小开 
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-在文件中创建顶层函数（例如，包含所有顶级函数的文件）：

fun Activity.hideKeyboard(){val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManagervar view = currentFocusif (view == null) { view = View(this) }imm.hideSoftInputFromWindow(view.windowToken, 0)}

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

this.hideKeyboard()
小开

调用此方法隐藏软键盘

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

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

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

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

小开

如果你使用静态编程语言来开发你的应用程序，这真的很容易做到。

添加此扩展功能：

活动安排：

fun Activity.hideKeyboard() {val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerval view = currentFocusif (view != null) {inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)}}

对于片段：

fun Fragment.hideKeyboard() {activity?.let {val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerval view = it.currentFocusif (view != null) {inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)}}}

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

 hideKeyboard()
小开

如果您使用的是静态编程语言，这很简单，我相信您可以轻松地将代码转换为Java首先在您的活动中使用此函数，当您的活动被加载时，例如在onCreate（）调用它。

fun hideKeybord (){val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerif (inputManager.isAcceptingText){inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0)}

}

正如我提到的，在你的onCreate（）方法中调用这个函数，然后将这个android:windowSoftInputMode="stateAlwaysHidden"行添加到你在文件中manafest.xml活动中。 

<activityandroid:name=".Activity.MainActivity"android:label="@string/app_name"android:theme="@style/AppTheme.NoActionBar"android:windowSoftInputMode="stateAlwaysHidden">
小开 
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...
<activityandroid: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);}

它会work....@ASK

小开

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

import android.app.Activityimport android.content.Contextimport android.support.design.widget.Snackbarimport android.view.Viewimport android.view.inputmethod.InputMethodManager
public class KeyboardHider {companion object {
fun hideKeyboard(view: View, context: Context) {val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManagerinputMethodManager.hideSoftInputFromWindow(view.windowToken, 0)}
}
}

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

CustomSnackbar.hideKeyboard(view, this@ActivityName)

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

小开

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

在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);}
小开

此代码片段可以帮助：

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

可以根据需要以不同的方法调用它（例如。

小开

首先，您应该从XML文件添加安卓系统：imeOptions字段并将其值更改为未指定的动作，如下所示

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

然后在java类中添加setOn编辑器动作监听器并添加如下所示的输入方法管理器

enterOrderNumber.setOnEditorActionListener（）{//编辑动作监听器

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

这是我的工作。它是用静态编程语言隐藏键盘。

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

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

<activityandroid:name=".MainActivity"android:screenOrientation="portrait"android:windowSoftInputMode="adjustPan"/>
小开

一个简单的解决方法是在按钮onClick()方法中仅editText.setEnabled(false);editText.setEnabled(true);。

小开

试试这个强制完全Android软输入键盘

在Helper类中创建方法。

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

我使用静态编程语言扩展来显示和隐藏键盘。

fun View.showKeyboard() {this.requestFocus()val inputMethodManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerinputMethodManager.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)}
fun View.hideKeyboard() {val inputMethodManager = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerinputMethodManager.hideSoftInputFromWindow(windowToken, 0)}
小开

适用于Android 10（API 29）的片段

val activityView = activity?.window?.decorView?.rootViewactivityView?.let {val imm = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManagerimm?.hideSoftInputFromWindow(it.windowToken, 0)}
小开

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

android:imeOptions="actionDone"
小开

对于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)}}
小开

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

android:focusable="false"
小开

只需调用下面的方法，它将隐藏您的键盘，如果它显示。

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) {}
}
小开

通过将泛型方法添加到您的实用程序或Helper类。通过调用自身，您可以隐藏和显示键盘

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

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

您也可以使用此代码片段隐藏静态编程语言中的键盘。

 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 ?: returninputManager?.hideSoftInputFromWindow(v.windowToken, 0)}
小开

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

fun hideKeyboard(activity: Activity?): Boolean {val inputManager = activity?.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager?if (inputManager != null) {val currentFocus = activity?.currentFocusif (currentFocus != null) {val windowToken = currentFocus.windowTokenif (windowToken != null) {return inputManager.hideSoftInputFromWindow(windowToken, 0)}}}return false}
fun showKeyboard(editText: EditText) {val imm = editText.context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManagerimm.hideSoftInputFromWindow(editText.windowToken, 0)imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0)editText.requestFocus()}
小开

•Kotlin Version通过Extension Function

使用kotlin扩展函数，显示和隐藏软键盘非常简单。

ExtensionFunctions.kt

import android.app.Activityimport android.view.Viewimport android.view.inputmethod.InputMethodManagerimport android.widget.EditTextimport 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)}

•使用

现在在您的Activity或Fragment中，hideKeyboard()可以清楚地访问，也可以从EditText的实例调用它，例如：

editText.hideKeyboard()
小开

静态编程语言

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

那你想叫什么就叫什么

碎片

KeyboardUtils.hideKeyboard(requireActivity())

活动

 KeyboardUtils.hideKeyboard(this)
小开

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

val controller = view.windowInsetsController
// Show the keyboardcontroller.show(Type.ime())// Hide the keyboardcontroller.hide(Type.ime())

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

小开

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

val controller = view.windowInsetsController
// Show the keyboard (IME)controller.show(Type.ime())
// Hide the keyboardcontroller.hide(Type.ime())

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

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

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

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

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

如果你设置在你的.xml android：集中="true"，比他不会工作，因为它是一个集合，就像它是不可改变的。

所以解决方案：Android：默认聚焦=“true”

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

小开

碎片中的KOTLIN溶液：

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

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

android:windowSoftInputMode="stateAlwaysHidden"
小开

有很多答案，如果毕竟什么都不起作用，那么，这里有一个提示：），您可以创建一个EditText和，

edittext.setAlpha(0f);

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

小开

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

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
小开

在静态编程语言中，只需使用这两种方法来显示和隐藏键盘。

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是您的当前视图，

小开

以下是使用静态编程语言隐藏软键盘的最简单方法：

//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 InputMethodManagerimm.hideSoftInputFromWindow( currentFocus!!.windowToken, 0 )}return super.dispatchTouchEvent( ev )}
小开

现在，将近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())
小开

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

小开

感谢上帝官方支持经过11年

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

然后从ViewCompat或WindowCompat类获取InsetsController。

最后使用InsetsController的hide（）和show（）函数

编辑
添加对话框支持。在BottomSheetDialog中可用。@Rondev。
使用更安全的方式获取活动，而不是直接从上下文中转换。

import android.app.Activityimport android.app.Dialogimport android.content.Contextimport android.content.ContextWrapperimport android.view.Viewimport androidx.core.view.ViewCompatimport androidx.core.view.WindowCompatimport androidx.core.view.WindowInsetsCompatimport androidx.fragment.app.Fragment
fun View.showKeyboard() = ViewCompat.getWindowInsetsController(this)?.show(WindowInsetsCompat.Type.ime())fun View.hideKeyboard() = ViewCompat.getWindowInsetsController(this)?.hide(WindowInsetsCompat.Type.ime())
fun Dialog.showKeyboard() = window?.decorView?.showKeyboard()fun Dialog.hideKeyboard() = window?.decorView?.hideKeyboard()
fun Context.showKeyboard() = getActivity()?.showKeyboard()fun Context.hideKeyboard() = getActivity()?.hideKeyboard()
fun Fragment.showKeyboard() = activity?.showKeyboard()fun Fragment.hideKeyboard() = activity?.hideKeyboard()
fun Activity.showKeyboard() = WindowCompat.getInsetsController(window, window.decorView)?.show(WindowInsetsCompat.Type.ime())fun Activity.hideKeyboard() = WindowCompat.getInsetsController(window, window.decorView)?.hide(WindowInsetsCompat.Type.ime())
fun Context.getActivity(): Activity? {return when (this) {is Activity -> thisis ContextWrapper -> this.baseContext.getActivity()else -> null}}

下面的老家伙

下面是github上的简单项目

import android.app.Activityimport android.app.Dialogimport android.content.Contextimport android.content.ContextWrapperimport android.view.Viewimport androidx.core.view.ViewCompatimport androidx.core.view.WindowCompatimport androidx.core.view.WindowInsetsCompatimport androidx.fragment.app.Fragment
fun View.showKeyboard() = ViewCompat.getWindowInsetsController(this)?.show(WindowInsetsCompat.Type.ime())fun View.hideKeyboard() = ViewCompat.getWindowInsetsController(this)?.hide(WindowInsetsCompat.Type.ime())
fun Dialog.showKeyboard() = window?.decorView?.showKeyboard()fun Dialog.hideKeyboard() = window?.decorView?.hideKeyboard()
fun Context.showKeyboard() = getActivity()?.showKeyboard()fun Context.hideKeyboard() = getActivity()?.hideKeyboard()
fun Fragment.showKeyboard() = activity?.showKeyboard()fun Fragment.hideKeyboard() = activity?.hideKeyboard()
fun Activity.showKeyboard() = WindowCompat.getInsetsController(window, window.decorView)?.show(WindowInsetsCompat.Type.ime())fun Activity.hideKeyboard() = WindowCompat.getInsetsController(window, window.decorView)?.hide(WindowInsetsCompat.Type.ime())
fun Context.getActivity(): Activity? {return when (this) {is Activity -> thisis ContextWrapper -> this.baseContext.getActivity()else -> null}}
小开 
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 focushideKeyboard(window);final View focused = window.getCurrentFocus();if (focused != null) focused.clearFocus();}}
小开

通过创建可以全局使用的扩展来隐藏静态编程语言中的软键盘。为此，您需要创建一个Singleton类。

object Extensions {    
fun View.hideKeyboard() {val inputMethodManager =context.getSystemService(AppCompatActivity.INPUT_METHOD_SERVICE)as InputMethodManagerinputMethodManager.hideSoftInputFromWindow(windowToken, 0)}}

在你需要隐藏键盘的fra的类的活动中，你可以像下面这样使用main布局id调用这个函数

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

这对我很管用

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

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

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

我的解决方案：

用活动构造它（视图是可选的），使用处理程序发布这个（有一些延迟，例如100ms更好）。直接调用输入管理器有时不起作用。只有工作时才能得到活动。我认为这是正常的。

如果你可以得到你的根视图组或editview当你调用，只是把它在更好的结果。

public class CloseSoftKeyboardRunnable implements Runnable{Activity activity;View view;  // for dialog will occur context getcurrentfocus == null. send a rootview to find currentfocus.
public CloseSoftKeyboardRunnable(Activity activity, View view){this.activity = activity;this.view = view;}
public CloseSoftKeyboardRunnable(Activity activity){this.activity = activity;}@Overridepublic void run() {if (!activity.isFinishing()){InputMethodManager imm = (InputMethodManager)activity.getSystemService(Context.INPUT_METHOD_SERVICE);
if (view == null) {view = activity.getCurrentFocus();}else{try {view = ((ViewGroup)view).getFocusedChild();}catch ( Exception e) {}}
Window window =  activity.getWindow();            
if (window != null){if (view == null) {try {view = window.getDecorView();view = ((ViewGroup)view).getFocusedChild();}catch ( Exception e) {}}
if (view == null) {view = window.getDecorView();}
if (view != null) {if (view instanceof EditText){EditText edittext = ((EditText) view);edittext.setText(edittext.getText().toString()); // reset edit text bug on some keyboards bugedittext.clearFocus();}
imm.hideSoftInputFromWindow(view.getWindowToken(), 0);}window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);}}}}
小开

这些答案中有许多是不必要的复杂；这里有一个解决方案，静态编程语言用户可以在View类上创建一个整洁的小扩展函数。

创建一个基本的静态编程语言文件（我的命名为KeyboardUtil.kt），并介绍以下内容：

fun View.hideKeyboard() {val imm = ContextCompat.getSystemService(context, InputMethodManager::class.java) as InputMethodManagerimm.hideSoftInputFromWindow(windowToken, 0)}

然后，你可以在任何视图上调用它来轻松关闭键盘。我使用ViewB的/DataB的，它工作得特别好，例如：

fun submitForm() {binding.root.hideKeyboard()// continue now the keyboard is dismissed}
小开

对于那些寻找jetpack撰写答案。

val keyboardController = LocalSoftwareKeyboardController.current
//for showing the keyboardkeyboardController?.show()//for hiding the keyboardkeyboardController?.hide()
小开

静态编程语言版本：

fun showKeyboard(mEtSearch: EditText, context: Context) {mEtSearch.requestFocus()val imm: InputMethodManager =context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManagerimm.showSoftInput(mEtSearch, 0)}
小开

您可以使用下面的扩展来隐藏和显示软键盘

fun Fragment.showKeyboard(view: View) {view.isFocusableInTouchMode = trueview.requestFocus()val imm = view.context?.getSystemService(Context.INPUT_METHOD_SERVICE)as InputMethodManagerimm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT) }
fun Fragment.hideKeyboard(view: View) {view.clearFocus()val imm = view.context?.getSystemService(Context.INPUT_METHOD_SERVICE)as InputMethodManagerimm.hideSoftInputFromWindow(view.windowToken, 0) }

要调用扩展，您可以简单地按照下面的片段

showKeyboard(Your edittext ID)
hideKeboard(Your edittext ID)

提交答案