закрыть/скрыть программную клавиатуру android

<p>у меня есть <code>edittext</code> и <code>button</code> в моем макете.</p><p>после записи в поле редактирования и нажатия на <code>button</code> я хочу скрыть виртуальную клавиатуру. я предполагаю, что это простой кусок кода, но где я могу найти пример этого?</p>

<p>чтобы прояснить это безумие, я хотел бы начать с извинения от имени всех пользователей android за совершенно нелепое обращение google с программной клавиатурой. причина в том, что существует так много разных ответов на один и тот же простой вопрос, потому что этот api, как и многие другие в android, разработан ужасно. я не могу придумать никакого вежливого способа заявить об этом.</p><p>я хочу спрятать клавиатуру. я ожидаю предоставить android следующее утверждение: <code>keyboard.hide()</code>. конец. большое спасибо. но у android есть проблема. вы должны использовать <code>inputmethodmanager</code>, чтобы скрыть клавиатуру. хорошо, хорошо, это api-интерфейс android для клавиатуры. но! вы должны иметь <code>context</code> для того, чтобы получить доступ к imm. теперь у нас есть проблема. возможно, я захочу спрятать клавиатуру от статического или служебного класса, который бесполезен или не нужен для каких-либо <code>context</code>. или и, что еще хуже, imm требует, чтобы вы указали, какую <code>view</code> (или, что еще хуже, какую <code>window</code>) вы хотите скрыть от клавиатуры.</p><p>это то, что делает скрытие клавиатуры таким сложным. уважаемый google! когда я просматриваю рецепт торта, на земле нет <code>recipeprovider</code>, который отказывался бы предоставить мне этот рецепт, если я сначала не отвечу, кто будет съеден торт и где он будет съеден !! </p><p>эта печальная история заканчивается ужасной правдой: чтобы скрыть клавиатуру android, вам потребуется предоставить 2 формы идентификации: <code>context</code> и <code>view</code> или <code>window</code>.</p><p>я создал метод статической утилиты, который может выполнять работу очень надежно, при условии, что вы вызываете его из <code>activity</code>.</p><pre><code>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); } </code></pre><p>имейте в виду, что этот служебный метод работает только при вызове из <code>activity</code>! приведенный выше метод вызывает <code>getcurrentfocus</code> целевого объекта <code>activity</code> для получения правильного токена окна. </p><p>но предположим, что вы хотите скрыть клавиатуру от <code>edittext</code>, размещенной в <code>dialogfragment</code>? вы не можете использовать метод выше для этого:</p><pre><code>hidekeyboard(getactivity()); //won't work </code></pre><p>это не сработает, потому что вы передадите ссылку на хост <code>fragment</code> <code>activity</code>, который не будет иметь сфокусированного контроля, пока отображается <code>fragment</code>! вот это да! итак, чтобы скрыть клавиатуру от фрагментов, я прибегаю к более низкому уровню, более распространенному и более уродливому:</p><pre><code>public static void hidekeyboardfrom(context context, view view) { inputmethodmanager imm = (inputmethodmanager) context.getsystemservice(activity.input\_method\_service); imm.hidesoftinputfromwindow(view.getwindowtoken(), 0); } </code></pre><p>ниже приведена дополнительная информация, полученная из-за потраченного времени в погоне за этим решением:</p><p><strong> о программе windowsoftinputmode </strong></p><p>есть еще одна точка зрения, о которой нужно знать. по умолчанию android автоматически назначит начальный фокус первому <code>edittext</code> или элементу фокусировки в <code>activity</code>. естественно, что inputmethod (обычно это программная клавиатура) будет реагировать на событие фокуса, показывая себя. атрибут <code>windowsoftinputmode</code> в <code>androidmanifest.xml</code>, когда установлено значение <code>statealwayshidden</code>, дает клавиатуре команду игнорировать этот автоматически назначенный начальный фокус. </p><pre><code><activity android:name=".myactivity" android:windowsoftinputmode="statealwayshidden"/> </code></pre><p>почти невероятно, что, кажется, ничего не делает для предотвращения открытия клавиатуры при прикосновении к элементу управления (если <code>focusable="false"</code> и/или <code>focusableintouchmode="false"</code> не назначены для элемента управления). по-видимому, параметр windowsoftinputmode применяется только к событиям автоматической фокусировки, а не к событиям фокусировки, вызванным событиями касания.</p><p>следовательно, <code>statealwayshidden</code> очень плохо назван. возможно, он должен называться <code>ignoreinitialfocus</code> вместо этого. </p><p>надеюсь это поможет.</p><hr><p><strong> обновление: больше способов получить жетон окна </strong></p><p>если нет сфокусированного представления (например, может произойти, если вы только что изменили фрагменты), есть другие представления, которые будут предоставлять полезный маркер окна.</p><p>это альтернативы для приведенного выше кода <code>if (view == null) view = new view(activity);</code> они не относятся явно к вашей деятельности.</p><p>внутри класса фрагмента:</p><pre><code>view = getview().getrootview().getwindowtoken(); </code></pre><p>дан фрагмент <code>fragment</code> в качестве параметра:</p><pre><code>view = fragment.getview().getrootview().getwindowtoken(); </code></pre><p>начиная с вашего содержания:</p><pre><code>view = findviewbyid(android.r.id.content).getrootview().getwindowtoken(); </code></pre><hr><p><strong> обновление 2: очистить фокус, чтобы не показывать клавиатуру снова, если вы открываете приложение из фона </strong></p><p>добавьте эту строку в конец метода:</p><p><code>view.clearfocus();</code></p>

