Android: mostra o teclado virtual automaticamente quando o foco está em um EditText

340

Estou mostrando uma caixa de entrada usando AlertDialog. O EditTextinterior da caixa de diálogo é automaticamente focado quando ligo AlertDialog.show(), mas o teclado virtual não é mostrado automaticamente.

Como faço para que o teclado virtual apareça automaticamente quando a caixa de diálogo é exibida? (e não há teclado físico / hardware). Assim como quando pressiono o botão Pesquisar para invocar a pesquisa global, o teclado virtual é mostrado automaticamente.

Randy Sugianto 'Yuku'
fonte
11
Isso deve acontecer automaticamente, conforme o comentário de Ted abaixo. Verifique isso primeiro!
Cheezmeister 8/08
Esta resposta é mais simples e funciona bem: stackoverflow.com/a/8018630/89818
caw
11
Voltei a esta resposta várias vezes ao longo dos anos. É sempre dentro de um diálogo que eu estou tendo esse problema, nunca fragmento ou atividade.
tir38
Possível duplicata de Fechar / ocultar o teclado
virtual

Respostas:

304

Você pode criar um ouvinte de foco EditTextno e AlertDialog, em seguida, obter o AlertDialog's Window. A partir daí, você pode exibir o teclado virtual ligando para 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);
        }
    }
});
Randy Sugianto 'Yuku'
fonte
5
Como eu faria isso usando o AlertDialog.Builder? ... alerta AlertDialog.Builder final = novo AlertDialog.Builder (Main.this);
Stephen
6
@ Stephen, você pode obter o diálogo do construtor usando final AlertDialog dialog = builder.create()e, showem seguida, no diálogo, em vez do construtor.
Tidbeck 11/11
30
RETIREI MEU COMENTÁRIO ACIMA Descobri que, se você não conseguir o foco certo, dê uma olhada no seu XML! Se você vir a tag <requestFocus> </requestFocus> - remova-a. Parece que a tag dará foco ao EditText e seu ouvinte não será acionado, pois o EditText já está focado.
Ted
11
Como você não faz isso se o dispositivo possui um teclado de hardware? Parece que isso é chato para esses usuários.
Mxcl # 8/12
8
Realmente não entendo por que esse não é o comportamento padrão no SDK. Se uma exibição que precisa de entrada de texto mostra um cursor piscando, por que alguém não gostaria de ver o teclado para inserir texto? Ela se sente tão errado de uma UX para mim
Christian García
240

Para mostrar o uso do teclado:

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

Para ocultar o uso do teclado:

InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(view.getWindowToken(),0); 
horkavlna
fonte
3
Isso funciona particularmente bem quando você deseja mostrar / ocultar o teclado virtual com base na alternância da visibilidade de uma exibição no layout entre VISIBLE e GONE.
PacificSky 5/07/12
38
Sugiro usar o sinalizador SHOW_IMPLICIT, pois isso significa que alterar a atividade ou o aplicativo ocultará automaticamente o teclado conforme o esperado.
precisa saber é o seguinte
6
@drspaceboo Usando SHOW_IMPLICIT não funciona em tudo para mim, eu tenho que usar SHOW_FORCED, não sei porquê ...
Yoann Hercouet
11
Quando o código acima deve ser executado? Tentei fazer isso logo após adicionar meu layout ao pai. Isso não funcionou. Mas se eu fizesse isso depois que o layout já existia há algum tempo, funcionava. Existe um retorno de chamada que me diga "Se você tentar mostrar o teclado agora, ele realmente funcionará"?
William Jockusch
11
toggleSoftInput (InputMethodManager.SHOW_FORCED, 0) alterna o teclado virtual. Se você deseja garantir que o teclado apareça, use imm.showSoftInput (view, InputMethodManager.SHOW_IMPLICIT), em que view é a View que receberá a entrada.
PJ_Finnegan
111

Você pode solicitar um teclado virtual logo após criar a caixa de diálogo (teste no SDK - r20)

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

