Android - manipule "Enter" em um EditText

459

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

Felix
fonte
1
Kotlin & Extensions: dê uma olhada aqui: stackoverflow.com/a/48810268/1912924
Francesco Donzello

Respostas:

374

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);
CommonsWare
fonte
26
(PS EditText estende TextView, assim, por que as propriedades que você deve olhar estão em TextView - quando li pela primeira vez que a última frase que eu fiz um olhar duas vezes :))
Ricket
15
Como uma nota. Nem todos os teclados suportam o atributo android: imeOptions padrão. O que é realmente decepcionante. Por exemplo, IME_ACTION_DONE é definido como 6, onde o teclado padrão HTC (em telefones como o Incredible, Evo 4G) a tecla de retorno é definido como 0. #
fernferret
13
Além disso, se você estiver usando imeOptions, certifique-se de usar também inputType = "text" ou outro equivalente. Para garantir que o teclado ouça você! Nexus1
Blundell
6
"Sim" - você seria mais descritivo do que isso? Ele provavelmente perguntará como implementar a solução.
Al Wang
4
@ AlWang: Primeiro, sua área de preocupação é abordada na resposta (consulte começando com "Você desejará ..."). Segundo, essa resposta é de seis anos atrás e, portanto, presumiríamos que o problema do OP foi resolvido. Afinal, o OP aceitou a resposta.
CommonsWare
267
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;
    }
});
Jarod DY Law
fonte
1
Por algum motivo, quando clico enterno meu texto de edição, o texto inteiro é movido para baixo ... Como posso corrigir isso?
Ruchir Baronia 01/03
1
@RuchirBaronia Adicione android: maxLines = "1" ao seu EditText. Seu EditText não está "se movendo para baixo", mas inserindo uma quebra de linha no texto digitado. Definir maxLines como 1 impede que a quebra de linha seja inserida.
precisa saber é
3
Esta solução funciona apenas para teclados de hardware, NÃO para o teclado virtual / virtual. Se você confiar nele, seu aplicativo será quebrado para usuários sem teclados conectados.
user3562927
12
Sem ofensa ao CommonsWare, mas sua resposta RTFM foi muito menos útil que este exemplo simples, mostrando exatamente como fazê-lo. Obrigado!
AutonomousApps
1
@AutonomousApps, muitas vezes vejo respostas do CommonsWare. Ele teve sorte em responder desde 2009, quando o Android começou. Frequentemente "sim", "não", "impossível" e assim por diante, geralmente sem código. Muitas vezes, suas respostas estão desatualizadas agora, então tento não seguir suas recomendações.
CoolMind 04/02/19
215

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);
Chad Hedgcock
fonte
20
Bom, eu usei EditorInfo.IME_ACTION_SEND e tenho android: imeOptions = "actionSend" no XML.
Bani
procurar por EditorInfo.IME_ACTION_SEND não teve efeito para mim (emulador), portanto, como um gatilho infalível, também procurei por KeyEvent.KEYCODE_ENTER. Veja aqui: stackoverflow.com/questions/2004344/…
Alguém em algum lugar
4
Geralmente é melhor executar ações KeyEvent.ACTION_UP. Para que isso funcione, você precisa primeiro consumir o ACTION_DOWNevento: if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_DOWN) { return true; }. Em seguida, você pode verificar o ACTION_UPevento e executar a ação (semelhante à resposta acima). Se você não consumir o ACTION_DOWNevento, onEditorActionnão será necessário ACTION_UP.
ashughes
2
Isto é o que funcionou para mim: if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN) {...}- não poderia obter qualquer das outras abordagens para o trabalho
Jonathan Ellis
38

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.

