Android EditText Löschen (Rücktaste) Schlüsselereignis

122

Wie kann ich ein Löschschlüsselereignis (Rücktaste) für einen editText erkennen? Ich habe versucht, TextWatcher zu verwenden, aber wenn der editText leer ist und ich die Entf-Taste drücke, passiert nichts. Ich möchte erkennen, dass die Löschtaste gegen einen editText gedrückt wird, auch wenn dieser keinen Text enthält.

Buda Gavril
quelle

Antworten:

172

HINWEIS: Funktioniert onKeyListenernicht für Softtastaturen.

Sie können einstellen , OnKeyListenerfür Sie , editTextso dass Sie eine beliebige Taste drücken erkennen kann
EDIT: Ein häufiger Fehler prüfen wir KeyEvent.KEYCODE_BACKfür backspace, aber eigentlich ist es KeyEvent.KEYCODE_DEL(wirklich diesen Namen sehr verwirrend!)

editText.setOnKeyListener(new OnKeyListener() {                 
    @Override
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        //You can identify which key pressed buy checking keyCode value with KeyEvent.KEYCODE_
        if(keyCode == KeyEvent.KEYCODE_DEL) {  
            //this is for backspace
        }
        return false;       
    }
});
Labeeb Panampullan
quelle
9
Ich habe es gerade versucht, aber onKeyListeners registrieren anscheinend keine Backspaces.
Stefs
3
Bei Softtastaturen funktioniert dies nicht. Dies funktioniert nur für Hardware-Eingaben.
Varundroid
6
Auf meinem Nexus4 (Lauf Lager KitKat) dies tut Arbeit für die Software - Tastatur.
Matthias
10
Also, wenn es nicht für Softkeys funktioniert, warum wird diese Antwort dann in / unter der Android-Plattform akzeptiert
?
32
Verwenden event.getAction() == KeyEvent.ACTION_DOWN && event.getKeyCode() == KeyEvent.KEYCODE_DELSie diese
Option,
83

Es ist schon eine Weile her, seit du gefragt hast, aber ich hatte nur das gleiche Problem. Wie bereits von Estel erwähnt, besteht das Problem bei Key Listenern darin, dass sie nur mit Hardwaretastaturen funktionieren. Um dies mit einer IME (Soft Keyboard) zu tun , ist die Lösung etwas ausgefeilter.

Die einzige Methode , die wir wirklich wollen , außer Kraft zu setzen ist sendKeyEventin dem EditText‚s - InputConnectionKlasse. Diese Methode wird aufgerufen, wenn Schlüsselereignisse in einem IME auftreten. Um dies zu überschreiben, müssen wir eine benutzerdefinierte Methode implementieren, EditTextdie die onCreateInputConnectionMethode überschreibt und das Standardobjekt InputConnectionin eine Proxy-Klasse einschließt! : |

Klingt kompliziert, aber hier ist das einfachste Beispiel, das ich erfinden könnte:

public class ZanyEditText extends EditText {

    private Random r = new Random();

    public ZanyEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public ZanyEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public ZanyEditText(Context context) {
        super(context);
    }

    public void setRandomBackgroundColor() {
        setBackgroundColor(Color.rgb(r.nextInt(256), r.nextInt(256), r
                .nextInt(256)));
    }

    @Override
    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
        return new ZanyInputConnection(super.onCreateInputConnection(outAttrs),
                true);
    }

    private class ZanyInputConnection extends InputConnectionWrapper {

        public ZanyInputConnection(InputConnection target, boolean mutable) {
            super(target, mutable);
        }

        @Override
        public boolean sendKeyEvent(KeyEvent event) {
            if (event.getAction() == KeyEvent.ACTION_DOWN
                    && event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                ZanyEditText.this.setRandomBackgroundColor();
                // Un-comment if you wish to cancel the backspace:
                // return false;
            }
            return super.sendKeyEvent(event);
        }

    }

}

In der Zeile mit dem Aufruf von setRandomBackgroundColorwird meine spezielle Rücktaste ausgeführt. In diesem Fall ändern Sie die EditTextHintergrundfarbe des.

