How to detect if users stop typing in EditText and

Question

I have an EditText field in my layout. I want to perform an action when the user stops typing in that edittext field. I have implemented TextWatcher and use its functions

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


@Override
public void onTextChanged(CharSequence text, int start, int lengthBefore, int lengthAfter) { } 

@Override
    public void afterTextChanged(Editable editable) {

    }

The function onTextChanged and afterTextChanged get called just after typing any character, but I want to perform action after the user has finished typing in that edittext field, just like facebook does on it's "Check In" page.

How can I implement this?

Answer 1

If you use Kotlin, use this extension function:

fun TextView.afterTextChangedDelayed(afterTextChanged: (String) -> Unit) {
    this.addTextChangedListener(object : TextWatcher {
        var timer: CountDownTimer? = null

        override fun beforeTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}

        override fun onTextChanged(p0: CharSequence?, p1: Int, p2: Int, p3: Int) {}

        override fun afterTextChanged(editable: Editable?) {
            timer?.cancel()
            timer = object : CountDownTimer(1000, 1500) {
                override fun onTick(millisUntilFinished: Long) {}
                override fun onFinish() { 
                    afterTextChanged.invoke(editable.toString()) 
                }
            }.start()
        }
    })
}

Use example:

editTextPassword.afterTextChangedDelayed {
    registerViewModel.addUserPassword(it)
}

Answer 2

I used a CountDownTimer to find out if the user stopped typing after a while. I hope to help.

yourEditText.addTextChangedListener(new TextWatcher() {

        CountDownTimer timer = null;

        @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 (timer != null) {
                timer.cancel();
            }

            timer = new CountDownTimer(1500, 1000) {

                public void onTick(long millisUntilFinished) {
                }

                public void onFinish() {

                    //do what you wish

                }

            }.start();

        }

        @Override
        public void afterTextChanged(Editable s) {

        }
    });

Answer 3

This is how I did and works for me!

long delay = 1000; // 1 seconds after user stops typing
long last_text_edit = 0;
Handler handler = new Handler();

private Runnable input_finish_checker = new Runnable() {
    public void run() {
        if (System.currentTimeMillis() > (last_text_edit + delay - 500)) {
            // TODO: do what you need here
            // ............
            // ............
            DoStaff();
        }
    }
};

EditText editText = (EditText) findViewById(R.id.editTextStopId);
editText.addTextChangedListener(new TextWatcher() {
    @Override
    public void beforeTextChanged (CharSequence s,int start, int count,
    int after){
    }
    @Override
    public void onTextChanged ( final CharSequence s, int start, int before,
    int count){
        //You need to remove this to run only once
        handler.removeCallbacks(input_finish_checker);

    }
    @Override
    public void afterTextChanged ( final Editable s){
        //avoid triggering event when text is empty
        if (s.length() > 0) {
            last_text_edit = System.currentTimeMillis();
            handler.postDelayed(input_finish_checker, delay);
        } else {

        }
    }
}

);

Answer 4

It is a little different kind of approach. But you can do something like this

I am assuming that after a user started typing in the edittext, and he didn't typed for a particular time period than it can be considered that he stopped typing.

editText.addTextChangedListener(new TextWatcher() {

        boolean isTyping = false;

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

        private Timer timer = new Timer();
        private final long DELAY = 5000; // milliseconds

        @Override
        public void afterTextChanged(final Editable s) {
            Log.d("", "");
            if(!isTyping) {
                Log.d(TAG, "started typing");
                // Send notification for start typing event
                isTyping = true;
            }
            timer.cancel();
            timer = new Timer();
            timer.schedule(
                    new TimerTask() {
                        @Override
                        public void run() {
                            isTyping = false;
                            Log.d(TAG, "stopped typing");
                            //send notification for stopped typing event
                        }
                    },
                    DELAY
            );
        }
    });

Basically what you are doing here is, that whenever a user starts typing, if there is a time gap of 5000 milliseconds in changing the text inside the edittext, you consider as the user has stopped typing. Of course you can change the time to whatever you want

Answer 5

You could use a focus change listener. If the edittext has focus then assume user still editing otherwise they have stopped and you can perform your action:

    EditText et = new EditText(mContext);
    et.setOnFocusChangeListener(new View.OnFocusChangeListener() {
        @Override
        public void onFocusChange(View view, boolean hasFocus) {
            if (hasFocus) {
                //user has focused
            } else {
                //focus has stopped perform your desired action
            }
        }
    });

Answer 6

There is a very simple and easy way of doing this using RxBindings for Android,

Get the library if you haven't already,

compile 'com.jakewharton.rxbinding:rxbinding:0.4.0'

Add and modify this snippet to your needs,

RxTextView.textChanges(mEditText)
            .debounce(3, TimeUnit.SECONDS)
            .subscribe(textChanged -> {
                Log.d("TAG", "Stopped typing!");
            });

What is Debounce Operator? - Learn more about it here

In our context, debounce will only notify you of the text change inside the EditText after a certain time has passed from the last text change that occurred inside the EditText.

Here I am waiting for 3 seconds until the last text change happened to conclude that the user has stopped typing. You can modify it according to your needs.