Android: показывать программную клавиатуру автоматически, когда фокус находится на EditText


341

Я показываю поле ввода, используя AlertDialog. EditTextВнутри диалога сама автоматически фокусируется , когда я звоню AlertDialog.show(), но мягкая клавиатура не отображается автоматически.

Как сделать так, чтобы программная клавиатура автоматически отображалась при отображении диалогового окна? (и нет физической / аппаратной клавиатуры). Аналогично тому, как когда я нажимаю кнопку «Поиск», чтобы вызвать глобальный поиск, автоматически отображается программная клавиатура.


1
Это должно произойти автоматически, согласно комментарию Теда ниже. Проверьте это первым!
Cheezmeister

Этот ответ наиболее прост и прекрасно работает: stackoverflow.com/a/8018630/89818
caw


1
Я возвращался к этому ответу несколько раз за эти годы. У меня всегда есть эта проблема, а не внутри Фрагмента или Действия.
tir38

Возможный дубликат
Md Imran Choudhury

Ответы:


305

Вы можете создать фокус слушателя на EditTextна AlertDialog, затем получить AlertDialog«S Window. Оттуда вы можете сделать показ мягкой клавиатуры, позвонив setSoftInputMode.

final AlertDialog dialog = ...;

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

5
Как бы я сделал это с помощью AlertDialog.Builder? ... final AlertDialog.Builder alert = new AlertDialog.Builder (Main.this);
Стивен

6
@ Стефан, вы можете получить диалог от компоновщика, используя, final AlertDialog dialog = builder.create()а затем showв диалоге вместо компоновщика.
Tidbeck

30
Я забрал свой комментарий выше. Я обнаружил, что если вы не можете правильно сфокусироваться, взгляните на свой XML! Если вы видите тег <requestFocus> </ requestFocus> там - удалите его. Кажется, что тег даст фокус на EditText, и тогда ваш слушатель не будет запущен, так как EditText уже имеет фокус.
Тед

11
Как вы этого не сделаете, если устройство имеет аппаратную клавиатуру? Похоже, это раздражает этих пользователей.
mxcl

8
Я действительно не понимаю, почему это не стандартное поведение в SDK. Если представление, для которого требуется ввод текста, показывает мигающий курсор, почему кто-то не хочет видеть клавиатуру для ввода текста? Мне так плохо с UX
Кристиан Гарсия

240

Для отображения клавиатуры используйте:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Для скрытия клавиатуры используйте:

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

3
Это особенно хорошо работает, когда вы хотите показать / скрыть программную клавиатуру, основываясь на переключении видимости представления в макете между VISIBLE и GONE.
PacificSky

38
Вместо этого я бы предложил использовать флаг SHOW_IMPLICIT, поскольку это означает, что изменение активности или приложения автоматически скроет клавиатуру, как и ожидалось.
drspaceboo

6
@drspaceboo Использование SHOW_IMPLICIT вообще не работает для меня, я должен использовать SHOW_FORCED, не знаю почему ...
Йоанн Херкуэ

1
Когда следует запустить приведенный выше код? Я попытался сделать это вскоре после добавления моего макета к его родителю. Это не сработало. Но если я сделал это после того, как макет был некоторое время, это сработало. Так есть ли обратный вызов, который скажет мне: «Если вы попытаетесь показать клавиатуру сейчас, она на самом деле будет работать»?
Уильям Джокуш

1
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) включает программную клавиатуру. Если вы хотите убедиться, что клавиатура появляется, вы можете вместо этого использовать imm.showSoftInput (view, InputMethodManager.SHOW_IMPLICIT), где view - это представление, которое получит ввод.
PJ_Finnegan

111

Вы можете запросить программную клавиатуру сразу после создания диалога (тест на SDK - r20)

// create dialog
final AlertDialog dialog = ...; 

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Для всех, кто интересуется, этот метод не открывает программную клавиатуру, когда подключена аппаратная клавиатура. Я только что проверил с USB-кабель On-The-Go. Отлично!
13rac1

Это ничего не делает для меня.
JohnyTex

