Como mostrar o teclado virtual quando o edittext está focado

Desejo mostrar automaticamente o teclado virtual quando um EditTextestiver focado (se o dispositivo não tiver um teclado físico) e tiver dois problemas:

1. Quando o meu Activityé exibido, o meu EditTexté focado, mas o teclado não é exibido, preciso clicar novamente nele para mostrar o teclado (ele deve ser exibido quando o meu Activityfor exibido).

2. E quando clico em pronto no teclado, o teclado é descartado, mas o EditTextfoco permanece e você não quer (porque minha edição está concluída).

Para resumir, meu problema é ter algo mais parecido com o iPhone: que mantém o teclado sincronizado com o meu EditTextestado (focado / não focado) e, é claro, não apresenta um teclado virtual se houver um físico.

Para forçar o teclado virtual a aparecer, você pode usar

EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
yourEditText.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

E para remover o foco EditText, infelizmente você precisa ter um manequim Viewpara capturar o foco.

Eu espero que isso ajude

Para fechá-lo, você pode usar

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

Isso funciona para usá-lo em uma caixa de diálogo

public void showKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
}

public void closeKeyboard(){
    InputMethodManager inputMethodManager = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
    inputMethodManager.toggleSoftInput(InputMethodManager.HIDE_IMPLICIT_ONLY, 0);
}

Eu tive o mesmo problema. Imediatamente após a edição do Text VISIBILITY mudar de GONE para VISIBLE, tive que definir o foco e exibir o teclado virtual. Consegui isso usando o seguinte código:

new Handler().postDelayed(new Runnable() {

    public void run() {
//        ((EditText) findViewById(R.id.et_find)).requestFocus();
//              
        EditText yourEditText= (EditText) findViewById(R.id.et_find);
//        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
//        imm.showSoftInput(yourEditText, InputMethodManager.SHOW_IMPLICIT);

        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
        yourEditText.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));                           
    }
}, 200);

Funciona para mim com atraso de 100ms, mas falhou sem demora ou com apenas um atraso de 1ms.

A parte comentada do código mostra outra abordagem, que funciona apenas em alguns dispositivos. Eu testei no SO versões 2.2 (emulador), 2.2.1 (dispositivo real) e 1.6 (emulador).

Essa abordagem me salvou muita dor.

Para fazer com que o teclado apareça, use

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

Este método é mais confiável do que invocar o InputMethodManager diretamente.

Para fechá-lo, use

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

Quando nada mais funcionar, force-o a ser mostrado :

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

E depois, se você deseja fechá-lo, em onPause (), por exemplo, você pode chamar:

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

O código a seguir é pilhado do código-fonte 4.1 do Google para o SearchView. Parece funcionar, também funciona em versões inferiores do Android.

private Runnable mShowImeRunnable = new Runnable() {
    public void run() {
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.showSoftInput(editText, 0);
        }
    }
};

private void setImeVisibility(final boolean visible) {
    if (visible) {
        post(mShowImeRunnable);
    } else {
        removeCallbacks(mShowImeRunnable);
        InputMethodManager imm = (InputMethodManager) getContext()
                .getSystemService(Context.INPUT_METHOD_SERVICE);

        if (imm != null) {
            imm.hideSoftInputFromWindow(getWindowToken(), 0);
        }
    }
}

Além disso, o código a seguir precisa ser adicionado à medida que o Controle / Atividade é criado. (No meu caso, é um controle composto, e não uma atividade).

this.editText.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    public void onFocusChange(View v, boolean hasFocus) {
        setImeVisibility(hasFocus);
    }
});

android:windowSoftInputMode="stateAlwaysVisible" -> no arquivo manifesto.

edittext.requestFocus(); -> no código.

Isso abrirá o teclado virtual no qual a edição de texto tem solicitação de foco à medida que a atividade é exibida.

Eu tive alguma sorte recente em alguns casos simples com o código abaixo. Eu não terminei todos os testes, mas ....

EditText input = (EditText) findViewById(R.id.Input);
input.requestFocus();    
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_DOWN , 0, 0, 0));
input.dispatchTouchEvent(MotionEvent.obtain(SystemClock.uptimeMillis(), SystemClock.uptimeMillis(), MotionEvent.ACTION_UP , 0, 0, 0));

E pronto, o teclado aparece.

Você pode tentar forçar o teclado virtual a aparecer, ele funciona para mim:

...
dialog.show();
input.requestFocus();
InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

