wake-up-neo.net

Android - Handle "Enter" in einem EditText

Ich frage mich, ob es eine Möglichkeit gibt, mit dem Drücken des Benutzers umzugehen Enter während der Eingabe eines EditText, so etwas wie das onSubmit-HTML-Ereignis.

Ich frage mich auch, ob es eine Möglichkeit gibt, die virtuelle Tastatur so zu manipulieren, dass die Schaltfläche "Fertig" mit einer anderen Bezeichnung versehen ist (z. B. "Los") und beim Klicken eine bestimmte Aktion ausführt (erneut wie onSubmit).

426
Felix

Ich frage mich, ob es eine Möglichkeit gibt, mit dem Drücken des Benutzers umzugehen Enter Während Sie einen EditText eingeben, ähnelt dies dem onSubmit-HTML-Ereignis.

Ja.

Ich frage mich auch, ob es eine Möglichkeit gibt, die virtuelle Tastatur so zu manipulieren, dass die Schaltfläche "Fertig" mit einer anderen Bezeichnung versehen ist (z. B. "Los") und beim Klicken eine bestimmte Aktion ausführt (erneut wie onSubmit).

Auch ja.

Sie sollten die Attribute Android:imeActionId und Android:imeOptions sowie die Methode setOnEditorActionListener() auf TextView.

Verwenden Sie zum Ändern des Texts der Schaltfläche "Fertig" in eine benutzerdefinierte Zeichenfolge Folgendes:

_mEditText.setImeActionLabel("Custom text", KeyEvent.KEYCODE_ENTER);
_
355
CommonsWare
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;
    }
});
240
Jarod DY Law

Hier ist was du tust. Es ist auch im Android Entwickler-Beispielcode 'Bluetooth Chat' versteckt. Ersetzen Sie die fett gedruckten Teile mit der Aufschrift "Beispiel" durch Ihre eigenen Variablen und Methoden.

Importieren Sie zunächst das, was Sie benötigen, in die Hauptaktivität, in der die Zurück-Schaltfläche etwas Besonderes tun soll:

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

Erstellen Sie jetzt eine Variable vom Typ TextView.OnEditorActionListener für Ihren Return-Schlüssel (hier verwende ich exampleListener);

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

Dann müssen Sie dem Hörer zwei Dinge darüber mitteilen, was zu tun ist, wenn die Return-Taste gedrückt wird. Es muss wissen, um welchen EditText es sich handelt (hier verwende ich exampleView), und dann muss es wissen, was zu tun ist, wenn die Eingabetaste gedrückt wird (hier example_confirm ()). Wenn dies der letzte oder einzige Bearbeitungstext in Ihrer Aktivität ist, sollte dies dasselbe tun wie die onClick-Methode für die Schaltfläche Senden (oder OK, Bestätigen, Senden, Speichern usw.).

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

Stellen Sie abschließend den Listener ein (höchstwahrscheinlich in Ihrer onCreate-Methode).

exampleView.setOnEditorActionListener(exampleListener);
211
Chad Hedgcock

Hardwaretastaturen liefern immer Eingabeereignisse, Softwaretastaturen geben jedoch unterschiedliche Aktions-IDs und Nullen in singleLine EditTexts zurück. Dieser Code reagiert jedes Mal, wenn der Benutzer die Eingabetaste in einem EditText drückt, auf den dieser Listener eingestellt wurde, unabhängig von EditText oder Tastaturtyp.

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

Das Standardaussehen der Eingabetaste in singleLine = false gibt eine gebogene Pfeiltaste zur Eingabe an. Wenn singleLine = true im letzten EditText ist, steht auf dem Schlüssel DONE und in den EditTexts davor NEXT. Standardmäßig ist dieses Verhalten für alle Vanilla-, Android- und Google-Emulatoren gleich. Das scrollHorizontal-Attribut macht keinen Unterschied. Der Null-Test ist wichtig, da die Reaktion von Telefonen auf weiche Eingaben dem Hersteller überlassen bleibt und selbst in den Emulatoren die Vanilla Level 16-Emulatoren auf lange weiche Eingaben in mehrzeiligen und scrollHorizontal EditTexts mit einer actionId von NEXT und einer Null für reagieren das Ereignis.

34
earlcasper

Ich weiß, dass dies ein Jahr alt ist, aber ich habe gerade herausgefunden, dass dies perfekt für einen EditText funktioniert.

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

Es verhindert alles außer Text und Leerzeichen. Ich konnte nicht tab, "return" ("\ n") oder irgendetwas.

21
Newbie

Diese Seite beschreibt genau, wie das geht.

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

Setzen Sie das Android: imeOptions , dann überprüfen Sie einfach das actionId in onEditorAction. Wenn Sie also imeOptions auf 'actionDone' setzen, suchen Sie in onEditorAction nach 'actionId == EditorInfo.IME_ACTION_DONE'. Stellen Sie außerdem sicher, dass Android: inputType festgelegt ist.

Hier ist der EditText aus dem oben verlinkten Beispiel:

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

Sie können dies auch programmgesteuert mit der Funktion setImeOptions (int) einstellen. Hier ist der OnEditorActionListener aus dem oben verlinkten Beispiel:

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

Als Ergänzung zu Chad's Antwort (die für mich fast perfekt funktionierte) musste ich den Aktionstyp KeyEvent überprüfen, um zu verhindern, dass mein Code zweimal ausgeführt wird (einmal beim Hoch- und einmal beim Herunterfahren) Veranstaltung).

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