Wenn Sie dies aus XML aufblasen, denken Sie daran, den vollständigen Paketnamen als Tag zu verwenden:

<cc.buttfu.test.ZanyEditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+id/somefield"
></cc.buttfu.test.ZanyEditText>
Idris
quelle
27
Ich bin kürzlich auf das gleiche Problem bei Jelly Bean gestoßen. Ich fand, dass diese Lösung meistens funktionierte, außer dass ich deleteSurroundingText (...) anstelle von sendKeyEvent (...) (das überhaupt nicht aufgerufen wurde) überschreiben musste. Hoffe das hilft jemand anderem!
Brandon
Diese Antwort, kombiniert mit dem obigen Kommentar von @Brandon, hat dies für mich zum Laufen gebracht. Was ich mich jetzt frage, ist, wie dies auf Geräten vor JellyBean funktioniert.
Christopher Perry
Es funktioniert mit der akzeptierten Antwort auf 2.2 und 2.3 Geräten für mich.
Christoph
Es scheint, als würde das Schlüsselereignis für die Rücktaste am 2.3. zweimal ausgelöst ...: /
Jeff,
25
Dies funktioniert nicht, wenn der Edittext leer ist. Gibt es Ideen, wie ein Ereignis für den Löschschlüssel abgerufen werden kann, wenn der Edittext leer ist und keinen Text enthält? 4.2
Rickster
69

Dies ist nur eine Ergänzung zu Idris 'Antwort und fügt die Überschreibung auch zu deleteSurroundingText hinzu. Weitere Informationen dazu habe ich hier gefunden: Android: Backspace in WebView / BaseInputConnection

package com.elavon.virtualmerchantmobile.utils;

import java.util.Random;

import android.content.Context;
import android.graphics.Color;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputConnectionWrapper;
import android.widget.EditText;

public class ZanyEditText extends EditText {

    private Random r = new Random();

    public ZanyEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public ZanyEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public ZanyEditText(Context context) {
        super(context);
    }

    public void setRandomBackgroundColor() {
        setBackgroundColor(Color.rgb(r.nextInt(256), r.nextInt(256), r
                .nextInt(256)));
    }

    @Override
    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
        return new ZanyInputConnection(super.onCreateInputConnection(outAttrs),
                true);
    }

    private class ZanyInputConnection extends InputConnectionWrapper {

        public ZanyInputConnection(InputConnection target, boolean mutable) {
            super(target, mutable);
        }

        @Override
        public boolean sendKeyEvent(KeyEvent event) {
            if (event.getAction() == KeyEvent.ACTION_DOWN
                    && event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                ZanyEditText.this.setRandomBackgroundColor();
                // Un-comment if you wish to cancel the backspace:
                // return false;
            }
            return super.sendKeyEvent(event);
        }


        @Override
        public boolean deleteSurroundingText(int beforeLength, int afterLength) {       
            // magic: in latest Android, deleteSurroundingText(1, 0) will be called for backspace
            if (beforeLength == 1 && afterLength == 0) {
                // backspace
                return sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))
                    && sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL));
            }

            return super.deleteSurroundingText(beforeLength, afterLength);
        }

    }

}
Jeff
quelle
3
Danke dir! Das deleteSurroundingTextbisschen war genau das, was ich brauchte, nachdem ich unzählige andere Lösungen ausprobiert hatte.
Adam Rosenfield
5
Diese Lösung hat bei früheren Android-Versionen sehr gut funktioniert, aber deleteSurroundingText wird leider nur aufgerufen, wenn Whitespace unter 4.4 (KitKat) entfernt wird. Ich habe sowohl auf Nexus4 als auch auf 7 getestet.
Dean
1
Es scheint, dass deleteSurroundingText erforderlich ist, wenn EditText mehrzeilig ist. Seltsam
Alex Sorokoletov
7
Vielen Dank, Mann, hat ohne deleteSurroundText nicht funktioniert. Android ist so zufällig, dass sie es in androm umbenennen sollten.
Torsten Ojaperv
2
Es funktioniert bei mir, aber ich kann keine Satzzeichen oder Leerzeichen mehr löschen!
Jaytj95
29

