Sự kiện chính xóa Android EditText (xóa lùi)

Làm cách nào tôi có thể phát hiện sự kiện khóa xóa (xóa lùi) cho một Văn bản chỉnh sửa? Tôi đã thử sử dụng TextWatcher, nhưng khi editText trống, khi tôi nhấn phím xóa, không có gì xảy ra. Tôi muốn phát hiện phím xóa khi nhấn vào một EditText ngay cả khi nó không có văn bản.

GHI CHÚ: onKeyListener không hoạt động đối với bàn phím mềm.

Bạn có thể thiết lập OnKeyListenercho bạn editTextđể bạn có thể phát hiện bất kỳ phím bấm
EDIT: Một sai lầm phổ biến chúng ta đang kiểm tra KeyEvent.KEYCODE_BACKcho backspace, nhưng thực sự nó là KeyEvent.KEYCODE_DEL(Really rằng tên rất khó hiểu!)

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

Bạn hỏi đã lâu rồi nhưng tôi cũng gặp vấn đề tương tự. Như đã được Estel đề cập, vấn đề với những người nghe chính là chúng chỉ hoạt động với bàn phím phần cứng. Để thực hiện việc này với IME (bàn phím mềm) , giải pháp phức tạp hơn một chút.

Các phương pháp duy nhất chúng tôi thực sự muốn ghi đè là sendKeyEventtrong EditText's InputConnectionlớp. Phương thức này được gọi khi các sự kiện chính xảy ra trong IME. Nhưng để ghi đè điều này, chúng ta cần triển khai một tùy chỉnh EditTextghi đè onCreateInputConnectionphương thức, gói InputConnectionđối tượng mặc định trong một lớp proxy! : |

Nghe có vẻ phức tạp, nhưng đây là ví dụ đơn giản nhất mà tôi có thể tạo ra:

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

    }

}

Dòng có lệnh gọi đến setRandomBackgroundColorlà nơi xảy ra hành động xóa lùi đặc biệt của tôi. Trong trường hợp này, việc thay đổiEditText màu nền của.

Nếu bạn đang thổi phồng điều này từ XML, hãy nhớ sử dụng tên gói đầy đủ làm thẻ:

<cc.buttfu.test.ZanyEditText
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:id="@+id/somefield"
></cc.buttfu.test.ZanyEditText>

Đây chỉ là một bổ sung cho câu trả lời của Idris, thêm vào ghi đè lên deleteSurroundingText. Tôi đã tìm thấy thêm thông tin về điều đó tại đây: Android: Backspace trong 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);
        }

    }

}

Đây là giải pháp dễ dàng của tôi, phù hợp với tất cả các API:

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

    } 
}

CẬP NHẬT 17.04.18 .
Như đã chỉ ra trong các nhận xét, giải pháp này không theo dõi báo chí xóa lùi nếu EditText trống (giống như hầu hết các giải pháp khác).
Tuy nhiên, nó đủ cho hầu hết các trường hợp sử dụng.
Tái bút: Nếu tôi phải tạo ra thứ gì đó tương tự ngày hôm nay, tôi sẽ làm:

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

Sau đó, chỉ cần sử dụng nó như một TextWatcher thông thường:

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

Tôi đã gửi 2 ngày để tìm giải pháp và tôi đã tìm ra giải pháp hoạt động :) (trên phím mềm)

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

Sau khi thêm textwatcher vào EditText của bạn:

yourEditText.addTextChangedListener(textWatcher);

Tôi hy vọng nó cũng hoạt động trên các thiết bị Android khác (samsung, LG, v.v.).

Giải pháp đơn giản của tôi mà hoạt động hoàn hảo. Bạn nên thêm một lá cờ. Đoạn mã của tôi:

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

Ví dụ về cách tạo EditText với TextWatcher

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

TextWatcher tùy chỉnh

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) {



        }
    }

cho một số người đang sử dụng Kotlin

addOnTextChanged không linh hoạt nên không thể xử lý một số trường hợp (ví dụ: phát hiện nếu người dùng nhấn xóa khi văn bản chỉnh sửa trống)

setOnkeyListenerhoạt động ngay cả bàn phím mềm hoặc bàn phím cứng! nhưng chỉ trên một số thiết bị . Trong trường hợp của tôi, nó hoạt động trên Samsung s8 nhưng không hoạt động trên Xiaomi mi8 se.

nếu bạn sử dụng kotlin, bạn có thể sử dụng hàm crossline doOnTextChanged , nó giống như addOnTextChangednhưng gọi lại được kích hoạt ngay cả khi văn bản chỉnh sửa bị trống.

LƯU Ý: doOnTextChanged là một phần của thư viện KTX Android

Có một câu hỏi tương tự trong Stackoverflow. Bạn cần ghi đè EditTextđể có quyền truy cập vào InputConnectionđối tượng chứa deleteSurroundingTextphương thức. Nó sẽ giúp bạn phát hiện sự kiện xóa (xóa lùi). Làm ơn, hãy xem một giải pháp mà tôi đã cung cấp ở đó Android - không thể chụp phím xóa lùi / xóa bằng cách nhấn mềm. bàn phím

Điều này dường như đang làm việc cho tôi:

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

Tôi cũng gặp phải vấn đề tương tự trong Dialog .. bởi vì tôi đang sử dụng setOnKeyListener .. Nhưng tôi đặt giá trị trả về mặc định là true. Sau khi thay đổi như mã dưới đây, nó hoạt động tốt cho tôi ..

    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 

        }
    });

Dựa trên @Jiff ZanyEditTextở đây là WiseEditTextvớisetSoftKeyListener(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;
    }

}

Vấn đề của tôi là tôi có tùy chỉnh Textwatcher, vì vậy tôi không muốn thêm OnKeyListenervào EditTextcũng như không muốn tạo tùy chỉnh EditText. Tôi muốn phát hiện xem phím xóa lùi có được nhấn trongafterTextChanged phương thức , vì vậy tôi không nên kích hoạt sự kiện của mình.

Đây là cách tôi giải quyết vấn đề này. Hy vọng nó sẽ hữu ích cho ai đó.

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

Tôi đã thử nghiệm giải pháp của @ Jeff trên phiên bản 4.2, 4.4, 6.0. Trên 4.2 và 6.0, nó hoạt động tốt. Nhưng trên 4.4, nó không hoạt động.

Tôi đã tìm thấy một cách dễ dàng để giải quyết vấn đề này. Điểm mấu chốt là chèn một ký tự ẩn vào nội dung của EditText ngay từ đầu và không để người dùng di chuyển con trỏ trước ký tự này. Cách của tôi là chèn một ký tự khoảng trắng với ImageSpan of Zero Width trên đó. Đây là mã của tôi.

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

Và chúng tôi cần tùy chỉnh một EditText có SelectionChangeListener

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

}

Và bước cuối cùng

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

Và bây giờ, chúng tôi đã hoàn tất ~ Chúng tôi có thể phát hiện sự kiện khóa xóa lùi khi EditText không có nội dung thực tế và người dùng sẽ không biết gì về thủ thuật của chúng tôi.

Câu hỏi này có thể cũ nhưng câu trả lời thực sự đơn giản bằng cách sử dụng TextWatcher.

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

Tôi đã tìm thấy một giải pháp thực sự đơn giản hoạt động với bàn phím mềm.

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

Bạn có thể đặt một người nghe chính trên hoạt động và trong phương pháp gọi lại, bạn có thể phát hiện người dùng đã nhấn phím nào. Đoạn mã dưới đây là để bạn tham khảo. Hy vọng nó giúp.

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