// request keyboard   
dialog.getWindow().setSoftInputMode (WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
Bao Le
fonte
Para quem se pergunta, esse método não abre o teclado virtual quando um teclado de hardware está conectado. Acabei de testar com um cabo USB On-The-Go. Perfeito!
13rac1 27/01
Isso não faz nada por mim.
31416 JohnyTex
Eu não tenho teclado de hardware. Talvez configuração (?)
JohnyTex
25

Eu tive o mesmo problema e resolvi-o com o seguinte código. Não tenho certeza de como ele se comportará em um telefone com teclado de hardware.

// 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();
tidbeck
fonte
É na classe do diálogo nível API 8.
tidbeck
deve ter sido removido mais tarde: /
Jacek Kwiecień
@Xylian ainda está na documentação Dialog.setOnShowListener ()
tidbeck
18
<activity
    ...
    android:windowSoftInputMode="stateVisible" >
</activity>

ou

getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
ahtartam
fonte
Muito obrigado, companheiro, isso foi incrível, usei os dois para resolver o meu problema, tive uma situação em que, se o usuário estivesse no modo de adição, precisava mostrar o teclado no início da atividade e, no modo de atualização, nenhum teclado era necessário por padrão. Então, no manifesto para a atividade que eu defino stateHiddene quando detecto que o usuário está criando um novo item, eu exibi o teclado usando a linha de código que você mencionou. :) Mais uma vez obrigado.
PHP Avenger
Recebo a mensagem 'não é possível resolver o getWindow ()'. Eu tentei colocar 'isso'. e outras coisas antes dele. Eu quero pegar o teclado sem usar um edittext, apenas clicando em uma determinada parte da tela.
Androidcoder
11
@ AndroidCoder, é uma parte da atividade, então adicione algo como ((Activity) context).getWindow().....
CoolMind 3/10
15

Trechos de código de outras respostas funcionam, mas nem sempre é óbvio onde colocá-los no código, especialmente se você estiver usando um AlertDialog.Buildere seguido o tutorial oficial da caixa de diálogo porque ele não usa final AlertDialog ...or alertDialog.show().

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

É preferível

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

Como SOFT_INPUT_STATE_ALWAYS_VISIBLE ocultará o teclado se o foco sair do EditText, onde SHOW_FORCED manterá o teclado exibido até que seja explicitamente dispensado, mesmo que o usuário retorne à tela inicial ou exiba os aplicativos recentes.

Abaixo está o código de trabalho para um AlertDialog criado usando um layout personalizado com um EditText definido em XML. Ele também define o teclado para ter uma tecla "go" e permite acionar o botão positivo.

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;
    }
}
Soren Stoutner
fonte
11

Bem, este é um post bastante antigo, ainda há algo a acrescentar.
Estes são 2 métodos simples que me ajudam a manter o teclado sob controle e funcionam perfeitamente:

Mostrar teclado

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

Ocultar teclado

public void hideKeyboard() {
    InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
    View v = getCurrentFocus();
    if (v != null)
        imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
}
sberezin
fonte
O que é getCurrentFocus()?
CoolMind 3/10
Entendo, esse é um método de um Activity.
CoolMind 5/10
10

Deixe-me apontar algumas informações adicionais para a solução de yuku, porque achei difícil fazer isso funcionar! Como obtenho o objeto AlertDialog do meu AlertDialog.Builder? Bem, é o resultado da minha alert.show()execução:

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);
      }
   }
});
user1344313
fonte
Essa deve ser a resposta aceita.
Cristiano Coelho
7

Dê uma olhada nesta discussão que trata de ocultar e mostrar manualmente o IME. No entanto, meu sentimento é que, se um foco EditTextnão está trazendo o IME, é porque você está chamando AlertDialog.show()seu OnCreate()ou algum outro método que é evocado antes da tela ser realmente apresentada. Movê-lo para OnPostResume()corrigi-lo nesse caso, acredito.

jqpubliq
fonte
6

Sim, você pode fazer com setOnFocusChangeListenerisso irá ajudá-lo.

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);
        }
    }
});
Sachin Surjan
fonte
4

Sei que essa pergunta é antiga, acho que usar uma função de extensão é uma maneira mais bonita de mostrar o teclado para um texto de edição

Aqui está o método que eu uso para mostrar o teclado para um edittext.

código kotlin: basta ligaredittext.showKeyboard()

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

o código 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);
      }
    });
  }
A.easazadeh
fonte
3

Se alguém estiver recebendo:

Não é possível fazer uma referência estática para o método não estático getSystemService (String) do tipo Activity

Tente adicionar contexto à chamada getSystemService.

assim

InputMethodManager imm = 
(InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,0);
Ryan Wittenburg
fonte
1