Hier ist meine einfache Lösung, die für alle APIs funktioniert:

private int previousLength;
private boolean backSpace;

// ...

@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
    previousLength = s.length();
}

@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
}

@Override
public void afterTextChanged(Editable s) {
    backSpace = previousLength > s.length();

    if (backSpace) {

        // do your stuff ...

    } 
}

UPDATE 17.04.18 .
Wie in den Kommentaren erwähnt, verfolgt diese Lösung die Rücktaste nicht, wenn EditText leer ist (wie die meisten anderen Lösungen).
Für die meisten Anwendungsfälle reicht dies jedoch aus.
PS Wenn ich heute etwas Ähnliches schaffen müsste, würde ich Folgendes tun:

public abstract class TextWatcherExtended implements TextWatcher {

    private int lastLength;

    public abstract void afterTextChanged(Editable s, boolean backSpace);

    @Override
    public void beforeTextChanged(CharSequence s, int start, int count, int after) {
        lastLength = s.length();
    }

    @Override
    public void afterTextChanged(Editable s) {
        afterTextChanged(s, lastLength > s.length());
    }  
}

Dann verwenden Sie es einfach als normalen TextWatcher:

 editText.addTextChangedListener(new TextWatcherExtended() {
        @Override
        public void afterTextChanged(Editable s, boolean backSpace) {
           // Here you are! You got missing "backSpace" flag
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) {
            // Do something useful if you wish.
            // Or override it in TextWatcherExtended class if want to avoid it here 
        }
    });
Leo Droidcoder
quelle
Nur was ich brauche! Danke dir!
DH28
9
Der TextWatcher wird bei einem leeren EditText nicht ausgelöst
Dan Neacșu
@ Leo Droidcoder habe ich in einer ähnlichen Lösung verwendet. Klar, prägnant und funktioniert perfekt ... Prost.
AJW
Dieser Algorithmus hat einen Fehler, als ob Sie nach der Eingabe auf die Leertaste klicken, dann ist die vorherige Länge größer als die Länge
Marcin S.
2
Funktioniert, solange Sie keine Auswahl verwenden (automatische Vervollständigung)
Javatar
13

Ich habe 2 Tage geschickt, um eine Lösung zu finden, und ich habe eine funktionierende gefunden :) (auf Softkeys)

public TextWatcher textWatcher = new TextWatcher() {
@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 (count == 0) {
        //Put your code here.
        //Runs when delete/backspace pressed on soft key (tested on htc m8)
        //You can use EditText.getText().length() to make if statements here
        }
    }

@Override
    public void afterTextChanged(Editable s) {
    }
}

Nachdem Sie den Textwatcher zu Ihrem EditText hinzugefügt haben:

yourEditText.addTextChangedListener(textWatcher);

Ich hoffe, es funktioniert auch auf anderen Android-Geräten (Samsung, LG usw.).

JP
quelle
Gerät HTC Wunsch (HTC ist jedoch üblich :-P)
Junaid
Wenn Sie einen Leerraum
eingeben,
Geniale Antwort Nr. 1, Bruder :)
Gundu Bandgar
6
Das funktioniert überhaupt nicht. count == 0 ist nur, wenn edittext leer ist!
Leo Droidcoder
@MarcAlexander Ich bin nicht sicher über diese Antwort, aber Sie können meine Lösung in der Antwort oben überprüfen
Leo Droidcoder
5

Meine einfache Lösung, die perfekt funktioniert. Sie sollten eine Flagge hinzufügen. Mein Code-Snippet:

