Android - manipule "Enter" em um EditText

Eu estou querendo saber se existe uma maneira de lidar com o usuário pressionando Enterenquanto digita EditText, algo como o evento HTML onSubmit.

Também me pergunto se existe uma maneira de manipular o teclado virtual de forma que o botão "Concluído" seja rotulado como outra coisa (por exemplo, "Ir") e execute uma certa ação quando clicado (novamente, como no Submeter).

Gostaria de saber se existe uma maneira de lidar com o usuário pressionando Enterenquanto digita um EditText, algo como o evento HTML onSubmit.

Sim.

Também me pergunto se existe uma maneira de manipular o teclado virtual de forma que o botão "Concluído" seja rotulado como outra coisa (por exemplo, "Ir") e execute uma certa ação quando clicado (novamente, como no Submeter).

Também sim.

Você deseja examinar os atributos android:imeActionIde android:imeOptions, além do setOnEditorActionListener()método, todosTextView .

Para alterar o texto do botão "Concluído" para uma sequência personalizada, use:

mEditText.setImeActionLabel("Custom text", KeyEvent.KEYCODE_ENTER);

final EditText edittext = (EditText) findViewById(R.id.edittext);
edittext.setOnKeyListener(new OnKeyListener() {
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        // If the event is a key-down event on the "enter" button
        if ((event.getAction() == KeyEvent.ACTION_DOWN) &&
            (keyCode == KeyEvent.KEYCODE_ENTER)) {
          // Perform action on key press
          Toast.makeText(HelloFormStuff.this, edittext.getText(), Toast.LENGTH_SHORT).show();
          return true;
        }
        return false;
    }
});

Aqui está o que você faz. Ele também está oculto no código de exemplo do Bluetooth Developer 'Bluetooth Chat'. Substitua as partes em negrito que dizem "exemplo" por suas próprias variáveis ​​e métodos.

Primeiro, importe o que você precisa para a Atividade principal, onde deseja que o botão de retorno faça algo especial:

import android.view.inputmethod.EditorInfo;
import android.widget.TextView;
import android.view.KeyEvent;

Agora, faça uma variável do tipo TextView.OnEditorActionListener para sua chave de retorno (aqui eu uso exampleListener );

TextView.OnEditorActionListener exampleListener = new TextView.OnEditorActionListener(){

Então você precisa dizer ao ouvinte duas coisas sobre o que fazer quando o botão de retorno é pressionado. Ele precisa saber do que estamos falando sobre EditText (aqui eu uso o exampleView ) e, em seguida, precisa saber o que fazer quando a tecla Enter for pressionada (aqui, example_confirm () ). Se este é o último ou o único EditText da sua atividade, ele deve fazer o mesmo que o método onClick para o botão Enviar (ou OK, Confirmar, Enviar, Salvar, etc).

public boolean onEditorAction(TextView exampleView, int actionId, KeyEvent event) {
   if (actionId == EditorInfo.IME_NULL  
      && event.getAction() == KeyEvent.ACTION_DOWN) { 
      example_confirm();//match this behavior to your 'Send' (or Confirm) button
   }
   return true;
}

Por fim, defina o ouvinte (provavelmente no seu método onCreate);

exampleView.setOnEditorActionListener(exampleListener);

Os teclados de hardware sempre produzem eventos de digitação, mas os teclados de software retornam diferentes IDs de ação e nulos no SingleLine EditTexts. Esse código responde toda vez que o usuário pressiona enter em um EditText em que este ouvinte foi definido, independentemente do EditText ou do tipo de teclado.

import android.view.inputmethod.EditorInfo;
import android.view.KeyEvent;
import android.widget.TextView.OnEditorActionListener;

listener=new TextView.OnEditorActionListener() {
  @Override
  public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
    if (event==null) {
      if (actionId==EditorInfo.IME_ACTION_DONE);
      // Capture soft enters in a singleLine EditText that is the last EditText.
      else if (actionId==EditorInfo.IME_ACTION_NEXT);
      // Capture soft enters in other singleLine EditTexts
      else return false;  // Let system handle all other null KeyEvents
    }
    else if (actionId==EditorInfo.IME_NULL) { 
    // Capture most soft enters in multi-line EditTexts and all hard enters.
    // They supply a zero actionId and a valid KeyEvent rather than
    // a non-zero actionId and a null event like the previous cases.
      if (event.getAction()==KeyEvent.ACTION_DOWN); 
      // We capture the event when key is first pressed.
      else  return true;   // We consume the event when the key is released.  
    }
    else  return false; 
    // We let the system handle it when the listener
    // is triggered by something that wasn't an enter.


    // Code from this point on will execute whenever the user
    // presses enter in an attached view, regardless of position, 
    // keyboard, or singleLine status.

    if (view==multiLineEditText)  multiLineEditText.setText("You pressed enter");
    if (view==singleLineEditText)  singleLineEditText.setText("You pressed next");
    if (view==lastSingleLineEditText)  lastSingleLineEditText.setText("You pressed done");
    return true;   // Consume the event
  }
};

