Android - Gérez «Entrer» dans un EditText

Je me demande s'il existe un moyen de gérer la pression de l'utilisateur Enterlors de la saisie d'un EditText, quelque chose comme l'événement HTML onSubmit.

Vous vous demandez également s'il existe un moyen de manipuler le clavier virtuel de telle sorte que le bouton "Terminé" soit étiqueté autre chose (par exemple "Go") et effectue une certaine action lorsque vous cliquez dessus (à nouveau, comme onSubmit).

Je me demande s'il existe un moyen de gérer la pression de l'utilisateur Enterlors de la saisie d'un EditText, quelque chose comme l'événement HTML onSubmit.

Oui.

Vous vous demandez également s'il existe un moyen de manipuler le clavier virtuel de telle sorte que le bouton "Terminé" soit étiqueté autre chose (par exemple "Go") et effectue une certaine action lorsque vous cliquez dessus (à nouveau, comme onSubmit).

Oui aussi.

Vous voudrez regarder les attributs android:imeActionIdet android:imeOptions, ainsi que la setOnEditorActionListener()méthode, tout cela TextView.

Pour changer le texte du bouton "Terminé" en une chaîne personnalisée, utilisez:

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

Voici ce que vous faites. Il est également masqué dans l'exemple de code du développeur Android «Bluetooth Chat». Remplacez les parties en gras qui disent "exemple" par vos propres variables et méthodes.

Tout d'abord, importez ce dont vous avez besoin dans l'activité principale où vous souhaitez que le bouton de retour fasse quelque chose de spécial:

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

Maintenant, créez une variable de type TextView.OnEditorActionListener pour votre clé de retour (ici j'utilise exampleListener );

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

Ensuite, vous devez dire à l'auditeur deux choses à faire lorsque vous appuyez sur le bouton de retour. Il doit savoir de quel EditText nous parlons (ici j'utilise exampleView ), puis il doit savoir quoi faire lorsque la touche Entrée est enfoncée (ici, example_confirm () ). S'il s'agit du dernier ou du seul EditText de votre activité, il doit faire la même chose que la méthode onClick pour votre bouton Soumettre (ou OK, Confirmer, Envoyer, Enregistrer, 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;
}

Enfin, définissez l'écouteur (très probablement dans votre méthode onCreate);

exampleView.setOnEditorActionListener(exampleListener);

Les claviers matériels génèrent toujours des événements d'entrée, mais les claviers logiciels renvoient des ID d'action et des valeurs NULL différents dans singleLine EditTexts. Ce code répond chaque fois que l'utilisateur appuie sur Entrée dans un EditText auquel cet écouteur a été défini, quel que soit EditText ou le type de clavier.

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'apparence par défaut de la touche Entrée dans singleLine = false donne une flèche courbée entrer le clavier. Lorsque singleLine = true dans le dernier EditText, la clé indique DONE, et sur les EditTexts avant elle, elle indique NEXT. Par défaut, ce comportement est cohérent sur tous les émulateurs vanilla, android et google. L'attribut scrollHorizontal ne fait aucune différence. Le test nul est important car la réponse des téléphones aux entrées logicielles est laissée au fabricant et même dans les émulateurs, les émulateurs vanille niveau 16 répondent aux longues entrées douces en plusieurs lignes et scrollHorizontal EditTexts avec un actionId de NEXT et un null pour l'événement.

Cette page décrit exactement comment procéder.

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

Définissez l' android: imeOptions, puis il vous suffit de vérifier l' actionId dans onEditorAction. Donc, si vous définissez imeOptions sur 'actionDone', vous vérifierez 'actionId == EditorInfo.IME_ACTION_DONE' dans onEditorAction. Assurez-vous également de définir l'androïde: inputType.

Voici le EditText de l'exemple lié ci-dessus:

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

Vous pouvez également définir cela par programmation à l'aide de la fonction setImeOptions (int) . Voici le OnEditorActionListener de l'exemple lié ci-dessus:

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

Je sais que cela a un an, mais je viens de découvrir que cela fonctionne parfaitement pour un EditText.

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

Il empêche tout sauf le texte et l'espace. Je ne pouvais pas tabuler, "retourner" ("\ n") ou quoi que ce soit.

Tout comme un addendum à la réponse du Tchad (qui a fonctionné presque parfaitement pour moi), j'ai trouvé que je devais ajouter une vérification sur le type d'action KeyEvent pour empêcher mon code de s'exécuter deux fois (une fois à la clé et une fois à la touche enfoncée) un événement).

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

Voir http://developer.android.com/reference/android/view/KeyEvent.html pour des informations sur la répétition des événements d'action (en maintenant la touche Entrée) etc.