У меня нет аппаратной клавиатуры. Может быть, конфигурация (?)
JohnyTex

25

У меня была та же проблема, и я решил ее с помощью следующего кода. Я не уверен, как он будет вести себя на телефоне с аппаратной клавиатурой.

// TextEdit
final EditText textEdit = new EditText(this);

// Builder
AlertDialog.Builder alert = new AlertDialog.Builder(this);
alert.setTitle("Enter text");
alert.setView(textEdit);

alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        String text = textEdit.getText().toString();
        finish();
    }
});

alert.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
    @Override
    public void onClick(DialogInterface dialog, int which) {
        finish();
    }
});

// Dialog
AlertDialog dialog = alert.create();
dialog.setOnShowListener(new OnShowListener() {

    @Override
    public void onShow(DialogInterface dialog) {
        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(textEdit, InputMethodManager.SHOW_IMPLICIT);
    }
});

dialog.show();

Это на уровне 8 класса API Dialog.
tidbeck

должен был быть удален позже: /
Яцек Kwiecień

@Xylian это все еще в документации Dialog.setOnShowListener ()
tidbeck


18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

или

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

Большое спасибо, приятель, это было потрясающе, на самом деле я использовал оба из них для решения своей проблемы, у меня была ситуация, когда если пользователь находится в режиме добавления, то нужно показать клавиатуру в начале активности, а для режима обновления клавиатура не требуется по умолчанию. Итак, в манифесте для активности я установил, stateHiddenи когда я обнаружил, что пользователь создает новый элемент, то я отобразил клавиатуру, используя указанную вами строку кода. :) Еще раз спасибо.
PHP Avenger

Я получаю сообщение «Не удается разрешить getWindow ()». Я пытался поставить «это». и другие вещи перед этим. Я хочу получить клавиатуру без использования текста редактирования, просто нажав на определенную часть экрана.
Androidcoder

1
@ Androidcoder, это часть Activity, поэтому добавьте что-то вроде ((Activity) context).getWindow().....
CoolMind

15

Фрагменты кода из других ответов работают, но не всегда очевидно, где разместить их в коде, особенно если вы используете AlertDialog.Builderи следовали официальному диалогу, потому что он не использует final AlertDialog ...или alertDialog.show().

alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Предпочтительнее

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Потому что SOFT_INPUT_STATE_ALWAYS_VISIBLE будет скрывать клавиатуру, если фокус переключится с EditText, где SHOW_FORCED будет отображать клавиатуру до тех пор, пока она не будет явно отклонена, даже если пользователь возвращается на домашний экран или отображает последние приложения.

Ниже приведен рабочий код для AlertDialog, созданного с использованием пользовательского макета с EditText, определенным в XML. Он также устанавливает на клавиатуре клавишу «go» и позволяет ей активировать положительную кнопку.

alert_dialog.xml:

<RelativeLayout
android:id="@+id/dialogRelativeLayout"
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

    <!-- android:imeOptions="actionGo" sets the keyboard to have a "go" key instead of a "new line" key. -->
    <!-- android:inputType="textUri" disables spell check in the EditText and changes the "go" key from a check mark to an arrow. -->
    <EditText
        android:id="@+id/editText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_marginBottom="16dp"
        android:imeOptions="actionGo"
        android:inputType="textUri"/>

</RelativeLayout>

AlertDialog.java:

import android.app.Activity;
import android.app.Dialog;
import android.content.DialogInterface;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v4.app.DialogFragment;
import android.support.v7.app.AlertDialog;
import android.support.v7.app.AppCompatDialogFragment;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.WindowManager;
import android.widget.EditText;

public class CreateDialog extends AppCompatDialogFragment {
    // The public interface is used to send information back to the activity that called CreateDialog.
    public interface CreateDialogListener {
        void onCreateDialogCancel(DialogFragment dialog);    
        void onCreateDialogOK(DialogFragment dialog);
    }

    CreateDialogListener mListener;