A aparência padrão da tecla enter em singleLine = false fornece uma seta dobrada para inserir o teclado. Quando singleLine = true no último EditText, a chave diz DONE e, no EditTexts, antes que diz NEXT. Por padrão, esse comportamento é consistente em todos os emuladores de baunilha, android e google. O atributo scrollHorizontal não faz nenhuma diferença. O teste nulo é importante porque a resposta dos telefones às entradas flexíveis é deixada para o fabricante e, mesmo nos emuladores, os emuladores de baunilha Nível 16 respondem a entradas flexíveis longas em várias linhas e rolagemHorizontal EditTexts with a actionId de NEXT e null a o evento.

Esta página descreve exatamente como fazer isso.

https://developer.android.com/training/keyboard-input/style.html

Defina o android: imeOptions , basta verificar o actionId no onEditorAction. Portanto, se você definir imeOptions como 'actionDone', verificará 'actionId == EditorInfo.IME_ACTION_DONE' em onEditorAction. Além disso, certifique-se de definir o android: inputType.

Aqui está o EditText do exemplo vinculado acima:

<EditText
    android:id="@+id/search"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="@string/search_hint"
    android:inputType="text"
    android:imeOptions="actionSend" />

Você também pode definir isso programaticamente usando a função setImeOptions (int) . Aqui está o OnEditorActionListener do exemplo vinculado acima:

EditText editText = (EditText) findViewById(R.id.search);
editText.setOnEditorActionListener(new OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        boolean handled = false;
        if (actionId == EditorInfo.IME_ACTION_SEND) {
            sendMessage();
            handled = true;
        }
        return handled;
    }
});

Eu sei que isso tem um ano, mas eu descobri que isso funciona perfeitamente para um EditText.

EditText textin = (EditText) findViewById(R.id.editText1);
textin.setInputType(InputType.TYPE_CLASS_TEXT);

Impede tudo, menos texto e espaço. Não consegui tabular, "retornar" ("\ n") ou qualquer coisa.

Assim como um adendo à resposta de Chad (que funcionou quase perfeitamente para mim), descobri que precisava adicionar uma verificação no tipo de ação KeyEvent para impedir que meu código fosse executado duas vezes (uma vez na tecla e outra na tecla para baixo) evento).

if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_DOWN)
{
    // your code here
}

Consulte http://developer.android.com/reference/android/view/KeyEvent.html para obter informações sobre eventos de ação repetidos (mantendo pressionada a tecla Enter) etc.

Eu tinha um propósito semelhante. Eu queria resolver pressionando a tecla "Enter" no teclado (que eu queria personalizar) em um AutoCompleteTextView que estende o TextView. Tentei diferentes soluções acima e elas pareciam funcionar. Mas tive alguns problemas quando mudei o tipo de entrada no meu dispositivo (Nexus 4 com AOKP ROM) do SwiftKey 3 (onde funcionou perfeitamente) para o teclado Android padrão (onde, em vez de manipular meu código do ouvinte, uma nova linha era entrou depois de pressionar a tecla "Enter". Demorei um pouco para resolver esse problema, mas não sei se ele funcionará em todas as circunstâncias, independentemente do tipo de entrada que você usar.

Então aqui está a minha solução:

Defina o atributo de tipo de entrada do TextView no xml como "text":

android:inputType="text"

Personalize o rótulo da tecla "Enter" no teclado:

myTextView.setImeActionLabel("Custom text", KeyEvent.KEYCODE_ENTER);

Defina um OnEditorActionListener para o TextView:

myTextView.setOnEditorActionListener(new OnEditorActionListener()
{
    @Override
    public boolean onEditorAction(TextView v, int actionId,
        KeyEvent event)
    {
    boolean handled = false;
    if (event.getAction() == KeyEvent.KEYCODE_ENTER)
    {
        // Handle pressing "Enter" key here

        handled = true;
    }
    return handled;
    }
});

Espero que isso ajude outras pessoas a evitar os problemas que tive, porque quase me deixaram maluco.

No seu xml, adicione o atributo imeOptions ao editText

<EditText
    android:id="@+id/edittext_additem"
    ...
    android:imeOptions="actionDone"
    />

Em seguida, no seu código Java, adicione o OnEditorActionListener ao mesmo EditText

mAddItemEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if(actionId == EditorInfo.IME_ACTION_DONE){
                //do stuff
                return true;
            }
            return false;
        }
    });