editText.addTextChangedListener(new TextWatcher() {
        @Override
        public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            if (after < count) {
                isBackspaceClicked = true;
            } else {
                isBackspaceClicked = false;
            }
        }

        @Override
        public void onTextChanged(CharSequence s, int start, int before, int count) { }

        @Override
        public void afterTextChanged(Editable s) {
            if (!isBackspaceClicked) {
                // Your current code
            } else {
                // Your "backspace" handling
            }
        }
Max Zonov
quelle
textChangeListner hat EmptTextview nie aufgerufen.
Janardhan R
3

Beispiel für die Erstellung von EditText mit TextWatcher

EditText someEdit=new EditText(this);
//create TextWatcher for our EditText
TextWatcher1 TW1 = new TextWatcher1(someEdit);
//apply our TextWatcher to EditText
        someEdit.addTextChangedListener(TW1);

benutzerdefinierter TextWatcher

public class TextWatcher1 implements TextWatcher {
        public EditText editText;
//constructor
        public TextWatcher1(EditText et){
            super();
            editText = et;
//Code for monitoring keystrokes
            editText.setOnKeyListener(new View.OnKeyListener() {
                @Override
                public boolean onKey(View v, int keyCode, KeyEvent event) {
                    if(keyCode == KeyEvent.KEYCODE_DEL){
                        editText.setText("");
                    }
                        return false;
                }
            });
        }
//Some manipulation with text
        public void afterTextChanged(Editable s) {
            if(editText.getText().length() == 12){
                editText.setText(editText.getText().delete(editText.getText().length() - 1, editText.getText().length()));
                editText.setSelection(editText.getText().toString().length());
            }
            if (editText.getText().length()==2||editText.getText().length()==5||editText.getText().length()==8){
                editText.setText(editText.getText()+"/");
                editText.setSelection(editText.getText().toString().length());
            }
        }
        public void beforeTextChanged(CharSequence s, int start, int count, int after){
        }
        public void onTextChanged(CharSequence s, int start, int before, int count) {



        }
    }
Alex Bigalo
quelle
1

für jemanden, der Kotlin benutzt

addOnTextChanged ist nicht flexibel genug , um einige Fälle zu behandeln (z. B .: Erkennen, ob der Benutzer die Entf- Taste drückt, wenn der Text leer war)

setOnkeyListenerfunktionierte sogar Softtastatur oder Hardkeyboard! aber nur auf einigen Geräten . In meinem Fall funktioniert es auf Samsung s8, aber nicht auf Xiaomi mi8 se.

Wenn Sie Kotlin verwenden, können Sie die Crossline-Funktion verwenden. Dies ist doOnTextChangeddasselbe wie, addOnTextChangedaber der Rückruf wird ausgelöst, selbst wenn der Bearbeitungstext leer war.

HINWEIS: doOnTextChanged ist Teil der Android KTX-Bibliothek

Mạnh Hoàng Huynh
quelle
2
Sie könnten wahrscheinlich angeben, dass die doOnTextChanged Erweiterungsfunktion in der Android KTX-Bibliothek verfügbar ist
Stein
2
Es scheint jedoch, dass der Rückruf NICHT "ausgelöst wird, selbst wenn der Bearbeitungstext leer war". Könnten Sie bitte ein Snippet mit dem Löschen (Rücktaste) für leer bereitstellen EditText? Vielen Dank im Voraus
Stein
1
Ah, ich habe es getestet, wenn ich ein Projekt entwickle. In meinem Fall ist auf xiaomi mi8se, wenn edittext leer ist und Sie Löschen drücken, kein Rückruf ausgelöst. Ich werde nach einem Ausschnitt für diesen Satz suchen.
Mạnh Hoàng Huynh
0

Es gibt eine ähnliche Frage im Stackoverflow. Sie müssen überschreiben EditText, um Zugriff auf ein InputConnectionObjekt zu erhalten, das eine deleteSurroundingTextMethode enthält . Es wird Ihnen helfen, ein Löschereignis (Rücktaste) zu erkennen. Bitte werfen Sie einen Blick auf eine Lösung, die ich dort für Android bereitgestellt habe - Rücktaste nicht erfassen / Löschen in Soft drücken. Tastatur

Ayaz Alifov
quelle
0

Das scheint für mich zu funktionieren:

public void onTextChanged(CharSequence s, int start, int before, int count) {
    if (before - count == 1) {
        onBackSpace();
    } else if (s.subSequence(start, start + count).toString().equals("\n")) {
        onNewLine();
    }
}
rocker99
quelle
0

Ich habe auch das gleiche Problem in Dialog .. weil ich setOnKeyListener verwende .. Aber ich setze Standard return true. Nach Änderung wie unten Code funktioniert es gut für mich ..

    mDialog.setOnKeyListener(new Dialog.OnKeyListener() {

        @Override
        public boolean onKey(DialogInterface arg0, int keyCode,
                             KeyEvent event) {
            if (keyCode == KeyEvent.KEYCODE_BACK) {
                mDialog.dismiss();
                return true;
            }
            return false;//this line is important 

        }
    });
Ranjith Kumar
quelle
0

Basierend auf @Jiff ist ZanyEditTexthier WiseEditTextmitsetSoftKeyListener(OnKeyListener)

package com.locopixel.seagame.ui.custom;

import java.util.Random;

import android.content.Context;
import android.graphics.Color;
import android.support.v7.widget.AppCompatEditText;
import android.util.AttributeSet;
import android.view.KeyEvent;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputConnectionWrapper;

public class WiseEditText extends AppCompatEditText {

    private Random r = new Random();
    private OnKeyListener keyListener;

    public WiseEditText(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    public WiseEditText(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public WiseEditText(Context context) {
        super(context);
    }

    @Override
    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
        return new MyInputConnection(super.onCreateInputConnection(outAttrs),
                true);
    }

    private class MyInputConnection extends InputConnectionWrapper {

        public MyInputConnection(InputConnection target, boolean mutable) {
            super(target, mutable);
        }

        @Override
        public boolean sendKeyEvent(KeyEvent event) {
            if (keyListener != null) {
                keyListener.onKey(WiseEditText.this,event.getKeyCode(),event);
            }
            return super.sendKeyEvent(event);
        }

        @Override
        public boolean deleteSurroundingText(int beforeLength, int afterLength) {       
            // magic: in latest Android, deleteSurroundingText(1, 0) will be called for backspace
            if (beforeLength == 1 && afterLength == 0) {
                // backspace
                return sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))
                    && sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL));
            }

            return super.deleteSurroundingText(beforeLength, afterLength);
        }

    }

    public void setSoftKeyListener(OnKeyListener listener){
        keyListener = listener;
    }

}
Qamar
quelle
Es wird zweimal für jedes Löschschlüsselereignis aufgerufen.
Pankaj Kumar
0