    // Check to make sure that the activity that called CreateDialog implements both listeners.
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (CreateDialogListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement CreateDialogListener.");
        }
    }

    // onCreateDialog requires @NonNull.
    @Override
    @NonNull
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(getActivity());
        LayoutInflater customDialogInflater = getActivity().getLayoutInflater();

        // Setup dialogBuilder.
        alertDialogBuilder.setTitle(R.string.title);
        alertDialogBuilder.setView(customDialogInflater.inflate(R.layout.alert_dialog, null));
        alertDialogBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogCancel(CreateDialog.this);
            }
        });
        alertDialogBuilder.setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                mListener.onCreateDialogOK(CreateDialog.this);
            }
        });

        // Assign the resulting built dialog to an AlertDialog.
        final AlertDialog alertDialog = alertDialogBuilder.create();

        // Show the keyboard when the dialog is displayed on the screen.
        alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

        // We need to show alertDialog before we can setOnKeyListener below.
        alertDialog.show();

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

        // Allow the "enter" key on the keyboard to execute "OK".
        editText.setOnKeyListener(new View.OnKeyListener() {
            public boolean onKey(View v, int keyCode, KeyEvent event) {
                // If the event is a key-down event on the "enter" button, select the PositiveButton "OK".
                if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER)) {
                    // Trigger the create listener.
                    mListener.onCreateDialogOK(CreateDialog.this);

                    // Manually dismiss alertDialog.
                    alertDialog.dismiss();

                    // Consume the event.
                    return true;
                } else {
                    // If any other key was pressed, do not consume the event.
                    return false;
                }
            }
        });

        // onCreateDialog requires the return of an AlertDialog.
        return alertDialog;
    }
}

11

Ну, это довольно старый пост, но есть что добавить.
Это 2 простых метода, которые помогают мне контролировать клавиатуру, и они работают просто идеально:

Показать клавиатуру

public void showKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.showSoftInput(v, 0);
}

Скрыть клавиатуру

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

Что такое getCurrentFocus()?
CoolMind

Я вижу, это метод Activity.
CoolMind

10

Позвольте мне указать некоторую дополнительную информацию о решении Юку, потому что мне было трудно заставить это работать! Как получить объект AlertDialog из моего AlertDialog.Builder? Ну, это результат моей alert.show()казни:

final AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
final EditText input = new EditText(getActivity());
alert.setView(input);

// do what you need, like setting positive and negative buttons...

final AlertDialog dialog = alert.show();

input.setOnFocusChangeListener(new OnFocusChangeListener() {
   @Override
   public void onFocusChange(View v, boolean hasFocus) {
      if(hasFocus) {
         dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
      }
   }
});

7

Взгляните на это обсуждение, которое обрабатывает скрытие и показ IME вручную. Тем не менее, я чувствую, что, если сфокусированный EditTextне поднимает IME, это потому, что вы вызываете AlertDialog.show()свой OnCreate()или какой-то другой метод, который вызывается до того, как экран действительно будет представлен. OnPostResume()Я полагаю, что в этом случае это нужно исправить.


6

Да, вы можете сделать, setOnFocusChangeListenerэто поможет вам.

editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (hasFocus) {
            dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        }
    }
});

4

Я знаю, что этот вопрос старый, я думаю, что использование функции расширения - более красивый способ показать клавиатуру для редактирования текста

Вот метод, который я использую, чтобы показать клавиатуру для текста редактирования.

код котлина: просто нужно позвонитьedittext.showKeyboard()

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

код Java:

public static void showKeyboard(EditText editText) {
    editText.post(new Runnable() {
      @Override
      public void run() {
        editText.requestFocus();
        InputMethodManager imm = (InputMethodManager) editText.getContext()
            .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
      }
    });
  }

3

Если кто-то получает:

Невозможно сделать статическую ссылку на нестатический метод getSystemService (String) из типа Activity

Попробуйте добавить контекст для вызова getSystemService.

Так

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

1

