Android: gestisci "Invio" in un testo di modifica

Mi chiedo se c'è un modo per gestire l'utente premendo Entermentre si digita un EditText, qualcosa come l'evento HTML onSubmit.

Mi chiedo anche se esiste un modo per manipolare la tastiera virtuale in modo tale che il pulsante "Fatto" sia etichettato qualcos'altro (ad esempio "Vai") ed esegua una determinata azione quando si fa clic (di nuovo, come onSubmit).

Mi chiedo se c'è un modo per gestire l'utente premendo Entermentre si digita un EditText, qualcosa come l'evento HTML onSubmit.

Sì.

Mi chiedo anche se esiste un modo per manipolare la tastiera virtuale in modo tale che il pulsante "Fatto" sia etichettato qualcos'altro (ad esempio "Vai") ed esegua una determinata azione quando si fa clic (di nuovo, come onSubmit).

Anche si.

Ti consigliamo di guardare gli attributi android:imeActionIde android:imeOptions, più il setOnEditorActionListener()metodo, tutti su TextView.

Per modificare il testo del pulsante "Fine" in una stringa personalizzata, utilizzare:

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

Ecco cosa fai. È anche nascosto nel codice di esempio "Chat Bluetooth" dello sviluppatore Android. Sostituisci le parti in grassetto che dicono "esempio" con le tue variabili e i tuoi metodi.

Innanzitutto, importa ciò di cui hai bisogno nell'attività principale in cui vuoi che il pulsante di ritorno faccia qualcosa di speciale:

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

Ora, crea una variabile di tipo TextView.OnEditorActionListener per la tua chiave di ritorno (qui uso exampleListener );

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

Quindi devi dire all'ascoltatore due cose su cosa fare quando viene premuto il pulsante di ritorno. Deve sapere di cosa stiamo parlando EditText (qui uso exampleView ), quindi deve sapere cosa fare quando si preme il tasto Invio (qui, example_confirm () ). Se questo è l'ultimo o solo EditText nella tua attività, dovrebbe fare la stessa cosa del metodo onClick per il tuo pulsante Invia (o OK, Conferma, Invia, Salva, ecc.).

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

Infine, imposta il listener (molto probabilmente nel tuo metodo onCreate);

exampleView.setOnEditorActionListener(exampleListener);

Le tastiere hardware producono sempre eventi di immissione, ma le tastiere software restituiscono diversi actionID e null in SingleLine EditTexts. Questo codice risponde ogni volta che l'utente preme invio in un EditText su cui questo listener è stato impostato, indipendentemente da EditText o dal tipo di tastiera.

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

L'aspetto predefinito della chiave di invio in singleLine = false fornisce una freccia piegata per accedere alla tastiera. Quando singleLine = true nell'ultimo EditText la chiave dice DONE, e su EditTexts prima che dice NEXT. Per impostazione predefinita, questo comportamento è coerente con tutti gli emulatori vanilla, android e google. L'attributo scrollHorizontal non fa alcuna differenza. Il test null è importante perché la risposta dei telefoni agli inserimenti software viene lasciata al produttore e anche negli emulatori, gli emulatori di livello 16 alla vaniglia rispondono agli inserimenti soft lunghi in multi-line e scroll. Orizzontale EditTexts con un'azione ID di NEXT e un valore null l'evento.

Questa pagina descrive esattamente come farlo.

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

Imposta android: imeOptions, quindi controlla l' azioneId in onEditorAction. Quindi, se imposti imeOptions su 'actionDone', verifichi 'actionId == EditorInfo.IME_ACTION_DONE' in onEditorAction. Inoltre, assicurati di impostare Android: inputType.

Ecco il EditText dall'esempio collegato sopra:

<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" />

Puoi anche impostarlo a livello di codice usando la funzione setImeOptions (int) . Ecco OnEditorActionListener dall'esempio collegato sopra:

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

So che ha un anno, ma ho appena scoperto che funziona perfettamente per un EditText.

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

Previene tutto tranne il testo e lo spazio. Non ho potuto tab, "return" ("\ n") o altro.

Proprio come un addendum alla risposta di Chad (che ha funzionato quasi perfettamente per me), ho scoperto che dovevo aggiungere un controllo sul tipo di azione KeyEvent per impedire l'esecuzione del mio codice due volte (una volta sulla chiave e una volta sulla chiave evento).

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

Vedi http://developer.android.com/reference/android/view/KeyEvent.html per informazioni sulla ripetizione di eventi di azione (tenendo premuto il tasto Invio) ecc.

