how to get which character is get deleted on backspace in android

Question

I am working with android 2.2.

How to know which character is get deleted on backspace when editing text in custom auto complete in android.

public boolean onKeyUp(int keyCode,KeyEvent msg){  
     if(keyCode == KeyEvent.KEYCODE_DEL)
     {
        // how to find here which character is get deleted
     }
     return false;
}

Bob · Accepted Answer · 2013-01-05T07:51:13.723

2

String prevText = "";
public boolean onKeyUp(int keyCode,KeyEvent msg){  

     if(keyCode == KeyEvent.KEYCODE_DEL)
     {
        int pos = myEditText.getSelectionStart();
        char c = prevText.charAt(pos);
        // c is deleted
     }
     prevText = myEditText.getText.toString();
     return false;
}

edited Jan 05 '13 at 07:51

answered Jan 05 '13 at 07:45

Bob

22,810
38
143
225

one more query for this ques. How to find color code of character which is get deleted on backspace. – Smily Jan 07 '13 at 10:56

score 1 · Answer 2 · answered Jan 05 '13 at 07:35

1

You can use add a TextWatcher to AutoCompleteTextView with addTextChangeListener(TextWatcher).

You don't need to listen to onKeyUp() the various TextWatcher methods inform you if the user is adding or removing text.

answered Jan 05 '13 at 07:35

Sam

86,580
20
181
179

score 1 · Answer 3 · answered Jan 05 '13 at 07:36

The easiest way is just keep last character that you type

int lastKeyCode;
public boolean onKeyUp(int keyCode,KeyEvent msg){  
     if(keyCode == KeyEvent.KEYCODE_DEL)
     {
        // print lastKeyCode here
        // how to find here which character is get deleted
     }
     lastKeyCode = keyCode;
     return false;
}

score 1 · Answer 4 · answered Mar 14 '18 at 10:19

Try this, working for me

editText.addTextChangedListener(new TextWatcher() {
        String initialChar = null;
        int initCursorPosition = 0;

        @Override
        public void onTextChanged(CharSequence charSequence, int start, int before, int after) {
                char addedChar = 0;

                int finalCursorPosition = editText.getSelectionStart();
                if (finalCursorPosition - initCursorPosition > 0) {
                    addedChar = charSequence.charAt(finalCursorPosition - 1);
                    Log.d(TAG, "onTextChanged added: " + addedChar);
                   //added char

                } else {
                    char delChar = initialChar.charAt(initCursorPosition - 1);
                   Log.d(TAG, "onTextChanged deletedChar: " + delChar);
                   //deleted char
                }

        }

        @Override
        public void beforeTextChanged(CharSequence charSequence, int start, int before, int after) {
            Log.d(TAG, "textChange beforeTextChanged: " + charSequence);
            Log.d(TAG, "textChange cursorPosition: " + editText.getSelectionStart());
            initialChar = String.valueOf(charSequence);
            initCursorPosition = editText.getSelectionStart();
        }

        @Override
        public void afterTextChanged(Editable arg0) {
        }
    });

score 0 · Answer 5 · edited Jan 07 '13 at 11:39

(Edittext).setOnKeyListener(new OnKeyListener()
{
    public boolean onKey(View v, int keyCode, KeyEvent event)
        {
            if(event.getKeyCode()==67)
            {
                if((EditText).getText().toString().length()>0)
                {
                               int pos = (Edittext).getSelectionStart();
                               Char c = (EditText).getText().toString.charAt(pos);
       Toast.makeText(getApplicationontext(),String.valueOf(c),Toast.LENGTH_SHORT).show();
                }
        }   
            return false;
        }
    });

I think it helps you

score 0 · Answer 6 · answered Oct 26 '21 at 04:51

I know this is a very late answer, but this would be effective for future users.

First the KeyEvent.KEYCODE_DEL doesn't work for soft keyboard in latest android versions, so you have to create a custom EditText to handle that.

So we'll create a class to handle all null type in LatinIME

import android.text.SpannableStringBuilder;

public class EditableAccomodatingLatinIMETypeNullIssues extends SpannableStringBuilder {
    EditableAccomodatingLatinIMETypeNullIssues(CharSequence source) {
        super(source);
    }

    public static CharSequence ONE_UNPROCESSED_CHARACTER = "/";

    @Override
    public SpannableStringBuilder replace(final int
                                                  spannableStringStart, final int spannableStringEnd, CharSequence replacementSequence,
                                          int replacementStart, int replacementEnd) {
        if (replacementEnd > replacementStart) {
            super.replace(0, length(), "", 0, 0);

            return super.replace(0, 0, replacementSequence, replacementStart, replacementEnd);
        }
        else if (spannableStringEnd > spannableStringStart) {
            super.replace(0, length(), "", 0, 0);

            return super.replace(0, 0, ONE_UNPROCESSED_CHARACTER, 0, 1);
        }

        return super.replace(spannableStringStart, spannableStringEnd,
                replacementSequence, replacementStart, replacementEnd);
    }
}

Then we'll go ahead to create another class to handle the InputConnection of the custom EditText to be created

import android.os.Build;
import android.text.Editable;
import android.text.Selection;
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.BaseInputConnection;

public class InputConnectionAccomodatingLatinIMETypeNullIssues extends BaseInputConnection {

    Editable myEditable = null;

