Android - Obsługa „Enter” w EditText

Zastanawiam się, czy istnieje sposób, aby poradzić sobie z naciśnięciem klawisza Enterpodczas wpisywania EditTextczegoś podobnego do zdarzenia HTML onSubmit.

Zastanawia mnie również, czy istnieje sposób na manipulowanie wirtualną klawiaturą w taki sposób, że przycisk „Gotowe” jest oznaczony czymś innym (na przykład „Idź”) i wykonuje określoną akcję po kliknięciu (ponownie, jak onSubmit).

Zastanawiam się, czy istnieje sposób, aby obsłużyć naciśnięcie użytkownika Enterpodczas pisania w EditText, coś takiego jak zdarzenie HTML onSubmit.

Tak.

Zastanawia mnie również, czy istnieje sposób na manipulowanie wirtualną klawiaturą w taki sposób, że przycisk „Gotowe” jest oznaczony czymś innym (na przykład „Idź”) i wykonuje określoną akcję po kliknięciu (ponownie, jak onSubmit).

Też tak.

Będziesz chciał przyjrzeć się atrybutom android:imeActionIdi android:imeOptions, a także setOnEditorActionListener()metodzie TextView.

Aby zmienić tekst przycisku „Gotowe” na niestandardowy ciąg, użyj:

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

Oto co robisz. Jest również ukryty w przykładowym kodzie programisty Androida „Czat Bluetooth”. Wymień pogrubione części z napisem „przykład” własnymi zmiennymi i metodami.

Najpierw zaimportuj to, czego potrzebujesz, do głównego działania, w którym chcesz, aby przycisk powrotu zrobił coś specjalnego:

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

Teraz utwórz zmienną typu TextView.OnEditorActionListener dla swojego klucza powrotu (tutaj używam exampleListener );

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

Następnie musisz powiedzieć słuchaczowi dwie rzeczy o tym, co zrobić po naciśnięciu przycisku powrotu. Musi wiedzieć, o czym jest EditText (tutaj używam exampleView ), a następnie musi wiedzieć, co zrobić, gdy zostanie naciśnięty klawisz Enter (tutaj, example_confirm () ). Jeśli jest to ostatni lub jedyny tekst EditText w Twojej aktywności, powinien on zrobić to samo, co metoda onClick dla przycisku Prześlij (lub OK, Potwierdź, Wyślij, Zapisz itp.).

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

Na koniec ustaw detektor (najprawdopodobniej w metodzie onCreate);

exampleView.setOnEditorActionListener(exampleListener);

Klawiatury sprzętowe zawsze dają zdarzenia enter, ale klawiatury programowe zwracają różne ID akcji i wartości zerowe w tekstach edycji SingleLine. Ten kod reaguje za każdym razem, gdy użytkownik naciśnie klawisz Enter w tekście EditText, dla którego ustawiony został ten detektor, niezależnie od tego, czy jest on edytowany, czy typ klawiatury.

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

Domyślny wygląd klawisza Enter w singleLine = false daje wygiętą strzałkę na klawiaturze. Kiedy singleLine = true w ostatnim EditText, klucz mówi GOTOWE, a na EditTexts przed nim NEXT. Domyślnie takie zachowanie jest spójne we wszystkich emulatorach waniliowych, androidowych i google. Atrybut scrollHorizontal nie robi żadnej różnicy. Test zerowy jest ważny, ponieważ odpowiedź telefonów na miękkie wejścia jest pozostawiona producentowi, a nawet w emulatorach, emulatory waniliowe poziomu 16 reagują na długie miękkie wejścia w wieloliniowych i przewijanych poziomych tekstach edycyjnych z działaniem Id NEXT i zerowe dla wydarzenie.

Ta strona opisuje dokładnie, jak to zrobić.

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

Ustaw Androida: imeOptions, a następnie po prostu sprawdź actionId w onEditorAction. Więc jeśli ustawisz imeOptions na „actionDone”, wtedy sprawdziłbyś „actionId == EditorInfo.IME_ACTION_DONE” w onEditorAction. Upewnij się również, czy ustawiłeś android: inputType.

Oto EditText z powyższego przykładu:

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

Możesz to również ustawić programowo za pomocą funkcji setImeOptions (int) . Oto OnEditorActionListener z powyższego przykładu:

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

Wiem, że to roczek, ale właśnie odkryłem, że działa idealnie dla EditText.

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

Zapobiega tylko tekstowi i spacji. Nie mogłem tabulować, „return” („\ n”) ani nic takiego.

Podobnie jak dodatek do odpowiedzi Chada (który działał prawie idealnie dla mnie), stwierdziłem, że muszę dodać kontrolę typu akcji KeyEvent, aby zapobiec dwukrotnemu wykonywaniu kodu (raz na klawiaturze i raz na klawiaturze) zdarzenie).

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

Widzieć http://developer.android.com/reference/android/view/KeyEvent.html, aby uzyskać informacje na temat powtarzania zdarzeń akcji (przytrzymanie klawisza Enter) itp.

