Como mostrar o teclado virtual quando o edittext está focado

461

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.

Ludovic Landry
fonte
Eu só tenho um EditText básico como: <EditText android: id = "@ + id / myEditText" android: layout_width = "fill_parent" android: layout_height = "wrap_content" android: imeOptions = "actionDone" /> E na minha atividade eu tenho this: EditText editTxt = (EditText) findViewById (R.id.myEditText); editTxt.requestFocus ();
Ludovic Landry
2
Isso me ajudou melhor do que qualquer resposta neste post: stackoverflow.com/a/2418314/1491212
Armel Larcier

Respostas:

628

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);
}
raukodraug
fonte
2
Se eu fizer isso, o teclado virtual será mostrado quando a atividade aparecer (é boa), mas quando meu foco sair do EditText e for para um botão, por exemplo, o teclado permanecerá (isso é ruim).
Ludovic Landry
157
Não funciona para mim com um EditText em uma caixa de diálogo que já tem foco. Não sei por que.
Matthias
10
@AbdellahBenhammou, talvez fazer uma chamada requestFocus no seu texto de edição antes de mostrar a entrada dinâmica possa resolver seu problema. Isso fez por mim.
R1k0
18
@AbdellahBenhammou, faça isso no onCreate () do seu DialogFragment: getDialog (). GetWindow (). SetSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
Phillip
22
Trabalhou apenas em conjunto com yourEditText.requestFocus()o descrito aqui: stackoverflow.com/questions/8991522/…
Vivek Pandey
231

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.

Mike Keskinov
fonte
48
Eu não sabia que algo poderia ser tão feio e tão bonito ao mesmo tempo. Muito obrigado!
mkerley
15
@jellyfish isso simula um toque no EditText. Para outras pessoas que estão lendo isso, em vez de criar um novo, Handlertambém pode usar o View.postDelayed()método no yourEditTextpróprio widget.
Tony Chan
5
Esta é uma solução hack - muito melhor por David Chandler.
Ben Bederson
4
Se a solução de David Chandler funcionar em todas as versões / dispositivos Android e no caso em que a VISIBILITY foi alterada de GONE para VISIBLE, então YES - você deverá usar a solução.
Mike Keskinov
3
Acordado. Você conhece uma solução melhor que funciona em todos os sabores do Android?
Mike Keskinov
162

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);
David Chandler
fonte
12
Alguém pode explicar por que isso é mais confiável do que invocar diretamente InputMethodManager? (Por um lado, ele não funciona, ao contrário de solução de raukodraug.)
Matthew Quiros
5
Também não funciona para mim. Trabalhando no Android 2.3.5. A solução de raukodraug funciona para mim. Pesquisou a dependência da versão, mas não conseguiu encontrar uma.
Hugo Logmans
2
Isso funcionou para mim no Android 4.4.2. O método InputMethodManager escolhido como a solução para esta postagem não funcionou para mim.
Phil
depois de usar o método na resposta, acrescentei isso e funcionou, mas sem ele não funcionou. thanx
Manny265
2
Não funcionou para mim no Android 4.4.2. Ele mostra o teclado, mas não o ocultou.
22414 John J Smith
87

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);
Bolling
fonte
4
Você estava certo, @Bolling! Quando nada mais funcionou, seu código me salvou. Obrigado!
Willian Paixao
3
Seu código foi o único que trabalhou para mim, e eu tentei todas as soluções nesta página! Muito obrigado!
Mattia Ruggiero
4
não force. em alguns casos, quando você passa do primeiro plano para o segundo plano, o teclado permanece lá porque você o forçou. é um problema de fragmentação, mas eu já vi isso em samsung duos.
j2emanue
Normalmente, sempre tenho código para fechar o teclado na Pausa (), pois o vi travar, mesmo que você não o force.
Bolling
Que fez o trabalho, mas quando mudança para as outras telas, ele ainda permanece em aberto
Sithu
75

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);
    }
});
Robin Davies
fonte
Obrigado! Funciona incrivelmente bem. E é a solução com a qual me sinto mais confortável com todas as respostas e tópicos que tenho lido sobre esse problema.
Rui
37
:-D setImeVisibility(hasFocus)?
Matthias
Eu tentei esse método, pois estava "rolando minha própria exibição de pesquisa" (não queria fazer isso, mas havia razões). Isso funcionou para mim, exceto no início da atividade. Adicionei android: windowSoftInputMode = "alwaysVisible" à atividade e já tinha requestFocus () sendo chamado no texto de edição. Funciona como um campeão.
Javahead76
Alguma idéia da necessidade de removeCallbacks (mShowImeRunnable)? Eu pensei que uma vez que o executável é escolhido para executar a partir da fila, ele será removido da fila ao mesmo tempo também?
Cheok Yan Cheng
1
Depois de experimentar várias variações, essa foi a única que funcionou consistentemente para mim (Android 4.42). Thx
John J Smith
34

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.