Aqui está a explicação: o imeOptions = actionDone atribuirá "actionDone" à EnterKey. A tecla EnterKey no teclado mudará de "Enter" para "Done". Portanto, quando a tecla Enter for pressionada, ela acionará esta ação e, portanto, você a manipulará.

Você também pode fazer isso ..

editText.setOnKeyListener(new OnKeyListener() {

            @Override
            public boolean onKey(View v, int keyCode, KeyEvent event)
            {
                if (event.getAction() == KeyEvent.ACTION_DOWN
                        && event.getKeyCode() ==       KeyEvent.KEYCODE_ENTER) 
                {
                    Log.i("event", "captured");

                    return false;
                } 

            return false;
        }
    });

     password.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if(event != null && event.getKeyCode() == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN) {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
                submit.performClick();
                return true;
            }
            return false;
        }
    });

Funciona muito bem para mim
Além disso, ocultar o teclado

Primeiro, você deve definir o EditText para ouvir o pressionamento de tecla

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main); 

    // Set the EditText listens to key press
    EditText edittextproductnumber = (EditText) findViewById(R.id.editTextproductnumber);
    edittextproductnumber.setOnKeyListener(this);

}

Segundo, defina o evento com a tecla pressionada, por exemplo, evento para definir o texto do TextView:

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    // TODO Auto-generated method stub

 // Listen to "Enter" key press
 if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER))
 {
     TextView textviewmessage = (TextView) findViewById(R.id.textViewmessage);
     textviewmessage.setText("You hit 'Enter' key");
     return true;
 }

return false;   

}

E, finalmente, não esqueça de importar EditText, TextView, OnKeyListener, KeyEvent na parte superior:

import android.view.KeyEvent;
import android.view.View.OnKeyListener;
import android.widget.EditText;
import android.widget.TextView;

funcionando perfeitamente

public class MainActivity extends AppCompatActivity {  
TextView t;
Button b;
EditText e;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    b = (Button) findViewById(R.id.b);
    e = (EditText) findViewById(R.id.e);

    e.addTextChangedListener(new TextWatcher() {

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {

            if (before == 0 && count == 1 && s.charAt(start) == '\n') {

                b.performClick();
                e.getText().replace(start, start + 1, ""); //remove the <enter>
            }

        }
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
        @Override
        public void afterTextChanged(Editable s) {}
    });

    b.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            b.setText("ok");

        }
    });
}

}

funcionando perfeitamente

editText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId != 0 || event.getAction() == KeyEvent.ACTION_DOWN) {
                // Action
                return true;
            } else {
                return false;
            }
        }
    });

Xml

<EditText
        android:id="@+id/editText2"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="@string/password"
        android:imeOptions="actionGo|flagNoFullscreen"
        android:inputType="textPassword"
        android:maxLines="1" />

Isso deve funcionar

input.addTextChangedListener(new TextWatcher() {

           @Override
           public void afterTextChanged(Editable s) {}

           @Override    
           public void beforeTextChanged(CharSequence s, int start,
             int count, int after) {
           }

           @Override    
           public void onTextChanged(CharSequence s, int start,
             int before, int count) {
               if( -1 != input.getText().toString().indexOf( "\n" ) ){
                   input.setText("Enter was pressed!");
                    }
           }
          });