<p>вы можете заставить android скрыть виртуальную клавиатуру, используя <a href="http://developer.android.com/reference/android/view/inputmethod/inputmethodmanager.html">inputmethodmanager</a> , вызывая <a href="http://developer.android.com/reference/android/view/inputmethod/inputmethodmanager.html#hidesoftinputfromwindow%28android.os.ibinder,%20int%29"><code>hidesoftinputfromwindow</code></a> , передавая токен окна, содержащего ваше сфокусированное представление.</p><pre><code>// 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); } </code></pre><p>это заставит клавиатуру быть спрятанной во всех ситуациях. в некоторых случаях вы захотите передать <code>inputmethodmanager.hide\_implicit\_only</code> в качестве второго параметра, чтобы гарантировать, что вы скрываете клавиатуру только тогда, когда пользователь явно не заставлял ее появляться (удерживая меню).</p><p><strong>примечание:</strong> если вы хотите сделать это в kotlin, используйте: <code>context?.getsystemservice(context.input\_method\_service) as inputmethodmanager</code></p><p><strong>синтаксис kotlin</strong></p><pre><code>// 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) } } </code></pre>

<p>также полезно скрыть софт-клавиатуру:</p><pre><code>getwindow().setsoftinputmode( windowmanager.layoutparams.soft\_input\_state\_always\_hidden ); </code></pre><p>это можно использовать для подавления программной клавиатуры до тех пор, пока пользователь фактически не коснется представления редактирования текста.</p>

<p>у меня есть еще одно решение, чтобы скрыть клавиатуру:</p><pre><code>inputmethodmanager imm = (inputmethodmanager) getsystemservice(activity.input\_method\_service); imm.togglesoftinput(inputmethodmanager.hide\_implicit\_only, 0); </code></pre><p>здесь передайте <code>hide\_implicit\_only</code> в позиции <code>showflag</code> и <code>0</code> в позиции <code>hiddenflag</code>. это принудительно закроет мягкую клавиатуру.</p>

<p>решение майера работает и для меня. в моем случае верхний уровень моего приложения - это tabhost, и я хочу скрыть ключевое слово при переключении вкладок - я получаю маркер окна из представления tabhost.</p><pre><code>tabhost.setontabchangedlistener(new ontabchangelistener() { public void ontabchanged(string tabid) { inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(tabhost.getapplicationwindowtoken(), 0); } } </code></pre>

<p>пожалуйста, попробуйте этот код ниже в <code>oncreate()</code></p><pre><code>edittext edtview=(edittext)findviewbyid(r.id.edittextconvertvalue); edtview.setinputtype(0); </code></pre>

<p><strong>update:</strong> я не знаю, почему это решение больше не работает (я только что протестировал на android 23). пожалуйста, используйте решение <a href="https://stackoverflow.com/a/9494042/523325">saurabh pareek</a> вместо. вот:</p><pre><code>inputmethodmanager imm = (inputmethodmanager) getsystemservice(activity.input\_method\_service); //hide: imm.togglesoftinput(inputmethodmanager.hide\_implicit\_only, 0); //show imm.togglesoftinput(inputmethodmanager.show\_implicit, 0); </code></pre><p>старый ответ:</p><pre><code>//show soft-keyboard: getwindow().setsoftinputmode(windowmanager.layoutparams.soft\_input\_state\_always\_visible); //hide keyboard : getwindow().setsoftinputmode(windowmanager.layoutparams.soft\_input\_state\_always\_hidden); </code></pre>

<pre><code>protected void hidesoftkeyboard(edittext input) { inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(input.getwindowtoken(), 0); } </code></pre>

<p>если все остальные ответы здесь не работают так, как вы хотели бы, есть другой способ ручного управления клавиатурой.</p><p>создайте функцию, которая будет управлять некоторыми свойствами <code>edittext</code>:</p><pre><code>public void setedittextfocus(boolean isfocused) { searchedittext.setcursorvisible(isfocused); searchedittext.setfocusable(isfocused); searchedittext.setfocusableintouchmode(isfocused); if (isfocused) { searchedittext.requestfocus(); } } </code></pre><p>затем убедитесь, что на focus <code>edittext</code> вы открываете/закрываете клавиатуру:</p><pre><code>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); } } } }); </code></pre><p>теперь, когда вы хотите открыть клавиатуру вручную, позвоните: </p><pre><code>setedittextfocus(true); </code></pre><p>и для закрытия звонка:</p><pre><code>setedittextfocus(false); </code></pre>

<p> <a href="https://stackoverflow.com/a/9494042/197359">saurabh pareek</a> пока лучший ответ.</p><p>можно использовать и правильные флаги.</p><pre><code>/* 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); </code></pre><p>пример реального использования</p><pre><code>/* 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 ... */ } </code></pre>

<p>от такого поиска, здесь я нашел ответ, который работает для меня</p><pre><code>// 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); </code></pre>