In http://developer.Android.com/reference/Android/view/KeyEvent.html finden Sie Informationen zum Wiederholen von Aktionsereignissen (Halten der Eingabetaste) usw.

16
kermitology

Ich hatte einen ähnlichen Zweck. Ich wollte das Drücken der Eingabetaste auf der Tastatur (die ich anpassen wollte) in einer AutoCompleteTextView auflösen, die TextView erweitert. Ich habe verschiedene Lösungen von oben ausprobiert und sie schienen zu funktionieren. ABER ich hatte einige Probleme, als ich den Eingabetyp auf meinem Gerät (Nexus 4 mit AOKP ROM) von SwiftKey 3 (wo es perfekt funktionierte) auf die Standardtastatur Android umstellte (wo ich meinen Code nicht über das handhabte) Zuhörer, nach dem Drücken der Eingabetaste wurde eine neue Zeile eingegeben. Ich habe eine Weile gebraucht, um dieses Problem zu beheben, aber ich weiß nicht, ob es unter allen Umständen funktioniert, unabhängig davon, welchen Eingabetyp Sie verwenden.

Also hier ist meine Lösung:

Setzen Sie das Eingabetyp-Attribut der TextView in der XML auf "text":

Android:inputType="text"

Passen Sie die Beschriftung der Eingabetaste auf der Tastatur an:

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

Legen Sie einen OnEditorActionListener für die Textansicht fest:

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

Ich hoffe, das kann anderen helfen, die Probleme zu vermeiden, die ich hatte, weil sie mich fast verrückt gemacht haben.

16
kaolick

Fügen Sie in Ihrer XML das Attribut imeOptions zum editText hinzu

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

Fügen Sie dann in Ihrem Java Code den OnEditorActionListener demselben EditText hinzu

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

Hier ist die Erklärung: Mit imeOptions = actionDone wird dem EnterKey "actionDone" zugewiesen. Der EnterKey auf der Tastatur ändert sich von "Enter" zu "Done". Wenn also die Eingabetaste gedrückt wird, wird diese Aktion ausgelöst und Sie werden damit fertig.

13
Akshayraj Kore

Sie können es auch tun ..

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;
        }
    });
8
Xar E Ahmer
     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;
        }
    });

Funktioniert sehr gut für mich
Außerdem Tastatur ausblenden

6
V. Kalyuzhnyu

funktioniert einwandfrei

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

        }
    });
}

}

funktioniert einwandfrei

5
Domi mtz

Zuerst müssen Sie EditText einstellen, um den Tastendruck zu hören

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

}

Definieren Sie zweitens das Ereignis beim Drücken der Taste, zum Beispiel das Ereignis, um den Text von TextView festzulegen:

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

}

Und schließlich vergessen Sie nicht, EditText, TextView, OnKeyListener, KeyEvent oben zu importieren:

import Android.view.KeyEvent;
import Android.view.View.OnKeyListener;
import Android.widget.EditText;
import Android.widget.TextView;
4
LifeiSHot
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" />
4
kreker

Das sollte funktionieren

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

Dies funktioniert problemlos auf LG Android Handys. Es verhindert, dass ENTER und andere Sonderzeichen als normale Zeichen interpretiert werden. Die Schaltfläche Next oder Done wird automatisch angezeigt und ENTER funktioniert wie erwartet.

edit.setInputType(InputType.TYPE_CLASS_TEXT);
3
Milan Švec

Hier ist eine einfache statische Funktion, die Sie in Ihre Klasse Utils oder Keyboards einfügen können, die Code ausführt, wenn der Benutzer die Eingabetaste auf einer Hardware- oder Softwaretastatur drückt. Es ist eine modifizierte Version der hervorragenden Antwort von @ 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;
        }
    };
}
2
JohnnyLambada
   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;
        }
    });
2
Brinda Rathod

Geben Sie diesen Code in Ihren Editor ein, damit er die erforderlichen Module importieren kann.

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

                // Put your function here ---!

                return true;

            }
            return false;
        }
    });
2
Sanjit Prasad

InputType im Textfeld muss text sein, damit CommonsWare funktioniert. Habe gerade alles ausprobiert, keinen inputType vor dem Test und nichts hat funktioniert, Enter hat sich weiterhin als soft enter registriert. Nach inputType = text funktionierte alles, einschließlich des setImeLabel.

Beispiel:Android:inputType="text"

2
Odaym

Eine zuverlässige Möglichkeit, auf ein <enter> in einem EditText zu antworten, sind ein TextWatcher , ein LocalBroadcastManager und ein BroadcastReceiver . Sie müssen die v4-Unterstützungsbibliothek hinzufügen, um den LocalBroadcastManager verwenden zu können. Ich benutze das Tutorial unter vogella.com : 7.3 "Lokale Broadcast-Ereignisse mit LocalBroadcastManager" wegen seines vollständigen, übersichtlichen Codebeispiels. In onTextChanged vor ist der Index des Endes der Änderung vor dem Wechsel>; minus Start. Wenn der Benutzeroberflächenthread im TextWatcher gerade mit dem Aktualisieren von editText beschäftigt ist, senden wir eine Absicht, den BroadcastReceiver zu aktivieren, wenn der Benutzeroberflächenthread mit dem Aktualisieren von editText fertig ist.

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
1
earlcasper

Diese Frage wurde mit Butterknife noch nicht beantwortet

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

Fügen Sie diese Abhängigkeit hinzu, und es sollte funktionieren:

import Android.view.KeyEvent;
import Android.view.View;
import Android.widget.EditText;
0
Jacky Supit