Digite este código no seu editor para poder importar os módulos necessários.

 query.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView textView, int actionId, KeyEvent keyEvent) {
            if(actionId == EditorInfo.IME_ACTION_DONE
                    || keyEvent.getAction() == KeyEvent.ACTION_DOWN
                        || keyEvent.getAction() == KeyEvent.KEYCODE_ENTER) {

                // Put your function here ---!

                return true;

            }
            return false;
        }
    });

Isso funciona bem em telefones LG Android. Impede que ENTERoutros caracteres especiais sejam interpretados como caracteres normais. NextO Donebotão ou aparece automaticamente e ENTERfunciona conforme o esperado.

edit.setInputType(InputType.TYPE_CLASS_TEXT);

Aqui está uma função estática simples que você pode ativar na sua classe Utilsou Keyboardsque executará o código quando o usuário pressionar a tecla Return em um teclado de hardware ou software. É uma versão modificada da excelente resposta do Earcasper

 /**
 * Return a TextView.OnEditorActionListener that will execute code when an enter is pressed on
 * the keyboard.<br>
 * <code>
 *     myTextView.setOnEditorActionListener(Keyboards.onEnterEditorActionListener(new Runnable()->{
 *         Toast.makeText(context,"Enter Pressed",Toast.LENGTH_SHORT).show();
 *     }));
 * </code>
 * @param doOnEnter A Runnable for what to do when the user hits enter
 * @return the TextView.OnEditorActionListener
 */
public static TextView.OnEditorActionListener onEnterEditorActionListener(final Runnable doOnEnter){
    return (__, actionId, event) -> {
        if (event==null) {
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                // Capture soft enters in a singleLine EditText that is the last EditText.
                doOnEnter.run();
                return true;
            } else if (actionId==EditorInfo.IME_ACTION_NEXT) {
                // Capture soft enters in other singleLine EditTexts
                doOnEnter.run();
                return true;
            } else {
                return false;  // Let system handle all other null KeyEvents
            }
        } else if (actionId==EditorInfo.IME_NULL) {
            // Capture most soft enters in multi-line EditTexts and all hard enters.
            // They supply a zero actionId and a valid KeyEvent rather than
            // a non-zero actionId and a null event like the previous cases.
            if (event.getAction()==KeyEvent.ACTION_DOWN) {
                // We capture the event when key is first pressed.
                return true;
            } else {
                doOnEnter.run();
                return true;   // We consume the event when the key is released.
            }
        } else {
            // We let the system handle it when the listener
            // is triggered by something that wasn't an enter.
            return false;
        }
    };
}

O InputType no campo de texto deve estar textem ordem para o que o CommonsWare disse para funcionar. Apenas tentei tudo isso, nenhum inputType antes da avaliação e nada funcionou, o Enter continuou registrando como soft enter. Depois inputType = text, tudo, incluindo o setImeLabel, funcionou.

Exemplo: android:inputType="text"

   final EditText edittext = (EditText) findViewById(R.id.edittext);
    edittext.setOnKeyListener(new OnKeyListener() {
        public boolean onKey(View v, int keyCode, KeyEvent event) {
            // If the event is a key-down event on the "enter" button
            if ((event.getAction() == KeyEvent.ACTION_DOWN) &&
                    (keyCode == KeyEvent.KEYCODE_ENTER)) {
                // Perform action on key press
                Toast.makeText(HelloFormStuff.this, edittext.getText(), Toast.LENGTH_SHORT).show();
                return true;
            }
            return false;
        }
    });