Às vezes, a resposta de raukodraug não funciona. Eu fiz isso dessa maneira com algumas tentativas e erros:

public static void showKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
    }
}

public static void hideKeyboard(Activity activity) {
    if (activity != null) {
        activity.getWindow()
                .setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
    }
}

E a parte EditText :

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

Para ocultar o teclado, use este:

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

e para mostrar o teclado:

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

E para o Kotlin, basta usar estas extensões:

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

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

Para fragmento, verifique se está funcionando:

 displayName = (EditText) view.findViewById(R.id.displayName);
    InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);

showSoftInput não estava funcionando para mim.

Imaginei que precisava definir o modo de entrada: (aqui no componente Activity no manifesto)

android:windowSoftInputMode="stateVisible" 

Acredite ou não, meu problema com o teclado virtual foi resolvido quando descobri que as animações de atividades podem desativar o teclado virtual. Quando você chama a intenção com o

i.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);

e

overridePendingTransition(0, 0);

Ele pode ocultar o teclado virtual e não há como mostrá-lo.

Eu tive o mesmo problema em várias situações diferentes, e as soluções que encontrei funcionam em algumas, mas não funcionam em outras, então aqui está uma solução combinada que funciona na maioria das situações que encontrei:

public static void showVirtualKeyboard(Context context, final View view) {
    if (context != null) {
        final InputMethodManager imm =  (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
        view.clearFocus();

        if(view.isShown()) {
            imm.showSoftInput(view, 0);
            view.requestFocus();
        } else {
            view.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
                @Override
                public void onViewAttachedToWindow(View v) {
                    view.post(new Runnable() {
                        @Override
                        public void run() {
                            view.requestFocus();
                            imm.showSoftInput(view, 0);
                        }
                    });

                    view.removeOnAttachStateChangeListener(this);
                }

                @Override
                public void onViewDetachedFromWindow(View v) {
                    view.removeOnAttachStateChangeListener(this);
                }
            });
        }
    }
}

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

Combinei tudo aqui e para mim funciona:

public static void showKeyboardWithFocus(View v, Activity a) {
    try {
        v.requestFocus();
        InputMethodManager imm = (InputMethodManager) a.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(v, InputMethodManager.SHOW_IMPLICIT);
        a.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Funcionou para mim. Você pode tentar com isso também para mostrar o teclado:

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

fragmento de código . . .

public void hideKeyboard(Context activityContext){

    InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    //android.R.id.content ( http://stackoverflow.com/a/12887919/2077479 )
    View rootView = ((Activity) activityContext)
            .findViewById(android.R.id.content).getRootView();

    imm.hideSoftInputFromWindow(rootView.getWindowToken(), 0);
}

public void showKeyboard(Context activityContext, final EditText editText){

    final InputMethodManager imm = (InputMethodManager)
            activityContext.getSystemService(Context.INPUT_METHOD_SERVICE);

    if (!editText.hasFocus()) {
        editText.requestFocus();
    }

    editText.post(new Runnable() {
        @Override
        public void run() {
            imm.showSoftInput(editText, InputMethodManager.SHOW_FORCED);
        }
    });
}

Kotlin extensão para mostrar o teclado em foco.

Essa é uma combinação de respostas anteriores, que são muito longas ou incompletas.

Esta extensão publica um executável na fila de mensagens que mostra o teclado virtual após solicitar o foco:

fun View.showSoftKeyboard() {
    post {
        if (this.requestFocus()) {
            val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
            imm?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
        }
    }
}

Chame-o de qualquer visualização, quando necessário posteriormente:

editText.showSoftKeyboard()

basta adicionar android: windowSoftInputMode = "stateHidden" no arquivo de manifesto ...

final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);

Dentro do seu manifesto:

android:windowSoftInputMode="stateAlwaysVisible"- teclado lançado inicialmente. android:windowSoftInputMode="stateAlwaysHidden" - teclado inicialmente oculto.

Eu gosto de usar também "adjustPan"porque quando o teclado é iniciado, a tela se ajusta automaticamente.

 <activity
      android:name="YourActivity"
      android:windowSoftInputMode="stateAlwaysHidden|adjustPan"/>

Basta adicionar esta linha na sua visualização EditText:

android:isScrollContainer="true"

e TADA - o teclado começou a aparecer automaticamente!

Eu tive um problema semelhante e descobri esta solução simples e estranha.

Como já foi mencionado aqui pelo user3392439, a aparência do teclado em foco de alguma forma estranhamente conectada com a presença do componente de rolagem no arquivo XML.

Mesmo a presença de outra visualização EditText que compreende a linha acima mencionada no mesmo XML faz com que o teclado apareça, não importa qual dos EditTexts esteja atualmente focado.

Se você tiver pelo menos uma visualização visível que compreende o componente de rolagem em seu arquivo XML - o teclado aparecerá automaticamente em foco.

Se não houver rolagem - você precisará clicar em EditText para fazer o teclado aparecer.

Todas as soluções fornecidas acima ( interação InputMethodManager no ouvinte OnFocusChangeListener.onFocusChange anexado ao seu EditText funcionarão bem se você tiver uma edição única na atividade.

No meu caso, tenho duas edições.

 private EditText tvX, tvY;
 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
 tvX.setOnFocusChangeListener(this);
    tvY.setOnFocusChangeListener(this);

@Override
public void onFocusChange(View v, boolean hasFocus) {       
    InputMethodManager imm =  (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    if(tvX.hasFocus() || tvY.hasFocus()) {            
        imm.showSoftInput(v, 0);            
    } else {
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);         
    }       
};

Observei que onFocusChange é acionado para tvX com hasFocus = true (teclado mostrado), mas depois para tvY com hasFocus = true (teclado oculto). No final, nenhum teclado estava visível.

A solução geral deve ter a instrução correta em "show keyboard if EditText text has focus"

Na seção onResume () da atividade, você pode chamar o método bringKeyboard ();

 onResume() {
     EditText yourEditText= (EditText) findViewById(R.id.yourEditText);
     bringKeyboard(yourEditText);
 }


  protected boolean bringKeyboard(EditText view) {
    if (view == null) {
        return false;
    }
    try {
      // Depending if edittext has some pre-filled values you can decide whether to bring up soft keyboard or not
        String value = view.getText().toString();
        if (value == null) {
            InputMethodManager imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
            return true;
        }
    } catch (Exception e) {
        Log.e(TAG, "decideFocus. Exception", e);
    }
    return false;
  }

Nenhuma das respostas funcionou para mim. Aqui está uma maneira simples.

searchEditText.setVisibility(View.VISIBLE);
                final Handler handler=new Handler();
                handler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        searchEditText.requestFocus();
                    }
                }, 400);