<h2>краткий ответ</h2><p>в вашем слушателе <code>onclick</code> вызовите <code>oneditoraction</code> <code>edittext</code> с <code>ime\_action\_done</code></p><pre><code>button.setonclicklistener(new onclicklistener() { @override public void onclick(view v) { someedittext.oneditoraction(editorinfo.ime\_action\_done) } }); </code></pre><h2>развертка</h2><p>я чувствую, что этот метод лучше, проще и более согласован с шаблоном дизайна android . в простом примере выше (и, как правило, в большинстве общих случаев) у вас будет <code>edittext</code>, который имеет/имел фокус, и он также обычно был тот, который в первую очередь вызывает клавиатуру (он определенно способен вызывать ее во многих распространенных сценариях). таким же образом <strong>it</strong> должен быть тем, кто отпускает клавиатуру, обычно это может быть сделано <code>imeaction</code>. просто посмотрите, как <code>edittext</code> с <code>android:imeoptions="actiondone"</code> ведет себя, вы хотите добиться того же поведения тем же способом.</p><hr><p>проверить это <a href="https://stackoverflow.com/a/3449616/2837443">связанный ответ</a> </p>

<p>это должно работать:</p><pre><code>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); </code></pre>

<p>я использую пользовательскую клавиатуру для ввода шестнадцатеричного числа, поэтому я не могу показать клавиатуру imm ...</p><p>в v3.2.4\_r1 <code>setsoftinputshownonfocus(boolean show)</code> был добавлен, чтобы управлять погодой или не отображать клавиатуру, когда textview получает фокус, но он все еще скрыт, поэтому необходимо использовать отражение:</p><pre><code>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 } } </code></pre><hr><p>для более старых версий я получил очень хорошие результаты (но далеко не идеальные) с <code>ongloballayoutlistener</code>, добавленным с помощью <code>viewtreeobserver</code> из моего корневого представления, а затем проверил, отображается ли клавиатура следующим образом:</p><pre><code>@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); } } </code></pre><p>это последнее решение может показывать клавиатуру в течение доли секунды и портить ручки выбора.</p><p>когда в клавиатуре вводится полный экран, ongloballayout не вызывается. чтобы избежать этого, используйте <a href="https://developer.android.com/reference/android/widget/textview.html#setimeoptions%28int%29">textview # setimeoptions (int)</a> или в объявлении textview xml:</p><pre><code>android:imeoptions="actionnone|actionunspecified|flagnofullscreen|flagnoextractui" </code></pre><p><strong>update:</strong> только что нашел, какие диалоги используются, чтобы никогда не показывать клавиатуру и работает во всех версиях:</p><pre><code>getwindow().setflags(windowmanager.layoutparams.flag\_alt\_focusable\_im, windowmanager.layoutparams.flag\_alt\_focusable\_im); </code></pre>

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

<p>я потратил более двух дней, работая над всеми решениями, опубликованными в ветке, и обнаружил, что их так или иначе не хватает. мое точное требование - иметь кнопку, которая со 100% надежностью отображает или скрывает экранную клавиатуру. когда клавиатура находится в скрытом состоянии, она не должна появляться вновь, независимо от того, какие поля ввода пользователь нажимает. когда он находится в своем видимом состоянии, клавиатура не должна исчезать независимо от того, на какие кнопки нажимает пользователь. это должно работать на android 2.2+ вплоть до самых последних устройств.</p><p>вы можете увидеть работающую реализацию этого в моем приложении <a href="https://play.google.com/store/apps/details?id=au.com.lukesleeman.rpn&hl=en">clean rpn</a> .</p><p>после тестирования многих из предложенных ответов на нескольких различных телефонах (включая устройства froyo и gingerbread) стало очевидно, что приложения android могут надежно:</p><ol> <li>временно скрыть клавиатуру. он появится снова, когда пользователь выделит новое текстовое поле.</li> <li>покажите клавиатуру при запуске действия и установите флаг на активность, указывающую, что клавиатура должна всегда быть видимой. этот флаг может быть установлен только тогда, когда действие инициализируется </li> <li>отметьте активность, чтобы никогда не показывать или не разрешать использование клавиатуры этот флаг может быть установлен только тогда, когда действие инициализируется </li> </ol><p>для меня временно скрыть клавиатуру недостаточно. на некоторых устройствах оно появится снова, как только появится новое текстовое поле. поскольку мое приложение использует несколько текстовых полей на одной странице, при фокусировке на новом текстовом поле скрытая клавиатура снова выскочит.</p><p>к сожалению, пункты 2 и 3 в списке работают только надёжно, когда работа начинается. после того, как действие стало видимым, вы не сможете надолго скрыть или показать клавиатуру хитрость заключается в том, чтобы фактически возобновить свою деятельность, когда пользователь нажимает кнопку переключения клавиатуры. в моем приложении, когда пользователь нажимает кнопку переключения клавиатуры, запускается следующий код:</p><pre><code>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); } } </code></pre><p>это приводит к тому, что текущее действие сохраняет свое состояние в bundle, а затем действие запускается, проходя через логическое значение, которое указывает, должна ли клавиатура отображаться или скрываться.</p><p>внутри метода oncreate выполняется следующий код:</p><pre><code>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); } </code></pre><p>если должна отображаться программная клавиатура, то inputmethodmanager должен показать клавиатуру, а в окне указывается, чтобы программный ввод был всегда видимым. если программная клавиатура должна быть скрыта, то устанавливается windowmanager.layoutparams.flag\_alt\_focusable\_im.</p><p>этот подход надежно работает на всех устройствах, на которых я тестировал - от 4-летнего телефона htc с android 2.2 до nexus 7 с 4.2.2. единственный недостаток этого подхода - вы должны быть осторожны при обращении с кнопкой «назад». поскольку мое приложение по существу имеет только один экран (это калькулятор), я могу переопределить onbackpressed () и вернуться на домашний экран устройства.</p>