Uma maneira confiável de responder a um <enter> em um EditText é com um TextWatcher , um LocalBroadcastManager e um BroadcastReceiver . Você precisa adicionar a biblioteca de suporte v4 para usar o LocalBroadcastManager. Eu uso o tutorial em vogella.com : 7.3 "Eventos de transmissão local com LocalBroadcastManager" devido ao seu exemplo conciso completo de código. Em onTextChanged before é o índice do final da alteração antes da alteração >; menos o início. Quando no TextWatcher o thread da interface do usuário está ocupado atualizando o editText editável, enviamos uma Intenção para ativar o BroadcastReceiver quando o thread da interface do usuário terminar de atualizar o editText.

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.text.Editable;
//in onCreate:
editText.addTextChangedListener(new TextWatcher() {
  public void onTextChanged
  (CharSequence s, int start, int before, int count) {
    //check if exactly one char was added and it was an <enter>
    if (before==0 && count==1 && s.charAt(start)=='\n') {
    Intent intent=new Intent("enter")
    Integer startInteger=new Integer(start);
    intent.putExtra("Start", startInteger.toString()); // Add data
    mySendBroadcast(intent);
//in the BroadcastReceiver's onReceive:
int start=Integer.parseInt(intent.getStringExtra("Start"));
editText.getText().replace(start, start+1,""); //remove the <enter>
//respond to the <enter> here

Esta pergunta ainda não foi respondida com Butterknife

LAYOUT XML

<android.support.design.widget.TextInputLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/some_input_hint">

        <android.support.design.widget.TextInputEditText
            android:id="@+id/textinput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:imeOptions="actionSend"
            android:inputType="text|textCapSentences|textAutoComplete|textAutoCorrect"/>
    </android.support.design.widget.TextInputLayout>

JAVA APP

@OnEditorAction(R.id.textinput)
boolean onEditorAction(int actionId, KeyEvent key){
    boolean handled = false;
    if (actionId == EditorInfo.IME_ACTION_SEND || (key.getKeyCode() == KeyEvent.KEYCODE_ENTER)) {
        //do whatever you want
        handled = true;
    }
    return handled;
}

Usando o Kotlin, criei uma função que lida com todos os tipos de ações "feitas" para o EditText, incluindo o teclado, e é possível modificá-lo e também manipular outras teclas como desejar:

private val DEFAULT_ACTIONS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT = arrayListOf(EditorInfo.IME_ACTION_SEND, EditorInfo.IME_ACTION_GO, EditorInfo.IME_ACTION_SEARCH, EditorInfo.IME_ACTION_DONE)
private val DEFAULT_KEYS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT = arrayListOf(KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_NUMPAD_ENTER)

fun EditText.setOnDoneListener(function: () -> Unit, onKeyListener: OnKeyListener? = null, onEditorActionListener: TextView.OnEditorActionListener? = null,
                               actionsToHandle: Collection<Int> = DEFAULT_ACTIONS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT,
                               keysToHandle: Collection<Int> = DEFAULT_KEYS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT) {
    setOnEditorActionListener { v, actionId, event ->
        if (onEditorActionListener?.onEditorAction(v, actionId, event) == true)
            return@setOnEditorActionListener true
        if (actionsToHandle.contains(actionId)) {
            function.invoke()
            return@setOnEditorActionListener true
        }
        return@setOnEditorActionListener false
    }
    setOnKeyListener { v, keyCode, event ->
        if (onKeyListener?.onKey(v, keyCode, event) == true)
            return@setOnKeyListener true
        if (event.action == KeyEvent.ACTION_DOWN && keysToHandle.contains(keyCode)) {
            function.invoke()
            return@setOnKeyListener true
        }
        return@setOnKeyListener false
    }
}

Então, use amostra:

        editText.setOnDoneListener({
            //do something
        })

Quanto à alteração do rótulo, acho que depende do aplicativo do teclado e que geralmente muda apenas na paisagem, conforme escrito aqui . De qualquer forma, exemplo de uso para isso:

        editText.imeOptions = EditorInfo.IME_ACTION_DONE
        editText.setImeActionLabel("ASD", editText.imeOptions)

Ou, se você quiser em XML:

    <EditText
        android:id="@+id/editText" android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:imeActionLabel="ZZZ" android:imeOptions="actionDone" />

E o resultado (mostrado na paisagem):

Adicione estas opções, e deve funcionar:

import android.view.KeyEvent;
import android.view.View;
import android.widget.EditText;

Isso fornecerá uma função que pode ser chamada quando o usuário pressionar a tecla Enter.

fun EditText.setLineBreakListener(onLineBreak: () -> Unit) {
    val lineBreak = "\n"
    doOnTextChanged { text, _, _, _ ->
        val currentText = text.toString()

        // Check if text contains a line break
        if (currentText.contains(lineBreak)) {

            // Uncommenting the lines below will remove the line break from the string
            // and set the cursor back to the end of the line

            // val cleanedString = currentText.replace(lineBreak, "")
            // setText(cleanedString)
            // setSelection(cleanedString.length)

            onLineBreak()
        }
    }
}

Uso

editText.setLineBreakListener {
    doSomething()
}