Оригинальный вопрос касается диалогов, и мой EditText находится на регулярной основе. Во всяком случае, я подозреваю, что это должно работать для большинства из вас тоже. Так вот что работает для меня (выше предложенный метод с самым высоким рейтингом ничего не сделал для меня). Вот пользовательский EditView, который делает это (подклассы не нужны, но я нашел это удобным для моих целей, так как я хотел также захватить фокус, когда представление становится видимым).

На самом деле это в значительной степени совпадает с ответом Tidbecks. Я вообще-то не заметил его ответа, так как у него были нулевые голоса. Тогда я собирался просто прокомментировать его пост, но это было бы слишком долго, поэтому я все равно закончил делать этот пост. Тидбек указывает, что он не уверен, как это работает с устройствами, имеющими клавиатуры. Я могу подтвердить, что поведение кажется одинаковым в любом случае. Это так, что в портретном режиме программная клавиатура выскакивает, а в альбомной - нет. Сдвинуть или нет физическую клавиатуру не имеет значения на моем телефоне.

Потому что, я лично нашел поведение немного неловко , я выбрал для использования: InputMethodManager.SHOW_FORCED. Это работает так, как я хотел, чтобы это работало. Клавиатура становится видимой независимо от ориентации, однако, по крайней мере, на моем устройстве она не выскакивает, если выдвинута аппаратная клавиатура.

import android.app.Service;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class BringOutTheSoftInputOnFocusEditTextView extends EditText {

    protected InputMethodManager inputMethodManager;

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init();
    }

    public BringOutTheSoftInputOnFocusEditTextView(Context context) {
        super(context);
        init();
    }

    private void init() {
        this.inputMethodManager = (InputMethodManager)getContext().getSystemService(Service.INPUT_METHOD_SERVICE);
        this.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    BringOutTheSoftInputOnFocusEditTextView.this.inputMethodManager.showSoftInput(BringOutTheSoftInputOnFocusEditTextView.this, InputMethodManager.SHOW_FORCED);
                }
            }
        });
    }

    @Override
    protected void onVisibilityChanged(View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (visibility == View.VISIBLE) {
            BringOutTheSoftInputOnFocusEditTextView.this.requestFocus();
        }
    }

}

1

Кажется, проблема в том, что поскольку место, где вы вводите текст, изначально скрыто (или вложено, или что-то в этом роде), AlertDialog автоматически устанавливает флаг WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMилиWindowManager.LayoutParams.FLAG_NOT_FOCUSABLE таким образом, вещи не запускают мягкий ввод для отображения.

Чтобы исправить это, добавьте следующее:

(...)
// Create the dialog and show it
Dialog dialog = builder.create()
dialog.show();

// After show (this is important specially if you have a list, a pager or other view that uses a adapter), clear the flags and set the soft input mode
dialog.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE|WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

1

попробуйте и используйте:

editText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, InputMethodManager.HIDE_IMPLICIT_ONLY);

1

Чтобы показать клавиатуру, мне пришлось сделать следующее

Android TextField: установить фокус + программный ввод программно

По сути, решение заключается в следующем

@Override
public void onResume() {
    super.onResume();
    //passwordInput.requestFocus(); <-- that doesn't work
    passwordInput.postDelayed(new ShowKeyboard(), 325); //250 sometimes doesn't run if returning from LockScreen
}

Где ShowKeyboardнаходится

private class ShowKeyboard implements Runnable {
    @Override
    public void run() {
        passwordInput.setFocusableInTouchMode(true);
        //passwordInput.requestFocusFromTouch(); //this gives touch event to launcher in background -_-
        passwordInput.requestFocus();
        getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
        ((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE)).showSoftInput(passwordInput, 0);
    }
}

После успешного ввода, я также убедитесь, что я скрываю клавиатуру

getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN);
((InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE))
                    .hideSoftInputFromWindow(getView().getWindowToken(), 0);

1

Поместите эти методы в свой класс Util и используйте где угодно.

Котлин

fun hideKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

private fun showKeyboard(activity: Activity) {
    val view = activity.currentFocus
    val methodManager = activity.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Ява

public static void hideKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.hideSoftInputFromWindow(view.getWindowToken(), InputMethodManager.HIDE_NOT_ALWAYS);
}