<p>в качестве альтернативы <a href="https://stackoverflow.com/a/9494042/451962">это универсальное решение</a> , если вы хотите закрыть программную клавиатуру <strong>из любого места</strong>, не имея ссылки на поле (edittext), которое использовалось для открытия клавиатуры, но все же захотите сделать это, если поле было сфокусировано, вы можете использовать это (из activity):</p><pre><code>if (getcurrentfocus() != null) { inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(getcurrentfocus().getwindowtoken(), 0); } </code></pre>

<p>благодаря <a href="https://stackoverflow.com/a/7696791/1617737">этому so ответу</a> я получил следующее, что, в моем случае, прекрасно работает при прокрутке фрагментов viewpager ...</p><pre><code>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); } } </code></pre>

<p>приведенные выше ответы работают для разных сценариев, но<strong> если вы хотите спрятать клавиатуру в представлении и изо всех сил пытаетесь получить правильный контекст, попробуйте это: </strong></p><pre><code>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); } } </code></pre><p>и чтобы получить контекст, извлеките его из конструктора :) </p><pre><code>public view/relativelayout/so and so (context context, attributeset attrs, int defstyle) { super(context, attrs, defstyle); this.context = context; init(); } </code></pre>

<p>если вы хотите закрыть программную клавиатуру во время модульного или функционального теста, вы можете сделать это, нажав кнопку «назад» в вашем тесте:</p><pre><code>// close the soft keyboard from a test getinstrumentation().sendkeydownupsync(keyevent.keycode\_back); </code></pre><p>я поставил «кнопку назад» в кавычки, так как выше не вызывает <code>onbackpressed()</code> для рассматриваемой активности. он просто закрывает клавиатуру.</p><p>обязательно сделайте небольшую паузу, прежде чем двигаться дальше, поскольку для закрытия кнопки «назад» требуется некоторое время, поэтому последующие нажатия на «виды» и т.д. не будут регистрироваться до тех пор, пока не произойдет короткая пауза (1 секунда достаточно длинная ).</p>

<p>вот как вы делаете это в mono для android (aka monodroid)</p><pre><code>inputmethodmanager imm = getsystemservice (context.inputmethodservice) as inputmethodmanager; if (imm != null) imm.hidesoftinputfromwindow (searchbox.windowtoken , 0); </code></pre>

<p>добавьте к своей деятельности <code>android:windowsoftinputmode="statehidden"</code> в файле манифеста. пример:</p><pre><code><activity android:name=".ui.activity.mainactivity" android:label="@string/mainactivity" android:windowsoftinputmode="statehidden"/> </code></pre>

<p>это сработало для меня из-за странного поведения клавиатуры</p><pre><code>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); } } </code></pre>

<p>для моего случая я использовал searchview в панели действий. после того, как пользователь выполнит поиск, клавиатура снова откроется.</p><p>использование inputmethodmanager не закрывало клавиатуру. мне пришлось очистить focus и установить фокусировку в поиске на false:</p><pre><code>msearchview.clearfocus(); msearchview.setfocusable(false); </code></pre>

