Close/hide the Android Soft Keyboard
我的布局中有一个
在编辑字段中写入内容并单击
您可以使用inputMethodManager强制android隐藏虚拟键盘,调用
1 2 3 4 5 6 | // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } |
这将强制键盘在所有情况下都隐藏。在某些情况下,您希望传入
注意:如果要在Kotlin中执行此操作,请使用:
科特林语法
1 2 3 4 5 6 | // Check if no view has focus: val view = this.currentFocus view?.let { v -> val imm = getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager imm?.let { it.hideSoftInputFromWindow(v.windowToken, 0) } } |
为了澄清这种疯狂,我首先代表所有安卓用户为谷歌对软键盘的彻底荒谬处理道歉。对于同一个简单的问题,有如此多的答案,每个答案都不一样,因为这个API和安卓系统中的许多其他API一样,设计得非常糟糕。我想不出有礼貌的说法。
我想把键盘藏起来。我希望向Android提供以下声明:
这就是隐藏键盘如此具有挑战性的原因。亲爱的谷歌:当我在寻找蛋糕的配方时,地球上没有任何一个
这个可悲的故事以丑陋的事实结束:为了隐藏安卓键盘,你需要提供两种身份证明:一种是
我已经创建了一个静态实用程序方法,只要您从一个
1 2 3 4 5 6 7 8 9 10 | public static void hideKeyboard(Activity activity) { InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); //Find the currently focused view, so we can grab the correct window token from it. View view = activity.getCurrentFocus(); //If no view currently has focus, create a new one, just so we can grab a window token from it if (view == null) { view = new View(activity); } imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } |
请注意,此实用程序方法仅在从
但是假设您想将键盘隐藏在一个托管在一个
1 | hideKeyboard(getActivity()); //won't work |
这不起作用,因为您将传递一个对
1 2 3 4 | public static void hideKeyboardFrom(Context context, View view) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } |
以下是从追求此解决方案浪费的更多时间中收集到的一些附加信息:
关于windowsoftinputmode
还有另一个争论点需要注意。默认情况下,android会自动将初始焦点分配给您的
1 2 3 | <activity android:name=".MyActivity" android:windowSoftInputMode="stateAlwaysHidden"/> |
几乎令人难以置信的是,当您触摸控件时,似乎没有采取任何措施来阻止键盘打开(除非
因此,
希望这有帮助。
更新:获取窗口令牌的更多方法
如果没有焦点视图(例如,如果您刚刚更改了片段,则可能发生这种情况),则还有其他视图将提供有用的窗口标记。
这些是上面代码
在片段类中:
1 | view = getView().getRootView().getWindowToken(); |
给定一个片段
1 | view = fragment.getView().getRootView().getWindowToken(); |
从内容主体开始:
1 | view = findViewById(android.R.id.content).getRootView().getWindowToken(); |
更新2:清除焦点以避免在后台打开应用程序时再次显示键盘
将此行添加到方法末尾:
隐藏软键盘也很有用:
1 2 3 | getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN ); |
这可用于抑制软键盘,直到用户实际接触到EditText视图。
我还有一个隐藏键盘的解决方案:
1 2 | InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); |
这里在
迈尔的解决方案对我也适用。在我的例子中,我的应用程序的顶层是一个tabhost,我想在切换选项卡时隐藏关键字-我从tabhost视图中获取窗口令牌。
1 2 3 4 5 6 | tabHost.setOnTabChangedListener(new OnTabChangeListener() { public void onTabChanged(String tabId) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(tabHost.getApplicationWindowToken(), 0); } } |
请在
1 2 | EditText edtView=(EditText)findViewById(R.id.editTextConvertValue); edtView.setInputType(0); |
更新:我不知道为什么这个解决方案不再有效(我刚在android 23上测试过)。请使用Saurabh Pareek的溶液代替。这里是:
1 2 3 4 5 | InputMethodManager imm = (InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE); //Hide: imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); //Show imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); |
老回答:
1 2 3 4 | //Show soft-keyboard: getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); //hide keyboard : getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); |
1 2 3 4 | protected void hideSoftKeyboard(EditText input) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(input.getWindowToken(), 0); } |
如果这里的所有其他答案都不能像您希望的那样为您工作,那么还有另一种手动控制键盘的方法。
创建一个用于管理
1 2 3 4 5 6 7 8 9 | public void setEditTextFocus(boolean isFocused) { searchEditText.setCursorVisible(isFocused); searchEditText.setFocusable(isFocused); searchEditText.setFocusableInTouchMode(isFocused); if (isFocused) { searchEditText.requestFocus(); } } |
然后,确保打开/关闭键盘时
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | searchEditText.setOnFocusChangeListener(new OnFocusChangeListener() { @Override public void onFocusChange(View v, boolean hasFocus) { if (v == searchEditText) { if (hasFocus) { // Open keyboard ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(searchEditText, InputMethodManager.SHOW_FORCED); } else { // Close keyboard ((InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow(searchEditText.getWindowToken(), 0); } } } }); |
现在,只要您想手动打开键盘,请拨打:
1 | setEditTextFocus(true); |
对于结束通话:
1 | setEditTextFocus(false); |
到目前为止,苏拉巴·帕列克有最好的答案。
不过,也可以使用正确的标志。
1 2 3 4 5 6 7 | /* hide keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); /* show keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); |
实际使用示例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /* click button */ public void onClick(View view) { /* hide keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); /* start loader to check parameters ... */ } /* loader finished */ public void onLoadFinished(Loader<Object> loader, Object data) { /* parameters not valid ... */ /* show keyboard */ ((InputMethodManager) getSystemService(Activity.INPUT_METHOD_SERVICE)) .toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); /* parameters valid ... */ } |
通过这样的搜索,我找到了一个适合我的答案。
1 2 3 4 5 6 | // Show soft-keyboard: InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); // Hide soft-keyboard: getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); |
简短的回答
在你的
1 2 3 4 5 6 7 | button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { someEditText.onEditorAction(EditorInfo.IME_ACTION_DONE) } }); |
下钻
我觉得这个方法更好,更简单,更符合安卓的设计模式。在上面的简单示例中(通常在大多数常见情况下),您将得到一个具有焦点的
检查相关答案
这应该有效:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | public class KeyBoard { public static void show(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show } public static void hide(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide } public static void toggle(Activity activity){ InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); if (imm.isActive()){ hide(activity); } else { show(activity); } } } KeyBoard.toggle(activity); |
我正在使用自定义键盘输入十六进制数,因此无法显示i m m键盘…
在v3.2.4中,添加了"r1 EDOCX1"(11)以控制天气或在文本视图获得焦点时不显示键盘,但它仍然隐藏,因此必须使用反射:
1 2 3 4 5 6 7 8 | if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) { try { Method method = TextView.class.getMethod("setSoftInputShownOnFocus", boolean.class); method.invoke(mEditText, false); } catch (Exception e) { // Fallback to the second method } } |
对于旧版本,我使用
1 2 3 4 5 6 7 8 9 10 | @Override public void onGlobalLayout() { Configuration config = getResources().getConfiguration(); // Dont allow the default keyboard to show up if (config.keyboardHidden != Configuration.KEYBOARDHIDDEN_YES) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(mRootView.getWindowToken(), 0); } } |
最后一个解决方案可能会在一瞬间显示键盘,并干扰选择手柄。
当键盘进入全屏时,ongloballayout不会被调用。要避免这种情况,请使用textview setimeoptions(int)或在textview xml声明中:
1 | android:imeOptions="actionNone|actionUnspecified|flagNoFullscreen|flagNoExtractUi" |
更新:刚刚找到了对话框用来从不显示键盘和在所有版本中工作的内容:
1 2 | getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); |
1 2 3 4 5 6 7 8 | public void setKeyboardVisibility(boolean show) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); if(show){ imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); }else{ imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),0); } } |
我花了两天多的时间研究所有在线程中发布的解决方案,发现它们在某种程度上是缺乏的。我的确切要求是有一个按钮,将100%的可靠性显示或隐藏屏幕键盘。当键盘处于隐藏状态时,无论用户点击什么输入字段,都不应重新显示。当键盘处于可见状态时,不管用户点击什么按钮,键盘都不应该消失。这需要在Android 2.2+上一直工作到最新的设备。
您可以在我的应用程序clean rpn中看到此方法的有效实现。
在许多不同的手机(包括Froyo和Gingerbread设备)上测试了许多建议的答案之后,很明显Android应用程序能够可靠地:
对我来说,暂时隐藏键盘是不够的。在某些设备上,只要聚焦新的文本字段,它就会重新出现。当我的应用程序在一个页面上使用多个文本字段时,聚焦一个新的文本字段将导致隐藏的键盘再次弹出。
不幸的是,列表中的第2项和第3项仅在活动开始时工作可靠。一旦活动可见,就不能永久隐藏或显示键盘。诀窍是当用户按下键盘切换按钮时,实际重新启动您的活动。在我的应用程序中,当用户按下切换键盘按钮时,会运行以下代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | private void toggleKeyboard(){ if(keypadPager.getVisibility() == View.VISIBLE){ Intent i = new Intent(this, MainActivity.class); i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION); Bundle state = new Bundle(); onSaveInstanceState(state); state.putBoolean(SHOW_KEYBOARD, true); i.putExtras(state); startActivity(i); } else{ Intent i = new Intent(this, MainActivity.class); i.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION); Bundle state = new Bundle(); onSaveInstanceState(state); state.putBoolean(SHOW_KEYBOARD, false); i.putExtras(state); startActivity(i); } } |
这将使当前活动的状态保存到一个包中,然后启动该活动,并通过一个布尔值来指示是否应显示或隐藏键盘。
在onCreate方法内部运行以下代码:
1 2 3 4 5 6 7 8 | if(bundle.getBoolean(SHOW_KEYBOARD)){ ((InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(newEquationText,0); getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); } else{ getWindow().setFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM, WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM); } |
如果应该显示软键盘,则会通知InputMethodManager显示键盘,并指示窗口使软输入始终可见。如果应隐藏软键盘,则设置windowManager.layoutParams.flag_alt_focusable_im。
这种方法在我测试过的所有设备上都能可靠地工作——从运行Android2.2的4岁HTC手机到运行4.2.2的Nexus7。这种方法的唯一缺点是您需要小心处理后退按钮。由于我的应用程序基本上只有一个屏幕(它是一个计算器),我可以覆盖onbackpressed()并返回设备主屏幕。
除此全面解决方案外,如果您想从任何地方关闭软键盘,而不需要引用用于打开键盘的(edittext)字段,但仍想在该字段被聚焦时执行此操作,则可以使用此(来自活动):
1 2 3 4 | if (getCurrentFocus() != null) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); } |
多亏了这个答案,我得出了以下结论,在我的例子中,当滚动浏览viewpager的片段时,它可以很好地工作…
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | private void hideKeyboard() { // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } private void showKeyboard() { // Check if no view has focus: View view = this.getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT); } } |
上面的答案适用于不同的场景,但如果您想将键盘隐藏在视图中,并努力获得正确的上下文,请尝试以下方法:
1 2 3 4 5 6 7 8 9 10 11 12 13 | setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { hideSoftKeyBoardOnTabClicked(v); } } private void hideSoftKeyBoardOnTabClicked(View v) { if (v != null && context != null) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(v.getApplicationWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } |
并从构造函数中获取上下文:)
1 2 3 4 5 | public View/RelativeLayout/so and so (Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; init(); } |
如果要在单元测试或功能测试期间关闭软键盘,可以通过单击测试中的"后退按钮"来关闭软键盘:
1 2 | // Close the soft keyboard from a Test getInstrumentation().sendKeyDownUpSync(KeyEvent.KEYCODE_BACK); |
我在引号中加了"后退按钮",因为上面的内容不会触发所讨论活动的
确保在继续之前暂停一会儿,因为关闭"后退"按钮需要一点时间,所以随后单击视图等,直到短暂暂停(1秒足够长的时间)之后才会注册。
以下是你在Android的Mono(也叫MonoDroid)中的操作方法。
1 2 3 | InputMethodManager imm = GetSystemService (Context.InputMethodService) as InputMethodManager; if (imm != null) imm.HideSoftInputFromWindow (searchbox.WindowToken , 0); |
添加到清单文件中的活动
1 2 3 4 | <activity android:name=".ui.activity.MainActivity" android:label="@string/mainactivity" android:windowSoftInputMode="stateHidden"/> |
这对我的键盘行为很奇怪
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | private boolean isKeyboardVisible() { Rect r = new Rect(); //r will be populated with the coordinates of your view that area still visible. mRootView.getWindowVisibleDisplayFrame(r); int heightDiff = mRootView.getRootView().getHeight() - (r.bottom - r.top); return heightDiff > 100; // if more than 100 pixels, its probably a keyboard... } protected void showKeyboard() { if (isKeyboardVisible()) return; InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); if (getCurrentFocus() == null) { inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); } else { View view = getCurrentFocus(); inputMethodManager.showSoftInput(view, InputMethodManager.SHOW_FORCED); } } protected void hideKeyboard() { if (!isKeyboardVisible()) return; InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); View view = getCurrentFocus(); if (view == null) { if (inputMethodManager.isAcceptingText()) inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_NOT_ALWAYS, 0); } else { if (view instanceof EditText) ((EditText) view).setText(((EditText) view).getText().toString()); // reset edit text bug on some keyboards bug inputMethodManager.hideSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } } |
只需在活动中使用此优化代码:
1 2 3 4 | if (this.getCurrentFocus() != null) { InputMethodManager inputManager = (InputMethodManager) this.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } |
对于我的案例,我使用的是ActionBar中的搜索视图。用户执行搜索后,键盘将再次弹出打开。
使用InputMethodManager未关闭键盘。我必须清除Focus并将搜索视图的Focusable设置为false:
1 2 | mSearchView.clearFocus(); mSearchView.setFocusable(false); |
在某些情况下,除了所有其他方法外,这种方法都可以工作。这节省了我的一天:)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | public static void hideSoftKeyboard(Activity activity) { if (activity != null) { InputMethodManager inputManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); if (activity.getCurrentFocus() != null && inputManager != null) { inputManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); inputManager.hideSoftInputFromInputMethod(activity.getCurrentFocus().getWindowToken(), 0); } } } public static void hideSoftKeyboard(View view) { if (view != null) { InputMethodManager inputManager = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE); if (inputManager != null) { inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0); } } } |
简单易用的方法,只需调用hidekeyboardfrom(youreactivity.this);隐藏键盘
1 2 3 4 5 6 7 8 | /** * This method is used to hide keyboard * @param activity */ public static void hideKeyboardFrom(Activity activity) { InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); } |
我几乎尝试过所有这些答案,我有一些随机问题,特别是三星Galaxy S5。
我最后要做的是强迫演出和隐藏,而且效果很好:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /** * Force show softKeyboard. */ public static void forceShow(@NonNull Context context) { InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); } /** * Force hide softKeyboard. */ public static void forceHide(@NonNull Activity activity, @NonNull EditText editText) { if (activity.getCurrentFocus() == null || !(activity.getCurrentFocus() instanceof EditText)) { editText.requestFocus(); } InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(editText.getWindowToken(), 0); activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); } |
用这个
1 2 | this.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); |
1 2 3 4 | public static void hideSoftKeyboard(Activity activity) { InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); } |
在呼叫OnTouchlistener之后:
1 2 3 4 5 6 7 | findViewById(android.R.id.content).setOnTouchListener(new OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { Utils.hideSoftKeyboard(activity); return false; } }); |
我有这种情况,我的
1 2 3 4 5 6 7 8 | public static void hideKeyboard( Activity activity ) { InputMethodManager imm = (InputMethodManager)activity.getSystemService( Context.INPUT_METHOD_SERVICE ); View f = activity.getCurrentFocus(); if( null != f && null != f.getWindowToken() && EditText.class.isAssignableFrom( f.getClass() ) ) imm.hideSoftInputFromWindow( f.getWindowToken(), 0 ); else activity.getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN ); } |
每次都像魔术一样
1 2 3 4 5 6 7 8 9 10 11 12 | private void closeKeyboard() { InputMethodManager inputManager = (InputMethodManager)getActivity().getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } private void openKeyboard() { InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE); if(imm != null){ imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); } } |
对于打开的键盘:
1 2 | InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.showSoftInput(edtView, InputMethodManager.SHOW_IMPLICIT); |
对于关闭/隐藏键盘:
1 2 | InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(edtView.getWindowToken(), 0); |
您还可以研究在edittext上使用setimeoption。
我只是有一个非常模拟的情况,我的布局包含一个编辑文本和一个搜索按钮。当我发现我可以在我的edittext上将IME选项设置为"actionsearch"时,我意识到我甚至不再需要搜索按钮了。软键盘(在此模式下)有一个搜索图标,可用于启动搜索(键盘会按预期自动关闭)。
有时您只需要按Enter键即可折叠
1 | android:imeOptions="actionDone" |
这会将Enter按钮更改为Done按钮,该按钮将关闭键盘。
有时,您可以有一个活动,其中包含一个列表视图,其中的行包含edittext,因此您必须在清单
如果你把它放在
1 2 3 4 5 6 7 | getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); new Handler().postDelayed(new Runnable() { @Override public void run() { getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN); } },100); |
试试这个
- 很简单,你可以打电话到你的
Activity 。
1 2 3 4 5 6 7 | public static void hideKeyboardwithoutPopulate(Activity activity) { InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService( Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow( activity.getCurrentFocus().getWindowToken(), 0); } |
- 在你的
MainActivitiy 里,叫这个
1 | hideKeyboardwithoutPopulate(MainActivity.this); |
它对我有效……
1 | EditText editText=(EditText)findViewById(R.id.edittext1); |
在onclick()中的代码行下放置
1 2 | editText.setFocusable(false); editText.setFocusableInTouchMode(true); |
这里隐藏键盘当我们点击按钮和当我们触摸编辑文本键盘将显示。
(或)
1 | getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); |
我为Kotlin写了一个小的扩展名,如果有人感兴趣的话,我不会对它进行太多的测试:
1 2 3 4 5 6 7 | fun Fragment.hideKeyboard(context: Context = App.instance) { val windowToken = view?.rootView?.windowToken windowToken?.let { val imm = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(windowToken, 0) } } |
app.instance是静态的"this"应用程序对象,存储在应用程序中
更新:在某些情况下,WindowToken为空。我增加了另外一种关闭键盘的方法,使用反射来检测键盘是否关闭。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | /** * If no window token is found, keyboard is checked using reflection to know if keyboard visibility toggle is needed * * @param useReflection - whether to use reflection in case of no window token or not */ fun Fragment.hideKeyboard(context: Context = MainApp.instance, useReflection: Boolean = true) { val windowToken = view?.rootView?.windowToken val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager windowToken?.let { imm.hideSoftInputFromWindow(windowToken, 0) } ?: run { if (useReflection) { try { if (getKeyboardHeight(imm) > 0) { imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS) } } catch (exception: Exception) { Timber.e(exception) } } } } fun getKeyboardHeight(imm: InputMethodManager): Int = InputMethodManager::class.java.getMethod("getInputMethodWindowVisibleHeight").invoke(imm) as Int |
这是有效的……
只需在函数中传递当前活动实例
1 2 3 4 5 6 7 8 | public void isKeyBoardShow(Activity activity) { InputMethodManager imm = (InputMethodManager) activity.getSystemService(Activity.INPUT_METHOD_SERVICE); if (imm.isActive()) { imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); // hide } else { imm.toggleSoftInput(0, InputMethodManager.HIDE_IMPLICIT_ONLY); // show } } |
1 2 3 4 | public static void hideSoftKeyboard(Activity activity) { InputMethodManager inputMethodManager = (InputMethodManager)activity.getSystemService(Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); } |
在
如果你想用Java代码隐藏键盘,那么使用这个:
1 2 | InputMethodManager imm = (InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(fEmail.getWindowToken(), 0); |
或者如果你总是想隐藏键盘,那么在你的AndroidManifest中使用它:
1 2 3 | <activity android:name=".activities.MyActivity" android:configChanges="keyboardHidden" /> |
实际上,Android授权机构总是提供新的更新,但他们没有处理所有Android开发人员在开发过程中所面临的旧缺陷。默认情况下,Android授权机构应处理这一问题,在改变EditText的焦点时,应隐藏/显示软输入键盘选项。但很抱歉,他们没有管理。好吧,离开它。
下面是在活动或片段中显示/隐藏/切换键盘选项的解决方案。
显示视图键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /** * open soft keyboard. * * @param context * @param view */ public static void showKeyBoard(Context context, View view) { try { InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); keyboard.showSoftInput(view, 0); } catch (Exception e) { e.printStackTrace(); } } |
显示带有活动上下文的键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * open soft keyboard. * * @param mActivity context */ public static void showKeyBoard(Activity mActivity) { try { View view = mActivity.getCurrentFocus(); if (view != null) { InputMethodManager keyboard = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE); keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED); } } catch (Exception e) { e.printStackTrace(); } } |
用片段上下文显示键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /** * open soft keyboard. * * @param mFragment context */ public static void showKeyBoard(Fragment mFragment) { try { if (mFragment == null || mFragment.getActivity() == null) { return; } View view = mFragment.getActivity().getCurrentFocus(); if (view != null) { InputMethodManager keyboard = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE); keyboard.showSoftInputFromInputMethod(view.getWindowToken(), InputMethodManager.SHOW_FORCED); } } catch (Exception e) { e.printStackTrace(); } } |
隐藏视图键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /** * close soft keyboard. * * @param context * @param view */ public static void hideKeyBoard(Context context, View view) { try { InputMethodManager keyboard = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE); keyboard.hideSoftInputFromWindow(view.getWindowToken(), 0); } catch (Exception e) { e.printStackTrace(); } } |
使用活动上下文隐藏键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | /** * close opened soft keyboard. * * @param mActivity context */ public static void hideSoftKeyboard(Activity mActivity) { try { View view = mActivity.getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) mActivity.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0); } } catch (Exception e) { e.printStackTrace(); } } |
使用片段上下文隐藏键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | /** * close opened soft keyboard. * * @param mFragment context */ public static void hideSoftKeyboard(Fragment mFragment) { try { if (mFragment == null || mFragment.getActivity() == null) { return; } View view = mFragment.getActivity().getCurrentFocus(); if (view != null) { InputMethodManager inputManager = (InputMethodManager) mFragment.getActivity().getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(view.getWindowToken(), 0); } } catch (Exception e) { e.printStackTrace(); } } |
切换键盘:
1 2 3 4 5 6 7 8 9 10 11 12 13 | /** * toggle soft keyboard. * * @param context */ public static void toggleSoftKeyboard(Context context) { try { InputMethodManager imm = (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE); imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); } catch (Exception e) { e.printStackTrace(); } } |
简单代码:在onCreate()中使用此代码
1 2 3 | getWindow().setSoftInputMode( WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN ); |
如果你使用KOTLIN来开发你的应用程序,它真的很容易做到。
添加此扩展功能:
活动:
1 2 3 4 5 6 7 | fun Activity.hideKeyboard() { val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager val view = currentFocus if (view != null) { inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS) } } |
片段:
1 2 3 4 5 6 7 8 9 | fun Fragment.hideKeyboard() { activity?.let { val inputManager = it.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager val view = it.currentFocus if (view != null) { inputManager.hideSoftInputFromWindow(view.windowToken, InputMethodManager.HIDE_NOT_ALWAYS) } } } |
现在你可以简单地调用你的片段或活动:
1 | hideKeyboard() |
以下是隐藏和显示方法。
科特林1 2 3 4 5 6 7 8 9 10 11 12 13 | fun hideKeyboard(activity: Activity) { val v = activity.currentFocus val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager assert(v != null) imm.hideSoftInputFromWindow(v!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS) } private fun showKeyboard(activity: Activity) { val v = activity.currentFocus val imm = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager assert(v != null) imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT) } |
爪哇
1 2 3 4 5 6 7 8 9 10 11 12 13 | public static void hideKeyboard(Activity activity) { View v = activity.getCurrentFocus(); InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); assert imm != null && v != null; imm.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } private static void showKeyboard(Activity activity) { View v = activity.getCurrentFocus(); InputMethodManager imm = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE); assert imm != null && v != null; imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT); } |
非常简单的方法
我在所有的项目中都这样做,并且像做梦一样工作。在你的声明中,只需加上这一行:
1 | android:focusableInTouchMode="true" |
完整代码示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | <?xml version="1.0" encoding="utf-8"?> <android.support.constraint.ConstraintLayout xmlns:app="http://schemas.android.com/apk/res-auto" android:layout_width="match_parent" android:layout_height="match_parent" android:focusableInTouchMode="true"> <EditText android:layout_width="match_parent" android:layout_height="wrap_content" /> <ListView android:layout_width="match_parent" android:layout_height="wrap_content"> </ListView> </android.support.constraint.ConstraintLayout> |
试试这个
1 2 3 4 5 6 7 8 9 | public void disableSoftKeyboard(final EditText v) { if (Build.VERSION.SDK_INT >= 11) { v.setRawInputType(InputType.TYPE_CLASS_TEXT); v.setTextIsSelectable(true); } else { v.setRawInputType(InputType.TYPE_NULL); v.setFocusable(true); } } |
简单方法:试试这个…
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | private void closeKeyboard(boolean b) { View view = this.getCurrentFocus(); if(b) { if (view != null) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } } else { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.showSoftInput(view, 0); } } |
以下是最佳解决方案
解决方案1)将输入类型设置为"文本"
1 2 3 4 5 6 | <EditText android:id="@+id/my_edit_text" android:layout_width="fill_parent" android:layout_height="wrap_content" android:hint="Tap here to type" android:inputType="text" /> |
这也可以通过编程方式完成。方法setInputType()(从textView继承)。
1 2 3 | EditText editText = (EditText) findViewById(R.id.my_edit_text); editText.setRawInputType(InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_NORMAL); |
解决方案2)使用inputmethodmanager.hideSoftinputfromWindow()。
1 2 3 | InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(myEditText.getWindowToken(), 0); |
或
1 2 3 4 | InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(myEditText.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); |
如果要手动隐藏键盘上的按钮操作,请单击:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | /** * Hides the already popped up keyboard from the screen. * */ public void hideKeyboard() { try { // use application level context to avoid unnecessary leaks. InputMethodManager inputManager = (InputMethodManager) getApplicationContext().getSystemService(Context.INPUT_METHOD_SERVICE); assert inputManager != null; inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } catch (Exception e) { e.printStackTrace(); } } |
当您想隐藏键盘时,除了edittext,您在屏幕上单击的位置在活动中重写此方法:
1 2 3 4 5 6 7 8 9 10 11 12 13 | @Override public boolean dispatchTouchEvent(MotionEvent ev) { View view = getCurrentFocus(); if (view != null && (ev.getAction() == MotionEvent.ACTION_UP || ev.getAction() == MotionEvent.ACTION_MOVE) && view instanceof EditText && !view.getClass().getName().startsWith("android.webkit.")) { int scrcoords[] = new int[2]; view.getLocationOnScreen(scrcoords); float x = ev.getRawX() + view.getLeft() - scrcoords[0]; float y = ev.getRawY() + view.getTop() - scrcoords[1]; if (x < view.getLeft() || x > view.getRight() || y < view.getTop() || y > view.getBottom()) ((InputMethodManager)this.getSystemService(Context.INPUT_METHOD_SERVICE)).hideSoftInputFromWindow((this.getWindow().getDecorView().getApplicationWindowToken()), 0); } return super.dispatchTouchEvent(ev); } |
1 2 3 4 5 6 7 8 9 10 11 | final RelativeLayout llLogin = (RelativeLayout) findViewById(R.id.rl_main); llLogin.setOnTouchListener( new View.OnTouchListener() { @Override public boolean onTouch(View view, MotionEvent ev) { InputMethodManager imm = (InputMethodManager) this.getSystemService( Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0); return false; } }); |
1 2 3 4 5 6 | public static void hideSoftKeyboard(Activity activity) { InputMethodManager inputMethodManager = (InputMethodManager) activity .getSystemService(Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus() .getWindowToken(), 0); } |
我创建了一个布局,一部分来自XML,另一部分来自一个定制的布局引擎,这些都是用代码处理的。唯一对我有用的是跟踪键盘是否打开,并使用键盘切换方法如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | public class MyActivity extends Activity { /** This maintains true if the keyboard is open. Otherwise, it is false. */ private boolean isKeyboardOpen = false; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); LayoutInflater inflater; inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE); View contentView = inflater.inflate(context.getResources().getIdentifier("main","layout", getPackageName()), null); setContentView(contentView); contentView.getViewTreeObserver().addOnGlobalLayoutListener(new OnGlobalLayoutListener() { public void onGlobalLayout() { Rect r = new Rect(); contentView.getWindowVisibleDisplayFrame(r); int heightDiff = contentView.getRootView().getHeight() - (r.bottom - r.top); if (heightDiff > 100) isKeyboardVisible = true; else isKeyboardVisible = false; }); } } public void closeKeyboardIfOpen() { InputMethodManager imm; imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); if (isKeyboardVisible) imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); } } |
下面的代码将帮助您生成可以从任何地方调用的通用函数。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import android.app.Activity import android.content.Context import android.support.design.widget.Snackbar import android.view.View import android.view.inputmethod.InputMethodManager public class KeyboardHider { companion object { fun hideKeyboard(view: View, context: Context) { val inputMethodManager = context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager inputMethodManager.hideSoftInputFromWindow(view.windowToken, 0) } } } |
使用一行代码从任意位置调用上述方法。
1 | CustomSnackbar.hideKeyboard(view, this@ActivityName) |
视图可以是任何东西,例如活动的根布局。
在android中,要通过inputmethodmanage隐藏vkeyboard,您可以通过传递包含您的焦点视图的窗口标记来校准hideSoftinputfromWindow。
1 2 3 4 5 6 | View view = this.getCurrentFocus(); if (view != null) { InputMethodManager im = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); im.hideSoftInputFromWindow(view.getWindowToken(), 0); } |
通过调用edittext.clearfocus(),然后调用inputmethodmanager.hide_implicit_,甚至可以
这种方法总是以任何代价工作。只要在你想隐藏键盘的地方使用它
1 2 3 4 5 6 | public static void hideSoftKeyboard(Context mContext,EditText username){ if(((Activity) mContext).getCurrentFocus()!=null && ((Activity) mContext).getCurrentFocus() instanceof EditText){ InputMethodManager imm = (InputMethodManager)mContext.getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(username.getWindowToken(), 0); } } |
这样使用:
无论Android的版本是什么。这种方法肯定有效
您只需将此代码添加到要隐藏软键盘的位置即可。"
1 2 3 4 5 6 | // Check if no view has focus: View view = getCurrentFocus(); if (view != null) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } |
在Kotlin
1 2 3 4 5 | fun hideKeyboard(activity: BaseActivity) { val view = activity.currentFocus?: View(activity) val imm = activity.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(view.windowToken, 0) } |
这对我有用。
1 2 3 4 5 6 7 8 | public static void hideKeyboard(Activity act, EditText et){ Context c = act.getBaseContext(); View v = et.findFocus(); if(v == null) return; InputMethodManager inputManager = (InputMethodManager) c.getSystemService(Context.INPUT_METHOD_SERVICE); inputManager.hideSoftInputFromWindow(v.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } |
调用此方法隐藏软键盘
1 2 3 4 5 6 7 | public void hideKeyBoard() { View view1 = this.getCurrentFocus(); if(view!= null){ InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view1.getWindowToken(), 0); } } |
另一种使用
1 2 3 4 5 6 7 8 9 | searchView = (SearchView) searchItem.getActionView(); searchView.setOnQueryTextListener(new OnQueryTextListener() { @Override public boolean onQueryTextSubmit(String query) { InputMethodManager imm = (InputMethodManager) getSystemService(getApplicationContext().INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(searchView.getApplicationWindowToken(), 0); } } |
这是操作栏中的SearchView搜索框,当提交查询的文本时(用户按
您可以为任何视图创建扩展函数
1 2 3 4 | fun View.hideKeyboard() = this.let { val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(windowToken, 0) } |
与活动一起使用的示例
1 | window.decorView.hideKeyboard(); |
示例与视图一起使用
1 | etUsername.hideKeyboard(); |
快乐编码…
在这里绝望地尝试了所有的方法,结合所有的方法,当然键盘不会关闭在Android4.0.3(它确实在Honeicomb Afair工作)。
突然,我发现了一个明显获胜的组合:
1 | textField.setRawInputType(InputType.TYPE_CLASS_TEXT |InputType.TYPE_TEXT_VARIATION_NORMAL); |
结合你的常规食谱
1 | blahblaj.hideSoftInputFromWindow ... |
希望这能阻止某人自杀。我离它很近。当然,我不知道它为什么会起作用。
为了简单起见,我写了一个通用的方法来做这件事:
1 2 3 4 5 6 7 8 9 10 11 | /** * hide soft keyboard in a activity * @param activity */ public static void hideKeyboard (Activity activity){ activity.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN); if (activity.getCurrentFocus() != null) { InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(activity.getCurrentFocus().getWindowToken(), 0); } } |
1 2 3 4 5 6 7 8 9 | public static void closeInput(final View caller) { caller.postDelayed(new Runnable() { @Override public void run() { InputMethodManager imm = (InputMethodManager) caller.getContext().getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(caller.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS); } }, 100); } |
此方法通常有效,但有一个条件:不能设置
嗨,这很简单,如果你和Kotlin一起工作,我相信你也可以很容易地把代码转换成Java,首先在你的活动中,当你的活动在OnCeCATE()调用它时,使用这个函数。
1 2 3 4 5 | fun hideKeybord (){ val inputManager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager if (inputManager.isAcceptingText){ inputManager.hideSoftInputFromWindow(currentFocus.windowToken, 0) } |
}
正如我在oncreate()方法中提到的,调用这个函数,然后将这个
1 2 3 4 5 | <activity android:name=".Activity.MainActivity" android:label="@string/app_name" android:theme="@style/AppTheme.NoActionBar" android:windowSoftInputMode="stateAlwaysHidden"> |
对于外面的Kotlin用户,这里有一个适用于我的用例的Kotlin扩展方法:
1 2 3 4 | fun View.hideKeyboard() { val imm = this.context.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(windowToken, 0) } |
把它放在一个名为VIEW扩展的文件中(或者你有什么),就像正常的方法那样在你的视图上调用它。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | there are two ways to do so... method 1:in manifest file define the line **android:windowSoftInputMode="adjustPan|stateAlwaysHidden"** of code in your manifest.xml file as below... <activity android:name="packagename.youactivityname" android:screenOrientation="portrait" android:windowSoftInputMode="adjustPan|stateAlwaysHidden" /> Method 2 : in Activity or Java class if(getCurrentFocus()!=null) { InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE)`enter code here`; inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); } |
它会起作用的……@ask
在Kotlin中的wiki答案:
1-在文件中创建顶级函数(例如包含所有顶级函数的文件):
1 2 3 4 5 6 | fun Activity.hideKeyboard(){ val imm = this.getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager var view = currentFocus if (view == null) { view = View(this) } imm.hideSoftInputFromWindow(view.windowToken, 0) } |
2-然后在任何需要的活动中调用它:
1 | this.hideKeyboard() |
1 2 3 4 5 | fun hideKeyboard(appCompatActivity: AppCompatActivity) { val view = appCompatActivity.currentFocus val imm = appCompatActivity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(view.windowToken, 0) } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | public void hideKeyboard() { if(getCurrentFocus()!=null) { InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); } } public void showKeyboard(View mView) { InputMethodManager inputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE); mView.requestFocus(); inputMethodManager.showSoftInput(mView, 0); } |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | /** * * Hide I Said!!! * */ public static boolean hideSoftKeyboard(@NonNull Activity activity) { View currentFocus = activity.getCurrentFocus(); if (currentFocus == null) { currentFocus = activity.getWindow().getDecorView(); if (currentFocus != null) { return getSoftInput(activity).hideSoftInputFromWindow(currentFocus.getWindowToken(), 0, null); } } return false; } public static boolean hideSoftKeyboard(@NonNull Context context) { if(Activity.class.isAssignableFrom(context.getClass())){ return hideSoftKeyboard((Activity)context); } return false; } public static InputMethodManager getSoftInput(@NonNull Context context) { return (InputMethodManager) context.getSystemService(Activity.INPUT_METHOD_SERVICE); } |
一些Kotlin代码:
隐藏键盘以防活动:
1 2 3 | (currentFocus ?: View(this)) .apply { (getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager) .hideSoftInputFromWindow(windowToken, 0) } |
如果应用程序的目标API级别为21或更高,则需要使用默认方法:
1 | editTextObj.setShowSoftInputOnFocus(false); |
确保在
1 2 3 4 | <EditText .... android:enabled="true" android:focusable="true" /> |
Kotlin版本
1 2 3 4 5 | val imm: InputMethodManager = getSystemService(Activity.INPUT_METHOD_SERVICE) as InputMethodManager //Hide: imm.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0); //Show imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0); |
在阅读了上面和另一篇文章中的所有答案之后,我仍然没有成功地让键盘自动打开。
在我的项目中,我动态地创建了一个对话框(
所以我做了如下的事情:
1 2 3 4 5 6 7 8 | dialogBuilder = new AlertDialog.Builder(activity); if(dialogBuilder==null) return false; //error inflater = activity.getLayoutInflater(); dialogView = inflater.inflate(layout, null); ... |
在完成所有视图(textview、imageview、edittext等)的设置之后,我做了:
1 2 3 | alertDialog = dialogBuilder.create(); alertDialog.show(); |
在讨论了所有的答案之后,我发现如果你知道把请求放在哪里的话,大多数答案都是有效的。这是所有人的关键。
所以,诀窍是把它放在对话产生之前:在我的例子中,这就像魅力:
1 2 3 4 5 6 7 8 | alertDialog = dialogBuilder.create(); alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE); //And only when everything is finished - let's bring up the window - alertDialog.show(); //Viola... keyboard is waiting for you open and ready... //Just don't forget to request focus for the needed view (i.e. EditText..) |
我很确定这个原则在所有窗口中都是一样的,所以请注意"ShowKeyboard"代码的位置——它应该在窗口启动之前。
来自Android SDK开发团队的一个小请求:
我认为所有这些都是不必要的,正如您所看到的,来自世界各地的成千上万的程序员正在处理这个荒谬和琐碎的问题,而它的解决方案应该是干净和简单的:imho如果我让
希望这能帮助像我这样的人。
您只需要在清单活动标记内写一行
1 | android:windowSoftInputMode="stateAlwaysHidden|adjustPan" |
它会起作用的。
我正在使用以下Kotlin活动扩展:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | /** * Hides soft keyboard if is open. */ fun Activity.hideKeyboard() { currentFocus?.windowToken?.let { (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?) ?.hideSoftInputFromWindow(it, InputMethodManager.HIDE_NOT_ALWAYS) } } /** * Shows soft keyboard and request focus to given view. */ fun Activity.showKeyboard(view: View) { view.requestFocus() currentFocus?.windowToken?.let { (getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager?) ?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT) } } |
用Try-Catch包围它,这样键盘就已经关闭了,应用程序不会崩溃:
1 2 3 4 5 6 7 8 9 10 11 | try{ View view = this.getCurrentFocus(); if (view != null) { InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); } }catch (Exception e) { e.printStackTrace(); } |
只需在baseActivity和baseFragment中对整个应用程序进行通用方法
在
1 | inputMethodManager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); |
使用此方法隐藏和显示键盘
1 2 3 4 5 6 7 8 9 10 11 12 | public void hideKeyBoard(View view) { if (view != null) { inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0); } } public void showKeyboard(View view, boolean isForceToShow) { if (isForceToShow) inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0); else if (view != null) inputMethodManager.showSoftInput(view, 0); } |
1 2 3 4 5 6 7 8 | private void hideSoftKeyboard() { View view = getView(); if (view != null) { InputMethodManager inputMethodManager = (InputMethodManager) getActivity() .getSystemService(Activity.INPUT_METHOD_SERVICE); inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(), 0); } } |
要在应用程序启动时显示键盘:
1 2 3 4 5 6 7 | getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN | WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); view.requestFocus(); new Handler().postDelayed(new Runnable() { public void run() { getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN); } }, 1000); |
对于xamarin.android:
1 2 3 4 5 6 | public void HideKeyboard() { var imm = activity.GetSystemService(Context.InputMethodService).JavaCast<InputMethodManager>(); var view = activity.CurrentFocus ?? new View(activity); imm.HideSoftInputFromWindow(view.WindowToken, HideSoftInputFlags.None); } |
1 | use Text watcher instead of EditText.and after you finished entering the input |
你可以使用
1 2 | InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(view.getWindowToken(), 0); |
在科特林试试这个
1 2 3 4 | private fun hideKeyboard(){ val imm = activity!!.getSystemService(INPUT_METHOD_SERVICE) as InputMethodManager imm.hideSoftInputFromWindow(activity!!.currentFocus!!.windowToken, 0) } |
用Java试试
1 2 3 4 | private void hideKeyboard(){ InputMethodManager imm =(InputMethodManager)getSystemService(INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(), 0); } |
我已经尝试了所有的解决方案,但没有一个解决方案对我有效,所以我找到了我的解决方案:您应该有如下布尔变量:
1 2 3 | public static isKeyboardShowing = false; InputMethodManager inputMethodManager = (InputMethodManager) getActivity() .getSystemService(Context.INPUT_METHOD_SERVICE); |
在触摸屏事件中,您可以拨打:
1 2 3 4 5 6 7 8 | @Override public boolean onTouchEvent(MotionEvent event) { if(keyboardShowing==true){ inputMethodManager.toggleSoftInput(InputMethodManager.RESULT_UNCHANGED_HIDDEN, 0); keyboardShowing = false; } return super.onTouchEvent(event); } |
在edittext中,在任何地方:
1 2 3 4 5 6 7 8 | yourEditText.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { yourClass.keyboardShowing = true; } }); |
这对我很有用:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | @Override public boolean dispatchTouchEvent(MotionEvent event) { View v = getCurrentFocus(); boolean ret = super.dispatchTouchEvent(event); if (v instanceof EditText) { View w = getCurrentFocus(); int scrcoords[] = new int[2]; w.getLocationOnScreen(scrcoords); float x = event.getRawX() + w.getLeft() - scrcoords[0]; float y = event.getRawY() + w.getTop() - scrcoords[1]; Log.d("Activity", "Touch event" + event.getRawX() +"," + event.getRawY() +"" + x +"," + y +" rect" + w.getLeft() +"," + w.getTop() +"," + w.getRight() +"," + w.getBottom() +" coords" + scrcoords[0] +"," + scrcoords[1]); if (event.getAction() == MotionEvent.ACTION_UP && (x < w.getLeft() || x >= w.getRight() || y < w.getTop() || y > w .getBottom())) { InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE); imm.hideSoftInputFromWindow(getWindow().getCurrentFocus() .getWindowToken(), 0); } } return ret; } |