Avevo uno scopo simile. Volevo risolvere premendo il tasto "Invio" sulla tastiera (che volevo personalizzare) in un AutoCompleteTextView che estende TextView. Ho provato diverse soluzioni dall'alto e sembravano funzionare. MA ho riscontrato alcuni problemi quando ho cambiato il tipo di input sul mio dispositivo (Nexus 4 con AOKP ROM) da SwiftKey 3 (dove funzionava perfettamente) alla tastiera Android standard (dove invece di gestire il mio codice dall'ascoltatore, una nuova riga era inserito dopo aver premuto il tasto "Invio". Ho impiegato un po 'di tempo per gestire questo problema, ma non so se funzionerà in tutte le circostanze, indipendentemente dal tipo di input utilizzato.

Quindi ecco la mia soluzione:

Impostare l'attributo del tipo di input di TextView nel file XML su "testo":

android:inputType="text"

Personalizza l'etichetta del tasto "Invio" sulla tastiera:

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

Impostare un OnEditorActionListener su 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;
    }
});

Spero che questo possa aiutare gli altri a evitare i problemi che ho avuto, perché mi hanno quasi fatto impazzire.

Nel tuo XML, aggiungi l'attributo imeOptions a editText

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

Quindi, nel tuo codice Java, aggiungi OnEditorActionListener allo stesso 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;
        }
    });

Ecco la spiegazione: imeOptions = actionDone assegnerà "actionDone" a EnterKey. Il tasto Invio sulla tastiera cambierà da "Invio" a "Fine". Quindi quando si preme il tasto Invio, si innescherà questa azione e quindi la si gestirà.

Puoi anche farlo ..

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

Funziona molto bene per me
Inoltre nascondi tastiera

Innanzitutto, devi impostare EditText per ascoltare la pressione dei tasti

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

}

In secondo luogo, definire l'evento premendo il tasto, ad esempio, l'evento per impostare il testo di 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 infine, non dimenticare di importare in alto EditText, TextView, OnKeyListener, KeyEvent:

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

funziona perfettamente

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

        }
    });
}

}

funziona perfettamente

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" />

Questo dovrebbe funzionare

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

Digita questo codice nel tuo editor in modo che possa importare i moduli necessari.

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

Funziona bene su telefoni Android LG. Impedisce ENTERche altri caratteri speciali vengano interpretati come caratteri normali. Nexto il Donepulsante appare automaticamente e ENTERfunziona come previsto.

edit.setInputType(InputType.TYPE_CLASS_TEXT);

Ecco una semplice funzione statica che puoi inserire nella tua classe Utilso Keyboardsche eseguirà il codice quando l'utente preme il tasto Invio su una tastiera hardware o software. È una versione modificata dell'ottima risposta di @ earlcasper

 /**
 * 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;
        }
    };
}

InputType sul campo di testo deve essere textin ordine per ciò che CommonsWare ha detto di funzionare. Ho appena provato tutto questo, nessun inputType prima del processo e nulla ha funzionato, Enter ha continuato a registrarsi come soft enter. Dopo inputType = text, tutto compreso il setImeLabel ha funzionato.

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

Un modo affidabile per rispondere a un <enter> in un EditText è con un TextWatcher , un LocalBroadcastManager e un BroadcastReceiver . È necessario aggiungere la libreria di supporto v4 per utilizzare LocalBroadcastManager. Uso il tutorial su vogella.com : 7.3 "Eventi di trasmissione locali con LocalBroadcastManager" a causa del suo codice conciso completo Esempio. In onTextChanged before è l'indice della fine della modifica prima della modifica >; meno inizio. Quando nel TextWatcher il thread dell'interfaccia utente è occupato ad aggiornare editText è modificabile, quindi inviamo un Intento per riattivare BroadcastReceiver quando il thread dell'interfaccia utente ha terminato l'aggiornamento 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

Questa domanda non ha ancora ricevuto risposta con 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>

APP JAVA

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

Con Kotlin ho creato una funzione che gestisce tutti i tipi di azioni "fatte" per EditText, inclusa la tastiera, ed è possibile modificarlo e anche gestire altri tasti come desideri:

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

Quindi, esempio di utilizzo:

        editText.setOnDoneListener({
            //do something
        })

Per quanto riguarda la modifica dell'etichetta, penso che dipenda dall'app della tastiera e che di solito cambi solo in orizzontale, come scritto qui . Ad ogni modo, esempio di utilizzo per questo:

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

Oppure, se si desidera in XML:

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

E il risultato (mostrato in orizzontale):

Aggiungi questi depencendy e dovrebbe funzionare:

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

Questo ti darà una funzione richiamabile quando l'utente preme il tasto Invio.

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