webentwicklung-frage-antwort-db.com.de

So können Sie feststellen, ob Benutzer die Eingabe von EditText Android beenden

Ich habe ein EditText-Feld in meinem Layout. Ich möchte eine Aktion ausführen, wenn der Benutzer die Eingabe dieses Edittext-Felds beendet. Ich habe TextWatcher implementiert und nutze dessen Funktionen 

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

    }

Die Funktionen onTextChanged und afterTextChanged werden direkt nach der Eingabe eines beliebigen Zeichens aufgerufen. Ich möchte jedoch eine Aktion ausführen, nachdem der Benutzer das Edittext-Feld vollständig eingegeben hat, genau wie Facebook es auf seiner "Check In" -Seite tut.

Wie kann ich das umsetzen?

14

So habe ich für mich gearbeitet und gearbeitet!

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 {

        }
    }
}

);
29
ThetNaing Mizo

Es gibt eine sehr einfache Möglichkeit, dies mit RxBindings für Android zu tun.

Holen Sie sich die Bibliothek, wenn Sie nicht bereits haben,

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

Fügen Sie dieses Snippet hinzu und passen Sie es Ihren Bedürfnissen an.

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

Was ist Debounce Operator? - Erfahren Sie hier mehr darüber

In unserem Kontext benachrichtigt Sie debounce nur über die Textänderung innerhalb von EditText, nachdem eine bestimmte Zeit seit der letzten Textänderung innerhalb von EditText verstrichen ist.

Hier warte ich 3 Sekunden , bis die letzte Textänderung ergab, dass der Benutzer aufgehört hat zu tippen. Sie können es nach Ihren Wünschen ändern.

13
Rahul Chowdhury

Sie können einen Fokusänderungslistener verwenden. Wenn der Edittext den Fokus hat, gehen Sie davon aus, dass der Benutzer noch bearbeitet wird, andernfalls wurde er beendet und Sie können Ihre Aktion ausführen:

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

Ich habe einen CountDownTimer verwendet, um herauszufinden, ob der Benutzer nach einer Weile nicht mehr tippt. Ich hoffe zu helfen.

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

        }
    });
2
Gui Moreira

Es ist ein etwas anderer Ansatz. Aber du kannst so etwas tun

Ich gehe davon aus, dass, nachdem ein Benutzer mit der Eingabe des Edittext begonnen hat und er für eine bestimmte Zeit nicht getippt hat, als angenommen werden kann, dass er mit dem Tippen aufhört.

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

Im Wesentlichen tun Sie hier Folgendes: Immer wenn ein Benutzer mit der Eingabe beginnt, und wenn beim Ändern des Textes innerhalb von edittext ein Zeitabstand von 5000 Millisekunden besteht, sollten Sie berücksichtigen, dass der Benutzer die Eingabe beendet hat. Natürlich können Sie die Uhrzeit beliebig ändern

2
Ankit Aggarwal

Wenn Sie Kotlin verwenden, verwenden Sie diese Erweiterungsfunktion:

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

}

Beispiel verwenden: 

 editTextPassword.afterTextChangedDelayed {
        registerViewModel.addUserPassword(it)
    }
1
Emmanuel Guther