gorenikhil33
fonte
2
Isso abre o teclado na criação da atividade.
Xpto
não responder à pergunta, mas me ajudou :)
S.Thiongane
abre chave sem requestFocus em api 22
David
Funciona bem para o meu caso. Gostaria de saber por que o atributo request focus apenas do xml precisa ser mencionado no manifesttambém!
sud007 18/05/19
30

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.

Dente
fonte
Para o meu caso, eu tinha um botão para adicionar algumas informações opcionais. No manipulador button.onClick, o código acima foi adicionado para forçar o teclado virtual a aparecer para a entrada das informações opcionais. Droid 2.2.2
Dent
Esta é uma boa solução, mas não esqueça que você deve criar um objeto MotionEvent e chamar recycle () após o uso, para ser reutilizado por um chamador posterior.
jimbob
Você só precisa de um dispatchTouchEvent () com ACTION_UP como argumento ..
Mohammed Junaid
15

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);
Vadim Zin4uk
fonte
1
Isso funciona para mim ... Eu tinha tentado estes InputMethodManager imm = (InputMethodManager) getSystemService (Context.INPUT_METHOD_SERVICE); imm.showSoftInput (nome, inputMethodManager.SHOW_IMPLICIT); ou getWindow (). setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE); mas nenhum deles estava trabalhando.
Günay Gültekin
10

À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());
            }
        }
    });
Xieyi
fonte
1
Esta é a única solução que funcionou para mim no Android 5
user1021430
10

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);
Mubashar
fonte
Para um DialogFragment, você pode chamar isso de um substituído onStart()e usar getDialog().getWindow()como alternativa a getActivity().getWindow().
Mr-IDE
10

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)
}
bitvale
fonte
É mesmo o que eu procurava.
lasec0203 11/04
8

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);
Arish Khan
fonte
7

showSoftInput não estava funcionando para mim.

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

android:windowSoftInputMode="stateVisible" 
vincebodi
fonte
6

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.

sparkbit
fonte
6

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);
                }
            });
        }
    }
}
n0sferat0k
fonte
6
editText.post(new Runnable() {
    @Override
    public void run() {
        InputMethodManager imm = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(editText, InputMethodManager.SHOW_IMPLICIT);
    }
});
Hóspede
fonte
6

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();
    }
}
lxknvlk
fonte
6

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

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
Tarit Ray
fonte
5

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);
        }
    });
}
Jongz Puangput
fonte
5

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()
Alex Burdusel
fonte
4

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

Prakash Gavade
fonte
4
final InputMethodManager keyboard = (InputMethodManager) ctx.getSystemService(Context.INPUT_METHOD_SERVICE);
keyboard.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
XXX
fonte
4

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"/>
Md Imran Choudhury
fonte
4

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.

Waldmann
fonte
Isso é muito estranho, mas definitivamente funciona - eu estava tentando requesFocus()de dentro de um manipulador de cliques e esta é a única maneira que não seja uma explícita showSoftInput SHOW_FORCED
atraiu
Puta merda, obrigado cara. Não faço idéia por que ele funciona, mas eu testei em 8 dispositivos de diferentes fabricantes e funcionou sempre!
Antonio Vlasic
3

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"

Bartosz Bilicki
fonte
3

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;
  }
Vikas
fonte
Qual é o WidgetUtils.showKeyboard? Essa é a parte mais importante aqui.
TWIStErRob
2

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.

Satyajit Das
fonte
Muito obrigado, ele precisa de algum atraso para o teclado mostrar ...
hkh114
1

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.

user3392439
fonte
1

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) {
        }
    });
Benjamin Piette
fonte
1

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.

Jean-Luc Barat
fonte