ouvidor
fonte
Quando atualizei o Java, minha cadeia de ferramentas do Android quebrou. Era de 32 bits. Reinstalei tudo de 64 bits e descobri que há muito mais versões de emulador público disponíveis agora. Devo admitir que só sei que o comportamento do EditorActionListener é consistente nos emuladores que testei.
earlcasper
Quando publiquei isso no meu blog, alguém comentou que, para fazê-lo funcionar no eclipse, você precisa alterar a ação ime padrão, adicionando android: imeOptions = ”actionGo”.
earlcasper
Ops, eu li errado o comentário no meu blog. Para fazê-lo funcionar no eclipse, você precisa alterar a ação ime padrão, adicionando android: imeOptions = ”actionGo”. para o 'EditText' no xml de layout.
earlcasper
Em uma reflexão mais aprofundada meu último comentário refere-se tanto Ant e Eclipse
earlcasper
27

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;
    }
});
Mike
fonte
21

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.

Novato
fonte
Trabalhou para mim, com a adição do IME_ACTION_DONE
htafoya
1
Funciona perfeitamente se você deseja desativar a tecla "Enter".
Deej
16

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.

cermitologia
fonte
16

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.

Kaolick
fonte
Infelizmente, isso não está funcionando com a nova versão 4 do SwiftKey. E isso está me deixando louco de novo ...: - /
kaolick 20/02
3
seu FI está incorreto. usar: 'event.getKeyCode () == KeyEvent.KEYCODE_ENTER'
Loda
Perfeito para mim. Lembre-se também de inserir o setImeActionLabel novamente na instrução IF, caso contrário o texto personalizado desaparecerá após a primeira pressão.
Steve Rogers
Seu IF está correto, porque ele define seu actionId como KeyEvent.KEYCODE_ENTER acima :-D, mas sim todo mundo provavelmente irá querer usar event.getKeyCode () == KeyEvent.KEYCODE_ENTER
Ray Hulha
15

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á.

ARCA
fonte
9

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;
        }
    });
Zar E Ahmer
fonte
Por algum motivo, quando clico enterno meu texto de edição, o texto inteiro é movido para baixo ... Como posso corrigir isso?
Ruchir Baronia 01/03
Eu acho que você quer aprender stackoverflow.com/questions/10978038/... othewise me mostrar o seu xml
Zar E Ahmer
6
     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

Vlad
fonte
5

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;
LifeiSHot
fonte
5

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

Domi mtz
fonte
5
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" />
kreker
fonte
4

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!");
                    }
           }
          });
ORY
fonte
4

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;
        }
    });
Sanjit Prasad
fonte
query = Nome do campo EditText e adicione também -> (android: imeOptions = "actionSearch") no xml de EditText.
Sanjit Prasad 11/11/19
3

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);
Milan Švec
fonte
Esta é a única coisa que funcionou para mim. Eu tenho um Motorola Moto X 2 e normalmente ele tem uma tecla "Return" com a seta e tudo. Isso mudou para uma marca de verificação e finalmente consegui convencer o ouvinte a trabalhar com isso. (Antes de criar uma nova linha). Portanto, se alguém está tendo esse problema ...
cola místico
2

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;
        }
    };
}
JohnnyLambada
fonte
Observe que isso usa uma expressão lambda que requer Java 1.8, mas é fácil convertê-la para não usar uma lambda. No entanto, o problema que vi com esse tipo de solução é que o teclado virtual não é oculto automaticamente e, no modo de tela cheia (pequeno dispositivo na orientação paisagem), o modo de tela cheia não é desativado depois que o usuário pressiona Enter ou DONE
jk7
2

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"

Odaym
fonte
2
   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;
        }
    });
Brinda Rathod
fonte
1

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
ouvidor
fonte
Se você estiver usando algum tipo de entrada de texto * (por exemplo android:inputType="textCapSentences"), os retornos de carro serão filtrados para fora da entrada, para que onTextChanged () não seja chamado quando o usuário pressionar a tecla Enter.
Jk7
1

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;
}
Alguém algum lugar
fonte
TextInputLayout e Butterknife: WIN!
Javi
1

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

insira a descrição da imagem aqui

desenvolvedor android
fonte
0

Adicione estas opções, e deve funcionar:

import android.view.KeyEvent;
import android.view.View;
import android.widget.EditText;
Jacky Supit
fonte
0

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()
}
Michael
fonte