private static void showKeyboard(Activity activity) {
    View view = activity.getCurrentFocus();
    InputMethodManager methodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);
    assert methodManager != null && view != null;
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
}

1

Я создал хорошие функции расширения kotlin-esqe, если кому-то интересно

fun Activity.hideKeyBoard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.hideSoftInputFromWindow(view!!.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)
}

fun Activity.showKeyboard() {
    val view = this.currentFocus
    val methodManager = this.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
    assert(view != null)
    methodManager.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

0

Это хороший образец для вас:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <ScrollView
        android:id="@+id/scrollID"
        android:layout_width="fill_parent"
        android:layout_height="0dip"
        android:layout_weight="1" >

        <LinearLayout
            android:id="@+id/test"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical" >
        </LinearLayout>
    </ScrollView>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:baselineAligned="true"
        android:orientation="horizontal"
        android:paddingBottom="5dp"
        android:paddingLeft="5dp"
        android:paddingRight="5dp"
        android:weightSum="1" >

        <EditText
            android:id="@+id/txtInpuConversation"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:hint="@string/edt_Conversation" >

            <requestFocus />
        </EditText>

        <Button
            android:id="@+id/btnSend"
            android:layout_width="0dip"
            android:layout_height="wrap_content"
            android:layout_weight="0.5"
            android:text="@string/btn_Conversation" />
    </LinearLayout>

</LinearLayout>

0

Почему этот ответ - Потому что выше решение будет показывать клавиатуру , но она не исчезнет , если вы щелкните в любом другом , что EditText. Поэтому вам нужно что-то сделать, чтобы клавиатура исчезла при потере EditTextфокуса.

Вы можете достичь этого, выполнив следующие действия:

  1. Сделайте родительский вид (контентный вид вашей деятельности) кликабельным и фокусируемым, добавив следующие атрибуты

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. Реализуйте метод hideKeyboard ()

        public void hideKeyboard(View view) {
            InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
        }
  3. Наконец, установите onFocusChangeListener вашего текста редактирования.

        edittext.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (!hasFocus) {
                    hideKeyboard(v);
                }
            }
        });

0

Это немного сложно. Я так и сделал, и это сработало.

1.При первом вызове скрыть программный ввод из окна. Это позволит скрыть программный ввод, если программная клавиатура видна, или ничего не делать, если его нет.

2. Покажите ваш диалог

3. Затем просто позвоните, чтобы переключить мягкий ввод.

код:

InputMethodManager inputManager = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE); 
//hiding soft input
inputManager.hideSoftInputFromWindow(findViewById(android.R.id.content).getWind‌​owToken(), 0);
//show dialog
yourDialog.show();
//toggle soft input
inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.SHOW_IMPLICIT);

0

Попробуй это

SomeUtils.java

public static void showKeyboard(Activity activity, boolean show) {
    InputMethodManager inputMethodManager = (InputMethodManager) activity.getSystemService(Context.INPUT_METHOD_SERVICE);

    if(show)
        inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
    else
        inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY,0);
}

0

Перепробовал много но вот что у меня сработало (котлин):

        val dialog = builder.create()
        dialog.setOnShowListener {
            nameEditText.requestFocus()
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0)
        }

        dialog.setOnDismissListener {
            val s = ContextCompat.getSystemService(requireContext(), InputMethodManager::class.java)
            s?.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0)
        }

        dialog.show()

0

Глядя на https://stackoverflow.com/a/39144104/2914140, я немного упростил:

// In onCreateView():
view.edit_text.run {
    requestFocus()
    post { showKeyboard(this) }
}

fun showKeyboard(view: View) {
    val imm = view.context.getSystemService(
        Context.INPUT_METHOD_SERVICE) as InputMethodManager?
    imm?.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
}

Это лучше, чем https://stackoverflow.com/a/11155404/2914140 :

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

потому что когда вы нажимаете кнопку «Домой» и переходите на домашний экран, клавиатура остается открытой.


-1
getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);

Я вызываю это в onCreate (), чтобы автоматически показывать клавиатуру при входе в Activity.

Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.