Miałem podobny cel. Chciałem rozwiązać, naciskając klawisz „Enter” na klawiaturze (który chciałem dostosować) w AutoCompleteTextView, który rozszerza TextView. Próbowałem różnych rozwiązań z góry i wydawało się, że działają. ALE napotkałem pewne problemy, kiedy zmieniłem typ wejścia na moim urządzeniu (Nexus 4 z AOKP ROM) z SwiftKey 3 (gdzie działało idealnie) na standardową klawiaturę Android (gdzie zamiast obsługiwać mój kod od słuchacza, nowa linia była wszedł po naciśnięciu klawisza „Enter”. Zajęło mi trochę czasu, aby poradzić sobie z tym problemem, ale nie wiem, czy zadziała we wszystkich okolicznościach, bez względu na to, jakiego typu wejścia użyjesz.

Oto moje rozwiązanie:

Ustaw atrybut typu wejściowego TextView w pliku XML na „tekst”:

android:inputType="text"

Dostosuj etykietę klawisza „Enter” na klawiaturze:

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

Ustaw OnEditorActionListener na 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;
    }
});

Mam nadzieję, że pomoże to innym uniknąć problemów, które miałem, ponieważ prawie doprowadziły mnie do szału.

W swoim pliku xml dodaj atrybut imeOptions do editText

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

Następnie w kodzie Java dodaj OnEditorActionListener do tego samego 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;
        }
    });

Oto wyjaśnienie - ImeOptions = actionDone przypisze „actionDone” do EnterKey. Klawisz Enter na klawiaturze zmieni się z „Enter” na „Gotowe”. Tak więc, kiedy zostanie naciśnięty klawisz Enter, uruchomi to działanie i tym samym sobie z nim poradzisz.

Możesz to również zrobić ..

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

Działa dla mnie bardzo dobrze
Ponadto ukryj klawiaturę

Najpierw musisz ustawić opcję EditText nasłuchiwać naciśnięcia klawisza

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

}

Po drugie, zdefiniuj zdarzenie po naciśnięciu klawisza, na przykład zdarzenie, aby ustawić tekst 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;   

}

I na koniec, nie zapomnij zaimportować EditText, TextView, OnKeyListener, KeyEvent u góry:

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

działa idealnie

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

        }
    });
}

}

działa idealnie

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

To powinno działać

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

Wpisz ten kod w edytorze, aby mógł zaimportować niezbędne moduły.

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

Działa to dobrze na telefonach z Androidem LG. Zapobiega ENTERinterpretowaniu innych znaków specjalnych jako znaków normalnych. Nextlub Doneprzycisk pojawia się automatycznie i ENTERdziała zgodnie z oczekiwaniami.

edit.setInputType(InputType.TYPE_CLASS_TEXT);

Oto prosta funkcja statyczna, którą możesz wrzucić do swojej Utilslub Keyboardsklasy, która wykona kod, gdy użytkownik naciśnie klawisz powrotu na klawiaturze sprzętowej lub programowej. To zmodyfikowana wersja doskonałej odpowiedzi @ 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;
        }
    };
}

InputType w polu tekstowym musi być text, aby zadziałało to, co powiedział Commons Commons. Po prostu wypróbowałem to wszystko, bez inputType przed próbą i nic nie działało, Enter nadal rejestrował się jako soft enter. Potem inputType = textwszystko, łącznie z setImeLabel, działało.

Przykład: 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;
        }
    });

Niezawodnym sposobem odpowiedzi na <enter> w EditText jest TextWatcher , LocalBroadcastManager i BroadcastReceiver . Musisz dodać bibliotekę wsparcia v4, aby korzystać z LocalBroadcastManager. Korzystam z samouczka na stronie vogella.com : 7.3 „Lokalne transmisje z LocalBroadcastManager” z powodu pełnego zwięzłego kodu Przykład. W onTextChanged before jest indeks końca zmiany przed zmianą >; minus start. Gdy w TextWatcher wątek interfejsu użytkownika jest zajęty aktualizowaniem edytowalnego editText, więc wysyłamy zamiar wznowienia BroadcastReceiver, gdy wątek interfejsu użytkownika zakończy aktualizację 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

Na to pytanie nie ma jeszcze odpowiedzi w przypadku 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;
}

Korzystając z Kotlin, stworzyłem funkcję, która obsługuje wszystkie rodzaje „wykonanych” działań dla EditText, w tym klawiaturę, i można go modyfikować, a także obsługiwać inne klawisze, jak chcesz:

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

Przykładowe użycie:

        editText.setOnDoneListener({
            //do something
        })

Jeśli chodzi o zmianę etykiety, myślę, że zależy to od aplikacji na klawiaturze i zwykle zmienia się tylko w układzie poziomym, jak tutaj napisano . W każdym razie przykładowe użycie tego:

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

Lub, jeśli chcesz w XML:

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

A wynik (pokazany w układzie poziomym):

Dodaj te depencendy i powinno działać:

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

Umożliwi to wywołanie funkcji, gdy użytkownik naciśnie klawisz powrotu.

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

Stosowanie

editText.setLineBreakListener {
    doSomething()
}