A pergunta original diz respeito às caixas de diálogo e meu EditText está em uma exibição regular. De qualquer forma, suspeito que isso funcione também para a maioria de vocês. Então, aqui está o que funciona para mim (o método de classificação mais alta sugerido acima não fez nada para mim). Aqui está um EditView personalizado que faz isso (a subclasse não é necessária, mas achei conveniente para meus propósitos, pois eu também queria focar quando a exibição se tornar visível).

Na verdade, é praticamente o mesmo que a resposta dos boatos. Na verdade, eu não percebi a resposta dele, pois tinha zero votos positivos. Então eu estava prestes a comentar o post dele, mas teria sido muito longo, então acabei fazendo esse post de qualquer maneira. tidbeck ressalta que não tem certeza de como isso funciona com dispositivos com teclados. Posso confirmar que o comportamento parece ser exatamente o mesmo em ambos os casos. Sendo assim, no modo retrato, o teclado do software aparece e, na paisagem, não. Ter o teclado físico deslizado para fora ou não, não faz diferença no meu telefone.

Porque, I pessoalmente o comportamento um pouco estranho optei por usar: InputMethodManager.SHOW_FORCED. Isso funciona como eu queria que funcionasse. O teclado fica visível independentemente da orientação; no entanto, pelo menos no meu dispositivo, ele não aparece se o teclado do hardware tiver sido deslizado para fora.

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

}
Timo
fonte
1

O problema parece ser que, como o local em que você digita o texto está oculto inicialmente (ou aninhado ou algo assim), o AlertDialog define automaticamente o sinalizador WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IMou WindowManager.LayoutParams.FLAG_NOT_FOCUSABLEpara que as coisas não acionem uma entrada suave para aparecer.

A maneira de corrigir isso é adicionar o seguinte:

(...)
// 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);
Allan Veloso
fonte
1

tente usar:

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

Para mostrar o teclado, eu tive que fazer o seguinte

Android TextField: defina foco + entrada suave programaticamente

Essencialmente, a solução é a seguinte

@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
}

Onde ShowKeyboardfica

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);
    }
}

Após uma entrada bem-sucedida, também oculto o teclado

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

Coloque esses métodos na sua classe Util e use em qualquer lugar.

Kotlin

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)
}

Java

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);
}
Khemraj
fonte
1

Eu criei boas funções de extensão kotlin-esqe, caso alguém esteja interessado

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)
}
Eu sou
fonte
0

Esta é uma boa amostra para você:

<?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>
AA
fonte
0

Por que esta resposta - Como a solução acima mostrará o teclado, mas não desaparecerá se você clicar em outro lugar que não seja EditText. Então, você precisa fazer algo para fazer com que o teclado desapareça quando EditTextperder o foco.

Você pode conseguir isso executando as seguintes etapas:

  1. Torne a visualização principal (visualização de conteúdo da sua atividade) clicável e focável, adicionando os seguintes atributos

        android:clickable="true" 
        android:focusableInTouchMode="true" 
  2. Implementar um método hideKeyboard ()

        public void hideKeyboard(View view) {
            InputMethodManager inputMethodManager =(InputMethodManager)getSystemService(Activity.INPUT_METHOD_SERVICE);
            inputMethodManager.hideSoftInputFromWindow(view.getWindowToken(),InputMethodManager.HIDE_IMPLICIT_ONLY );
        }
  3. Por fim, defina o onFocusChangeListener do seu edittext.

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

Isso é um pouco complicado. Eu fiz dessa maneira e funcionou.

1.Na primeira chamada para ocultar a entrada suave da janela. Isso ocultará a entrada programável se o teclado virtual estiver visível ou não fizer nada se não estiver.

2.Show sua caixa de diálogo

3.Em seguida, basta ligar para alternar a entrada suave.

código:

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);
FRR
fonte
0

Tente isto

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);
}
GameBug
fonte
0

Tentei muitos, mas é isso que funcionou para mim (kotlin):

        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()
Lorenzo
fonte
0

Olhando para https://stackoverflow.com/a/39144104/2914140 , simplifiquei um pouco:

// 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)
}

É melhor que https://stackoverflow.com/a/11155404/2914140 :

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

porque quando você pressiona o botão Início e passa para a tela inicial, o teclado permanece aberto.

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

Eu chamo isso em onCreate () para mostrar o teclado automaticamente, quando entrei na Activity.

Raul Yang
fonte