J'avais un objectif similaire. Je voulais résoudre en appuyant sur la touche "Entrée" du clavier (que je voulais personnaliser) dans un AutoCompleteTextView qui étend TextView. J'ai essayé différentes solutions d'en haut et elles semblaient fonctionner. MAIS j'ai rencontré des problèmes lorsque j'ai changé le type d'entrée sur mon appareil (Nexus 4 avec AOKP ROM) de SwiftKey 3 (où cela fonctionnait parfaitement) au clavier Android standard (où au lieu de gérer mon code de l'auditeur, une nouvelle ligne était entré après avoir appuyé sur la touche "Entrée". Il m'a fallu un certain temps pour gérer ce problème, mais je ne sais pas si cela fonctionnera en toutes circonstances, quel que soit le type d'entrée que vous utilisez.

Voici donc ma solution:

Définissez l'attribut de type d'entrée de TextView dans le xml sur "texte":

android:inputType="text"

Personnalisez le libellé de la touche "Entrée" du clavier:

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

Définissez un OnEditorActionListener sur 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;
    }
});

J'espère que cela peut aider les autres à éviter les problèmes que j'ai eus, car ils m'ont presque rendu fou.

Dans votre xml, ajoutez l'attribut imeOptions à editText

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

Ensuite, dans votre code Java, ajoutez le OnEditorActionListener au même 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;
        }
    });

Voici l'explication: imeOptions = actionDone affectera "actionDone" à EnterKey. La touche EnterKey du clavier passera de "Enter" à "Done". Ainsi, lorsque la touche Entrée est enfoncée, elle déclenchera cette action et vous la manipulerez donc.

Vous pouvez aussi le faire ..

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

Fonctionne très bien pour moi
En plus masquer le clavier

Tout d'abord, vous devez définir EditText écouter la touche appuyez sur

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

}

Deuxièmement, définissez l'événement lorsque vous appuyez sur la touche, par exemple, événement pour définir le texte de 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;   

}

Et enfin, n'oubliez pas d'importer EditText, TextView, OnKeyListener, KeyEvent en haut:

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

fonctionne parfaitement

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

        }
    });
}

}

fonctionne parfaitement

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

Cela devrait fonctionner

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

Tapez ce code dans votre éditeur afin qu'il puisse importer les modules nécessaires.

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

Cela fonctionne très bien sur les téléphones LG Android. Il empêche les ENTERautres caractères spéciaux d'être interprétés comme des caractères normaux. Nextou le Donebouton apparaît automatiquement et ENTERfonctionne comme prévu.

edit.setInputType(InputType.TYPE_CLASS_TEXT);

Voici une fonction statique simple que vous pouvez lancer dans votre classe Utilsou Keyboardsqui exécutera du code lorsque l'utilisateur appuiera sur la touche retour d'un clavier matériel ou logiciel. C'est une version modifiée de l'excellente réponse de @ 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 sur le champ de texte doit être texten ordre pour que ce que CommonsWare dit fonctionner. Je viens d'essayer tout cela, aucun type d'entrée avant le procès et rien n'a fonctionné, Enter a continué à s'inscrire en tant que soft enter. Après inputType = text, tout, y compris le setImeLabel, a fonctionné.

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

Une manière fiable de répondre à un <enter> dans un EditText est avec un TextWatcher , un LocalBroadcastManager et un BroadcastReceiver . Vous devez ajouter la bibliothèque de support v4 pour utiliser LocalBroadcastManager. J'utilise le tutoriel sur vogella.com : 7.3 "Événements de diffusion locale avec LocalBroadcastManager" en raison de son exemple de code concis complet. Dans onTextChanged avant se trouve l'index de la fin de la modification avant la modification >; moins le début. Lorsque dans le TextWatcher, le thread d'interface utilisateur est occupé à mettre à jour modifiable de editText, nous envoyons donc une intention de réveiller le BroadcastReceiver lorsque le thread d'interface utilisateur a terminé la mise à jour de 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

Cette question n'a pas encore reçu de réponse avec 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;
}

En utilisant Kotlin, j'ai créé une fonction qui gère toutes sortes d'actions de type "terminé" pour EditText, y compris le clavier, et il est possible de le modifier et de gérer d'autres touches comme vous le souhaitez également:

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

Donc, exemple d'utilisation:

        editText.setOnDoneListener({
            //do something
        })

Quant au changement d'étiquette, je pense que cela dépend de l'application clavier, et qu'il ne change généralement que sur le paysage, comme écrit ici . Quoi qu'il en soit, un exemple d'utilisation pour cela:

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

Ou, si vous voulez en XML:

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

Et le résultat (montré en paysage):

Ajoutez ces dépendances, et cela devrait fonctionner:

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

Cela vous donnera une fonction appelable lorsque l'utilisateur appuie sur la touche de retour.

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

Usage

editText.setLineBreakListener {
    doSomething()
}