    public InputConnectionAccomodatingLatinIMETypeNullIssues(View targetView, boolean fullEditor) {
        super(targetView, fullEditor);
    }
    @Override
    public Editable getEditable() {
        if(Build.VERSION.SDK_INT >= 14) {
            if(myEditable == null) {
                myEditable = new EditableAccomodatingLatinIMETypeNullIssues(
                        EditableAccomodatingLatinIMETypeNullIssues.ONE_UNPROCESSED_CHARACTER);
                Selection.setSelection(myEditable, 1);
            }
            else {
                int myEditableLength = myEditable.length();
                if(myEditableLength == 0) {
                    myEditable.append(
                            EditableAccomodatingLatinIMETypeNullIssues.ONE_UNPROCESSED_CHARACTER);
                    Selection.setSelection(myEditable, 1);
                }
            }
            return myEditable;
        }
        else {
            return super.getEditable();
        }
    }

    @Override
    public boolean deleteSurroundingText(int beforeLength, int afterLength) {
        if((Build.VERSION.SDK_INT >= 14) // && (Build.VERSION.SDK_INT < 19)
                && (beforeLength == 1 && afterLength == 0)) {
            return super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))
                    && super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL));
        }
        else {
            return super.deleteSurroundingText(beforeLength, afterLength);
        }
    }
}

Then creating the custom EditText

import android.content.Context;
import android.text.InputType;
import android.util.AttributeSet;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import org.jetbrains.annotations.NotNull;

public class CustomEditText extends androidx.appcompat.widget.AppCompatEditText {

    public CustomEditText(@NonNull @NotNull Context context) {
        super(context);
    }

    public CustomEditText(@NonNull @NotNull Context context, @Nullable @org.jetbrains.annotations.Nullable AttributeSet attrs) {
        super(context, attrs);
    }

    public CustomEditText(@NonNull @NotNull Context context, @Nullable @org.jetbrains.annotations.Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
        InputConnectionAccomodatingLatinIMETypeNullIssues baseInputConnection =
                new InputConnectionAccomodatingLatinIMETypeNullIssues(this, false);

        outAttrs.actionLabel = null;

        outAttrs.inputType = InputType.TYPE_NULL;

        outAttrs.imeOptions = EditorInfo.IME_ACTION_DONE;

        return baseInputConnection;
    }

}

So in your .xml file, you can say something like

<your.package.name.CustomEditText
    <!set all required attributes-->
    />

Now in your java code, you have to listen for the Backspace click event and get the character to be deleted before it's deleted.

editText.setOnKeyListener(new View.OnKeyListener(){
    public boolean onKey(View v, int keyCode, KeyEvent event){
        if(event.getAction() == KeyEvent.ACTION_DOWN && keyCode == KeyEvent.KEYCODE_DEL) {
            int selStart = editText.getSelectionStart();
            int selEnd = editText.getSelectionEnd();
            //incase if some text in the textbox are selected, selStart and selEnd will
            //return the positions of both selected ends and you can get the text(s) deleted.
            
            //check if the selEnd is at 0, and if true, then there's not point going further
            if(selEnd == 0)
                return false;
            
            //if there is no texts selected, then reduce selStart by one to get the text to be deleted
            if(selStart == selEnd)
                selStart -= 1;
            
            String text = editText.getText().toString();
            //now this will get you char or chars to be deleted
            String charDeleted = text.substring(selStart, selEnd);
            
            //So before returning false to deleted the char,
            //let me answer the question asked also on the
            //comment section in Bobs' answer
            //which is to find the color code of the deleted char
            //Note, this is for only a single char, if you want to
            //handle for multiple chars, then you'll have to split the
            //deleted chars into an array and get the color codes for each
            
            //This will get all HTML text within the deleted char including the color code
            String htmlText = Html.toHtml((Spanned) editText.getText().subSequence(selStart, selEnd));
            
            //Now you have to use a HTML parser, and I'm using JSoup
            //Don't forget to implement the JSoup library into your project
            Document doc = Jsoup.parse(htmlText, "UTF-8");
            
            //Here I'm selecting a SPAN html tag, hoping that the char should be in a SPAN
            //If it's in a FONT or any other tag, then you select the tag instead and also
            //the attribute containing the color code
            Elements element = doc.select("span");
            //Attribute containing the color code for SPAN is the STYLE
            String style = element.attr("style");
            //So the style string would be giving you something like "color:#AABBCC;"
            //Where #AABBCC is the color code of the deleted char
        }
        return false;
    }
});

score -2 · Answer 7 · edited Jan 05 '13 at 08:01

-2

Try this

edittext.addTextChangeListener(new TextWatcher{
@override
  public void afterTextChanged(Editable s){
     String changedtext = s.toString();
}

@override
public void  beforeTextChanged (CharSequence s, int start, int count, int after){}

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

edited Jan 05 '13 at 08:01

Ronak Mehta

5,971
5
42
69

answered Jan 05 '13 at 07:51

techieWings

2,045
2
16
18

The reason of down vote is you have added correct listeners but not completely answered the question e.g where ru u doing deletion or checking deletion . – Naveed Aug 03 '13 at 02:57
Answer is just to let person know that, he can use this to achieve his requirements. – techieWings Aug 23 '13 at 13:07

how to get which character is get deleted on backspace in android

7 Answers7