<p>я почти перепробовал все эти ответы, у меня были некоторые случайные проблемы, особенно с samsung galaxy s5.</p><p>в итоге я заставляю себя показывать и прятаться, и это прекрасно работает:</p><pre><code>/** * 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); } </code></pre>

<p>в некоторых случаях этот метод может работать, кроме всех других. это спасает мой день :)</p><pre><code>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); } } } </code></pre>

<p>простой и легкий в использовании метод, просто вызовите<strong> hidekeyboardfrom (youractivity.this); </strong>чтобы скрыть клавиатуру</p><pre><code>/** * 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); } </code></pre>

<p>использовать этот</p><pre><code>this.getwindow().setsoftinputmode( windowmanager.layoutparams.soft\_input\_state\_always\_hidden); </code></pre>

<p>у меня есть случай, когда моя <code>edittext</code> может быть расположена также в <code>alertdialog</code>, поэтому клавиатура должна быть закрыта при отклонении. следующий код, кажется, работает где угодно:</p><pre><code>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 ); } </code></pre>

<pre><code>public static void hidesoftkeyboard(activity activity) { inputmethodmanager inputmethodmanager = (inputmethodmanager) activity.getsystemservice(activity.input\_method\_service); inputmethodmanager.hidesoftinputfromwindow(activity.getcurrentfocus().getwindowtoken(), 0); } </code></pre><p>после этого вызовите ontouchlistener:</p><pre><code>findviewbyid(android.r.id.content).setontouchlistener(new ontouchlistener() { @override public boolean ontouch(view v, motionevent event) { utils.hidesoftkeyboard(activity); return false; } }); </code></pre>

<p>просто используйте этот оптимизированный код в своей деятельности:</p><pre><code>if (this.getcurrentfocus() != null) { inputmethodmanager inputmanager = (inputmethodmanager) this.getsystemservice(context.input\_method\_service); inputmanager.hidesoftinputfromwindow(this.getcurrentfocus().getwindowtoken(), inputmethodmanager.hide\_not\_always); } </code></pre>

<p>работает как волшебное прикосновение каждый раз</p><pre><code>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); } } </code></pre>

<p>для открытой клавиатуры:</p><pre><code>inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.showsoftinput(edtview, inputmethodmanager.show\_implicit); </code></pre><p>для закрытия/скрытия клавиатуры:</p><pre><code> inputmethodmanager imm = (inputmethodmanager)getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(edtview.getwindowtoken(), 0); </code></pre>

<p>вы также можете изучить использование <a href="http://developer.android.com/reference/android/widget/textview.html#attr\_android:imeoptions">setimeoption</a> в edittext.</p><p>у меня просто была очень симулированная ситуация, когда мой макет содержал edittext и кнопку поиска. когда я обнаружил, что могу просто установить опцию ime на «actionsearch» в своем edittext, я понял, что мне больше не нужна кнопка поиска. программная клавиатура (в этом режиме) имеет значок поиска, с помощью которого можно начать поиск (и клавиатура закрывается, как и следовало ожидать). </p>

<p>иногда все, что вам нужно, это кнопка ввода, чтобы сложить <code>keyboard</code> дать поле <code>edittext</code>, у которого есть атрибут </p><pre><code> android:imeoptions="actiondone" </code></pre><p>это изменит кнопку enter на кнопку done, которая закроет клавиатуру.</p>

<p>меня устраивает..</p><pre><code>edittext edittext=(edittext)findviewbyid(r.id.edittext1); </code></pre><p>поместите ниже строки кода в onclick ()</p><pre><code>edittext.setfocusable(false); edittext.setfocusableintouchmode(true); </code></pre><p>здесь скрыть клавиатуру, когда мы нажимаем кнопку и когда мы касаемся клавиатуры edittext будет отображаться.</p><p><strong> (или же) </strong></p><pre><code>getwindow().setsoftinputmode(windowmanager.layoutparams.soft\_input\_state\_always\_hidden); </code></pre>

<p>иногда у вас может быть действие, которое содержит просмотр списка со строками, которые содержат edittext, поэтому вы должны настроить манифест <code>soft\_input\_adjust\_pan</code>, после чего появится клавиатура, что раздражает.</p><p>следующий обходной путь работает, если вы поместите его в конец <code>oncreate</code></p><pre><code>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); </code></pre>

<h1>попробуй это</h1><ul> <li>просто вы можете позвонить в свой <code>activity</code> </li> </ul><hr><pre><code> public static void hidekeyboardwithoutpopulate(activity activity) { inputmethodmanager inputmethodmanager = (inputmethodmanager) activity.getsystemservice( activity.input\_method\_service); inputmethodmanager.hidesoftinputfromwindow( activity.getcurrentfocus().getwindowtoken(), 0); } </code></pre><hr><ul> <li>в вашем <code>mainactivitiy</code> позвоните </li> </ul><hr><pre><code> hidekeyboardwithoutpopulate(mainactivity.this); </code></pre><hr>

<p>в <code>androidmanifest.xml</code> под <code><activity..></code> установите <code>android:windowsoftinputmode="statealwayshidden"</code></p>

<p>если вы хотите скрыть клавиатуру, используя код java, используйте это:</p><pre><code> inputmethodmanager imm = (inputmethodmanager)this.getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(femail.getwindowtoken(), 0); </code></pre><p>или, если вы хотите всегда скрывать клавиатуру, используйте это в androidmanifest:</p><pre><code> <activity android:name=".activities.myactivity" android:configchanges="keyboardhidden" /> </code></pre>

<p>я написал небольшое расширение для kotlin, если кто-то заинтересовался, не очень проверял это:</p><pre><code>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) } } </code></pre><p>app.instance является статическим объектом «this», хранящимся в приложении</p><p>обновление: в некоторых случаях windowtoken имеет значение null. я добавил дополнительный способ закрытия клавиатуры с помощью отражения, чтобы определить, закрыта ли клавиатура</p><pre><code>/** * 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 </code></pre>

<pre><code>public static void hidesoftkeyboard(activity activity) { inputmethodmanager inputmethodmanager = (inputmethodmanager)activity.getsystemservice(activity.input\_method\_service); inputmethodmanager.hidesoftinputfromwindow(activity.getcurrentfocus().getwindowtoken(), 0); } </code></pre>

<p>это работает ..</p><p>просто передайте текущий экземпляр активности в функцию </p><pre><code> 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 } } </code></pre>

<p>на самом деле, авторитет android всегда дает новые обновления, но они не устраняют свои старые недостатки, с которыми сталкиваются все разработчики android в своей разработке. это должно быть обработано авторитетом android по умолчанию, при изменении фокуса с edittext следует скрыть/показать параметр клавиатуры мягкого ввода. но извините, они не справляются. хорошо оставь это.</p><p>ниже приведены решения для отображения/скрытия/переключения параметра клавиатуры в разделе «деятельность» или «фрагмент».</p><p><strong> показать клавиатуру для просмотра: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> показать клавиатуру с контекстом действия: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> показать клавиатуру с контекстом фрагмента: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> скрыть клавиатуру для просмотра: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> скрыть клавиатуру в контексте действия: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> скрыть клавиатуру с контекстом фрагмента: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> переключить клавиатуру: </strong></p><pre><code>/** * 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(); } } </code></pre>

<p>просто код: используйте этот код в<strong> oncreate () </strong></p><pre><code>getwindow().setsoftinputmode( windowmanager.layoutparams.soft\_input\_state\_always\_hidden ); </code></pre>

<p>здесь есть оба метода скрытия и показа.</p><h2>котлин</h2><pre><code>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) } </code></pre><h2>джава</h2><pre><code>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); } </code></pre>

<p>если вы используете kotlin для разработки своего приложения, это действительно легко сделать.</p><p>добавьте это расширение функций:</p><p>для деятельности:</p><pre><code>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) } } </code></pre><p>для фрагмента:</p><pre><code>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) } } } </code></pre><p>теперь вы можете просто позвонить в своем фрагменте или деятельности:</p><pre><code> hidekeyboard() </code></pre>

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

<p>попробуй это</p><pre><code>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); } } </code></pre>

<p><strong> очень простой способ </strong></p><p>я делаю это во всех своих проектах и работаю как во сне. в ваших объявлениях <code>layout.xml</code> просто добавьте одну строку:</p><pre><code>android:focusableintouchmode="true" </code></pre><p>пример полного кода:</p><pre><code><?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> </code></pre>

<p>вот лучшие решения</p><p>решение 1) установите для inputtype значение «text»</p><pre><code><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" /> </code></pre><p>это также может быть сделано программно через. метод setinputtype () (унаследованный от textview). </p><pre><code>edittext edittext = (edittext) findviewbyid(r.id.my\_edit\_text); edittext.setrawinputtype(inputtype.type\_class\_text | inputtype.type\_text\_variation\_normal); </code></pre><p>решение 2) используйте inputmethodmanager.hidesoftinputfromwindow ()</p><pre><code>inputmethodmanager imm = (inputmethodmanager)getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(myedittext.getwindowtoken(), 0); </code></pre><p>или же</p><pre><code>inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(myedittext.getwindowtoken(), inputmethodmanager.hide\_not\_always); </code></pre>

<p>простой метод, ребята: попробуйте это ...</p><pre><code>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); } } </code></pre>

<pre><code>public static void hidesoftkeyboard(activity activity) { inputmethodmanager inputmethodmanager = (inputmethodmanager) activity .getsystemservice(activity.input\_method\_service); inputmethodmanager.hidesoftinputfromwindow(activity.getcurrentfocus() .getwindowtoken(), 0); } </code></pre>

<p><strong> когда вы хотите скрыть клавиатуру вручную по нажатию кнопки: </strong></p><pre><code>/** * 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(); } } </code></pre><p><strong> если вы хотите скрыть клавиатуру, где бы вы ни щелкали на экране, кроме текста редактирования </strong> переопределите этот метод в своей деятельности:</p><pre><code>@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); } </code></pre>

<p>в android, чтобы скрыть vkeyboard с помощью inputmethodmanage, вы можете вызвать hidesoftinputfromwindow, передав токен окна, содержащего ваше сфокусированное представление.</p><pre><code>view view = this.getcurrentfocus(); if (view != null) { inputmethodmanager im = (inputmethodmanager)getsystemservice(context.input\_method\_service); im.hidesoftinputfromwindow(view.getwindowtoken(), 0); } </code></pre><p>вызов edittext.clearfocus () и затем inputmethodmanager.hide\_implicit\_only даже работает </p>

<p>вы можете просто добавить этот код, где вы хотите, чтобы скрыть программную клавиатуру "</p><pre><code> // 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); } </code></pre>

<p>в котлине</p><pre><code>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) } </code></pre>

<p>я создал макет частично из xml и частично из пользовательского механизма компоновки, который обрабатывается в коде. единственная вещь, которая работала для меня, состояла в том, чтобы отслеживать, была ли клавиатура открыта, и использовать метод переключения клавиатуры следующим образом:</p><pre><code>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); } } </code></pre>

<p>этот метод всегда будет работать любой ценой. просто используйте его там, где вы хотите, чтобы скрыть клавиатуру</p><pre><code>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); } } </code></pre><p>используйте это так:</p><p>какой бы ни была версия android. этот метод обязательно сработает</p>

<p>это сработало для меня.</p><pre><code>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); } </code></pre>

<p>все отчаянно опробовал все здесь, комбинируя все методы, и, конечно, клавиатура не закрывается в android 4.0.3 (она работала в honeicomb afair).</p><p>затем я неожиданно обнаружил выигрышную комбинацию:</p><pre><code>textfield.setrawinputtype(inputtype.type\_class\_text |inputtype.type\_text\_variation\_normal); </code></pre><p>в сочетании с вашими обычными рецептами</p><pre><code>blahblaj.hidesoftinputfromwindow ... </code></pre><p>надеюсь, что это останавливает кого-то от самоубийства .. я был близок к этому. конечно, я понятия не имею, почему это работает.</p>

<p>альтернативой использования <code>searchview</code> будет использование этого кода:</p><pre><code>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); } } </code></pre><p>это окно поиска searchview в панели действий, которое при отправке текста из запроса (пользователь нажимает клавишу <code>enter</code> или кнопку/значок поиска), затем активируется код <code>inputmethodmanager</code> и приводит к падению вашей программной клавиатуры. этот код был помещен в мою <code>oncreateoptionsmenu()</code>. <code>searchitem</code> из <code>menuitem</code>, который является частью кода по умолчанию для <code>oncreateoptionsmenu()</code>. спасибо @mckoss за хороший кусок этого кода!</p>

<p>вы можете создать<strong> расширение </strong>функцию для любого просмотра</p><pre><code>fun view.hidekeyboard() = this.let { val imm = context.getsystemservice(context.input\_method\_service) as inputmethodmanager imm.hidesoftinputfromwindow(windowtoken, 0) } </code></pre><p><strong> пример использования с activity </strong></p><pre><code>window.decorview.hidekeyboard(); </code></pre><p><strong> пример использования с view </strong></p><pre><code>etusername.hidekeyboard(); </code></pre><p>удачного кодирования ...</p>

<p>вызовите этот метод, чтобы скрыть программную клавиатуру</p><pre><code>public void hidekeyboard() { view view1 = this.getcurrentfocus(); if(view!= null){ inputmethodmanager imm = (inputmethodmanager) getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(view1.getwindowtoken(), 0); } } </code></pre>

<pre><code>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); } </code></pre><p>этот метод обычно работает, но есть одно условие: вы не можете установить <code>android:windowsoftinputmode="any\_of\_these"</code></p>

<p>несмотря на все эти ответы, просто чтобы быть достаточно простым, я написал общий метод для этого:</p><pre><code>/** * 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); } } </code></pre>

<p>приведенный ниже код поможет вам сделать универсальную функцию, которую можно вызывать из любого места. </p><pre><code>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) } } } </code></pre><p>вызовите метод above из любого места, используя одну строку кода.</p><pre><code>customsnackbar.hidekeyboard(view, this@activityname) </code></pre><p>представлением может быть что угодно, например, корневой макет действия.</p>

<p>привет это просто, если вы работаете с kotlin, я верю, что вы можете легко преобразовать код в java тоже сначала в своей деятельности, используйте эту функцию, когда ваша деятельность загружается, например, в вызове oncreate ().</p><pre><code>fun hidekeybord (){ val inputmanager = getsystemservice(context.input\_method\_service) as inputmethodmanager if (inputmanager.isacceptingtext){ inputmanager.hidesoftinputfromwindow(currentfocus.windowtoken, 0) } </code></pre><p>}</p><p>как я уже упоминал, вызовите эту функцию в методе oncreate (), а затем добавьте эту строку <code>android:windowsoftinputmode="statealwayshidden"</code> к своей активности в файле manafest.xml. вот так ... </p><pre><code><activity android:name=".activity.mainactivity" android:label="@string/app\_name" android:theme="@style/apptheme.noactionbar" android:windowsoftinputmode="statealwayshidden"> </code></pre>

<p>для пользователей kotlin здесь есть метод расширения kotlin, который работал для моих случаев использования:</p><pre class="lang-java prettyprint-override"><code>fun view.hidekeyboard() { val imm = this.context.getsystemservice(activity.input\_method\_service) as inputmethodmanager imm.hidesoftinputfromwindow(windowtoken, 0) } </code></pre><p>поместите его в файл с именем viewextensions (или что у вас есть) и вызовите его для ваших представлений, как обычный метод.</p>

<p>если ваше приложение нацелено на<strong> api level 21 или более </strong>, то есть метод по умолчанию:</p><pre><code>edittextobj.setshowsoftinputonfocus(false); </code></pre><p>убедитесь, что вы установили код ниже в xml-теге <code>edittext</code>.</p><pre><code><edittext .... android:enabled="true" android:focusable="true" /> </code></pre>

<p>этот фрагмент кода может помочь:</p><pre><code> final inputmethodmanager inputmethodmanager = (inputmethodmanager) getsystemservice(activity.input\_method\_service); if (inputmethodmanager != null && inputmethodmanager.isactive()) { if (getcurrentfocus() != null) { inputmethodmanager.hidesoftinputfromwindow(getcurrentfocus().getwindowtoken(), 0); } } </code></pre><p>его можно вызывать в различных методах в зависимости от необходимости (например, onpause, onresume, onrestart ...)</p>

<p>я использую следующие расширения активности kotlin:</p><pre><code>/** * 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) } } </code></pre>

<p>чтобы показать клавиатуру при запуске приложения:</p><pre><code> 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); </code></pre>

<p>котлин версия </p><pre><code>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); </code></pre>

<p>окружите его попыткой catch, чтобы клавиатура уже была закрыта, приложение не зависало: </p><pre><code>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(); } </code></pre>

<p>я очень много перепробовал все решения, но у меня не получилось, поэтому я нашел свое решение: у вас должны быть логические переменные, такие как:</p><pre><code>public static iskeyboardshowing = false; inputmethodmanager inputmethodmanager = (inputmethodmanager) getactivity() .getsystemservice(context.input\_method\_service); </code></pre><p>и в случае сенсорного экрана вы звоните:</p><pre><code>@override public boolean ontouchevent(motionevent event) { if(keyboardshowing==true){ inputmethodmanager.togglesoftinput(inputmethodmanager.result\_unchanged\_hidden, 0); keyboardshowing = false; } return super.ontouchevent(event); } </code></pre><p>и в edittext есть в любом месте:</p><pre><code>youredittext.setonclicklistener(new onclicklistener() { @override public void onclick(view v) { yourclass.keyboardshowing = true; } }); </code></pre>

<p>для xamarin. android:</p><pre><code>public void hidekeyboard() { var imm = activity.getsystemservice(context.inputmethodservice).javacast<inputmethodmanager>(); var view = activity.currentfocus ?? new view(activity); imm.hidesoftinputfromwindow(view.windowtoken, hidesoftinputflags.none); } </code></pre>

<p>вам нужно всего лишь написать одну строку внутри вашего тега активности манифеста</p><pre><code> android:windowsoftinputmode="statealwayshidden|adjustpan" </code></pre><p>и это будет работать.</p>

<pre><code> fun hidekeyboard(appcompatactivity: appcompatactivity) { val view = appcompatactivity.currentfocus val imm = appcompatactivity.getsystemservice(context.input\_method\_service) as inputmethodmanager imm.hidesoftinputfromwindow(view.windowtoken, 0) } </code></pre>

<p>просто сделать общий метод для всего приложения в baseactivity и basefragment</p><p>в <code>oncreate()</code> инициализировать <code>inputmethodmanager</code></p><pre><code>inputmethodmanager = (inputmethodmanager) getsystemservice(context.input\_method\_service); </code></pre><p>сделать эти методы, чтобы скрыть и показать клавиатуру</p><pre><code>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); } </code></pre>

<pre><code>use text watcher instead of edittext.and after you finished entering the input </code></pre><p>ты можешь использовать </p><pre><code>inputmethodmanager imm = (inputmethodmanager)getsystemservice(context.input\_method\_service); imm.hidesoftinputfromwindow(view.getwindowtoken(), 0); </code></pre>

<pre><code>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); } </code></pre><p>это будет работать .... @ ask</p>

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

<p>некоторый код котлина: </p><p>скрыть клавиатуру из активности:</p><pre><code>(currentfocus ?: view(this)) .apply { (getsystemservice(activity.input\_method\_service) as inputmethodmanager) .hidesoftinputfromwindow(windowtoken, 0) } </code></pre>

<p><strong>вики ответ на kotlin:</strong></p><p>1 - создайте <a href="https://blog.jetbrains.com/kotlin/2015/06/improving-java-interop-top-level-functions-and-properties/">функцию верхнего уровня</a> внутри файла (например, файла, который содержит все ваши функции верхнего уровня):</p><pre><code>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) } </code></pre><p>2 - затем назовите это в любой деятельности, в которой это было необходимо:</p><pre><code>this.hidekeyboard() </code></pre>

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

<pre><code>private void hidesoftkeyboard() { view view = getview(); if (view != null) { inputmethodmanager inputmethodmanager = (inputmethodmanager) getactivity() .getsystemservice(activity.input\_method\_service); inputmethodmanager.hidesoftinputfromwindow(view.getwindowtoken(), 0); } } </code></pre>

<p>прочитав все ответы выше и в другом посте, мне все равно не удалось автоматически открыть клавиатуру.</p><p>в моем проекте я создал диалог (<code>alertdialog</code>) динамически (программируя его без или с минимумом необходимого xml).</p><p>итак, я делал что-то вроде:</p><pre><code> dialogbuilder = new alertdialog.builder(activity); if(dialogbuilder==null) return false; //error inflater = activity.getlayoutinflater(); dialogview = inflater.inflate(layout, null); ... </code></pre><p>и после завершения настройки всех представлений (textview, imageview, edittext и т.д.) я сделал:</p><pre><code> alertdialog = dialogbuilder.create(); alertdialog.show(); </code></pre><p>поэкспериментировав со всеми ответами, я обнаружил, что большинство из них работают <strong><em>if</em></strong> вы знаете <strong><em>где</em></strong>, чтобы поставить запрос ... и это был ключ ко всем.</p><p>итак, хитрость заключается в том, чтобы поставить <strong>before</strong> при создании диалога: <code>alertdialog.show()</code> в моем случае это сработало как charm:</p><pre><code> 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..) </code></pre><p>я совершенно уверен, что этот принцип одинаков для всех окон, поэтому обратите внимание на расположение вашего кода "showkeyboard" - это должно быть до запуска окна.</p><p>небольшой запрос от команды разработчиков android sdk:</p><p>я думаю, что все это не нужно, поскольку тысячи программистов со всего мира имеют дело с этой нелепой и тривиальной проблемой, а ее решение должно быть простым и понятным: имхо, если я получу <code>requestfocus()</code> для ориентированной на ввод view (например, <code>edittext</code>), клавиатура должна открываться автоматически, если пользователь не запрашивает not-to, поэтому я думаю, что здесь используется метод requestfocus (), и он должен принимать логическое значение showsoftkeyboard со значением по умолчанию <code>true</code>: <code>view.requestfocus(boolean showsoftkeyboard);</code></p><p>надеюсь, что это поможет другим, как я.</p>

<p>попробуйте это в котлине</p><pre><code> private fun hidekeyboard(){ val imm = activity!!.getsystemservice(input\_method\_service) as inputmethodmanager imm.hidesoftinputfromwindow(activity!!.currentfocus!!.windowtoken, 0) } </code></pre><p>попробуйте это на java</p><pre><code> private void hidekeyboard(){ inputmethodmanager imm =(inputmethodmanager)getsystemservice(input\_method\_service); imm.hidesoftinputfromwindow(getcurrentfocus().getwindowtoken(), 0); } </code></pre>