Mein Problem war, dass ich benutzerdefinierte hatte Textwatcher, also wollte ich nicht zu einem hinzufügen OnKeyListener, EditTextund ich wollte keine benutzerdefinierten erstellen EditText. Ich wollte erkennen, ob die Rücktaste in meinem gedrückt wurdeafterTextChanged Methode die , daher sollte ich mein Ereignis nicht auslösen.

So habe ich das gelöst. Hoffe es wäre hilfreich für jemanden.

public class CustomTextWatcher extends AfterTextChangedTextWatcher {

private boolean backspacePressed;

@Override
public void afterTextChanged(Editable s) {
    if (!backspacePressed) {
        triggerYourEvent();
    }
}

@Override
public void onTextChanged(CharSequence s, int start, int before, int count) {
    super.onTextChanged(s, start, before, count);
    backspacePressed = count == 0; //if count == 0, backspace is pressed
}
}
Dmitry Smolyaninov
quelle
0

Ich habe @ Jeffs Lösung auf Version 4.2, 4.4, 6.0 getestet. Unter 4.2 und 6.0 funktioniert es gut. Aber auf 4.4 funktioniert es nicht.

Ich habe einen einfachen Weg gefunden, um dieses Problem zu umgehen. Der entscheidende Punkt ist, zu Beginn ein unsichtbares Zeichen in den Inhalt von EditText einzufügen und den Benutzer den Cursor nicht vor diesem Zeichen bewegen zu lassen. Ich füge ein Leerzeichen mit einem ImageSpan mit einer Breite von Null ein. Hier ist mein Code.

                @Override
                public void afterTextChanged(Editable s) {
                    String ss = s.toString();
                    if (!ss.startsWith(" ")) {
                        int selection = holder.editText.getSelectionEnd();
                        s.insert(0, " ");
                        ss = s.toString();
                        holder.editText.setSelection(selection + 1);
                    }
                    if (ss.startsWith(" ")) {
                        ImageSpan[] spans = s.getSpans(0, 1, ImageSpan.class);
                        if (spans == null || spans.length == 0) {
                            s.setSpan(new ImageSpan(getResources().getDrawable(R.drawable.zero_wdith_drawable)), 0 , 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                        }
                    }
                }

Und wir brauchen einen benutzerdefinierten EditText, der einen SelectionChangeListener hat

public class EditTextSelectable extends android.support.v7.widget.AppCompatEditText {
public interface OnSelectChangeListener {
    void onSelectChange(int start, int end);
}

private OnSelectChangeListener mListener;

public void setListener(OnSelectChangeListener listener) {
    mListener = listener;
}

...constructors...

@Override
protected void onSelectionChanged(int selStart, int selEnd) {
    if (mListener != null) {
        mListener.onSelectChange(selStart, selEnd);
    }
    super.onSelectionChanged(selStart, selEnd);
}

}}