Atrasou o método requestFocus () por 400ms.

Descobri um comportamento estranho, pois em um dos meus aplicativos o teclado virtual era exibido automaticamente ao entrar na atividade (existe um editText.requestFocus () no onCreate).

Ao aprofundar as descobertas, descobri que isso acontecia porque havia um ScrollView ao redor do layout. Se eu remover o ScrollView, o comportamento será o descrito na declaração original do problema: somente ao clicar no editText já focado, o teclado virtual será exibido.

Se não funcionar, tente inserir um ScrollView - é inofensivo de qualquer maneira.

Eu tive um problema semelhante ao usar animações de exibição . Então, eu coloquei um ouvinte de animação para garantir que eu esperasse a animação terminar antes de tentar solicitar um acesso de teclado no edittext exibido.

    bottomUp.setAnimationListener(new Animation.AnimationListener() {
        @Override
        public void onAnimationStart(Animation animation) {
        }

        @Override
        public void onAnimationEnd(Animation animation) {
            if (textToFocus != null) {
                // Position cursor at the end of the text
                textToFocus.setSelection(textToFocus.getText().length());
                // Show keyboard
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.showSoftInput(textToFocus, InputMethodManager.SHOW_IMPLICIT);
            }
        }

        @Override
        public void onAnimationRepeat(Animation animation) {
        }
    });

Estou de acordo com o raukodraug, portanto, usando em um swithview, você deve solicitar / um foco claro como este:

    final ViewSwitcher viewSwitcher = (ViewSwitcher) findViewById(R.id.viewSwitcher);
    final View btn = viewSwitcher.findViewById(R.id.address_btn);
    final View title = viewSwitcher.findViewById(R.id.address_value);

    title.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            viewSwitcher.showPrevious();
            btn.requestFocus();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.showSoftInput(btn, InputMethodManager.SHOW_IMPLICIT);
        }
    });

    // EditText affiche le titre evenement click
    btn.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            btn.clearFocus();
            viewSwitcher.showNext();
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(btn.getWindowToken(), 0);
            // Enregistre l'adresse.
            addAddress(view);
        }
    });

Saudações.