Und der letzte Schritt

holder.editText.setListener(new EditTextSelectable.OnSelectChangeListener() {
                @Override
                public void onSelectChange(int start, int end) {
                    if (start == 0 && holder.editText.getText().length() != 0) {
                        holder.editText.setSelection(1, Math.max(1, end));
                    }
                }
            });

Und jetzt sind wir fertig ~ Wir können das Backspace-Schlüsselereignis erkennen, wenn EditText keinen tatsächlichen Inhalt hat und der Benutzer nichts über unseren Trick weiß.

Passantwhu
quelle
0

Diese Frage mag alt sein, aber die Antwort ist mit einem TextWatcher wirklich einfach.

int lastSize=0;
@Override
public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {
    //2. compare the old length of the text with the new one
    //3. if the length is shorter, then backspace was clicked
    if (lastSize > charSequence.length()) {
        //4. Backspace was clicked
        //5. perform action
    }
    //1. get the current length of of the text
    lastSize = charSequence.length();
}
BluRe.CN
quelle
Ähnlich wie bei früheren Lösungen kann dies durch automatische Vervollständigung / Vorschläge ausgelöst werden.
Stonz2
0

Ich habe eine wirklich einfache Lösung gefunden, die mit einer weichen Tastatur funktioniert.

override fun onTextChanged(text: CharSequence?, start: Int, before: Int, count: Int) {
    text?.let { 
        if(count < before) {
            Toast.makeText(context, "backspace pressed", Toast.LENGTH_SHORT).show()
            // implement your own code
        }
    }
}
Hawklike
quelle
-3

Sie können einen Schlüssel-Listener für die Aktivität festlegen und in der Rückrufmethode ermitteln, welche Taste der Benutzer gedrückt hat. Der folgende Code dient als Referenz. Ich hoffe es hilft.

//after user hits keys, this method would be called.
public boolean onKeyUp(int keyCode, KeyEvent event) {
        if (editText.isFocused()) {
            switch (keyCode) {
            case KeyEvent.KEYCODE_DEL:  //delete key
                Log.i("INFO", "delete key hit"); //you should see this log in ddms after you hit delete key
                break;
            }
        }
        return super.onKeyUp(keyCode, event);
    }
Huang
quelle
Diese Lösung wurde überprüft - KEYCODE_DEL wird nur dann in die Aktivität versetzt, wenn der Bearbeitungstext dies nicht alleine erledigt. Zum Beispiel, wenn in editText kein Text oder Text vorhanden ist, der Cursor jedoch ganz am Anfang steht. Das ist lustig, dass ich in meinem Fall genau dieses Verhalten brauche
Anton Kizema
In meiner Aktivität gibt es keinen EditText und ich lasse die Tastatur nur programmgesteuert erscheinen. Ich muss jede Softtastatur abfangen und dies scheint die einzig funktionierende Lösung zu sein. Der andere überschreibt die dispatchKeyEvent-Methode. Leider sendet der IME ab JellyBean kein KeyEvent für den DELETE-Schlüssel. developer.android.com/reference/android/view/KeyEvent.html
Bemipefe