Android EditText - टाइपिंग की घटना समाप्त

Question

जब उपयोगकर्ता EditText का संपादन पूरा कर लेता है, तो मैं एक घटना को पकड़ना चाहता हूं।

यह कैसे किया जा सकता है?

Comments

@ IPadmaKumar सबसे प्राकृतिक तरीका होगा यदि फोकस एडिटटेक्स्ट पर खो जाता है - तो उपयोगकर्ता सबसे निश्चित रूप से हो जाता है, हालांकि अनुभव से ऐसा लगता है कि सभी एंड्रॉइड विजेट ठीक से फोकस नहीं पकड़ रहे हैं (मेरे पास स्पिनर्स और बटन के साथ उन मुद्दों थे -) इसलिए अन्य विजेट्स फोकस नहीं खो सकते ...

— AgentKnopf

इतना बड़ा मंच हमें इस तरह के सरल कार्यों से निपटने की अनुमति क्यों देता है? Google कुछ भी नहीं खोएगा यदि वे अपने मुख्य पुस्तकालयों में ऐसी मुख्य विशेषताओं को कम से कम जोड़ते हैं

— MBH

यदि आप स्ट्रिंग उपयोगकर्ता की सही लंबाई जानते हैं, तो दर्ज करें, टेक्स्ट को आफ्टर-टेक्स्ट में प्राप्त करें। Ex:override fun afterTextChanged(s: Editable?) { if (s.toString().length == 5) { val enteredString = s.toString() }

— शीलेंद्र मद्दा

मैं आश्चर्य में अपने सिर को खरोंच रहा हूं कि एंड्रॉइड में यह इतना मुश्किल क्यों है कि हमें (खुद को शामिल करने के लिए) एक ऑनलाइन चर्चा शुरू करने और कोड के 10+ लाइनों के साथ कई अलग-अलग समाधान शुरू करने की आवश्यकता है ..?

— nsandersen

Answer 1

जब उपयोगकर्ता ने संपादन समाप्त कर लिया है, तो वह / Doneया दबाएगाEnter

((EditText)findViewById(R.id.youredittext)).setOnEditorActionListener(
    new EditText.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId == EditorInfo.IME_ACTION_SEARCH ||
                    actionId == EditorInfo.IME_ACTION_DONE ||
                    event != null &&
                    event.getAction() == KeyEvent.ACTION_DOWN &&
                    event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
                if (event == null || !event.isShiftPressed()) {
                   // the user is done typing. 

                   return true; // consume.
                }                
            }
            return false; // pass on to other listeners. 
        }
    }
);

Comments

क्या आप इसके बारे में निश्चित हो सकते हैं? मुझे अगले संपादन क्षेत्र में / में टैप करने की आदत है - मैं बहुत ज्यादा कभी भी Enter / Done नहीं दबाता - और जो मैंने अपने ग्राहकों से देखा है, न तो वे ... मैं एडिटेक्स / कॉम्बोक्स आदि की सूची के बारे में बात कर रहा हूं। । यदि आप केवल उपयोगकर्ता को एक इनपुट फ़ील्ड देते हैं और उसे एक बटन दबाने के लिए मजबूर करते हैं, तो इससे पहले कि वह अन्य क्षेत्रों में आगे बढ़ सके, तो यह स्पष्ट रूप से एक अलग कहानी है ...

— AgentKnopf

याद रखें, आपके पास अपने संपादन पाठ के लिए Android: singleLine = "true" सेट होना चाहिए। धन्यवाद करने के लिए stackoverflow.com/questions/15901863/...

— स्टीवन स्मिथ

अच्छा समाधान है, लेकिन अशक्त सूचक के साथ दुर्घटना हो सकती है ... 'घटना' को Done क्रिया पर null किया जा सकता है इसलिए event.isShiftPressed () क्रैश। यदि आप इसका उपयोग null पॉइंटर चेक में करते हैं।

— जॉर्जी

Null "इवेंट" की जांच करने के लिए एडिट किया गया।

— वर्ड रीयररेंजर

क्या होगा यदि आप कीबोर्ड को बंद करने वाले BACK बटन को हिट करते हैं?

— user347187

Answer 2

बेहतर तरीके से, आप यह भी जांच सकते हैं कि उपयोगकर्ता ने संपादन किया है या नहीं , यह जांचने के लिए EditText onFocusChange श्रोता का उपयोग करें: (सॉफ्ट कीबोर्ड पर बटन दबाने या प्रवेश करने वाले उपयोगकर्ता पर भरोसा न करें)

 ((EditText)findViewById(R.id.youredittext)).setOnFocusChangeListener(new OnFocusChangeListener() {

    @Override
    public void onFocusChange(View v, boolean hasFocus) {

      // When focus is lost check that the text field has valid values.

      if (!hasFocus) { {
         // Validate youredittext
      }
    }
 });

नोट: एक से अधिक EditText के लिए, आप अपनी कक्षा को कार्यान्वित करने दे सकते हैं View.OnFocusChangeListenerफिर श्रोताओं को आप में से प्रत्येक EditText पर सेट करें और उन्हें नीचे के रूप में मान्य करें

((EditText)findViewById(R.id.edittext1)).setOnFocusChangeListener(this);
((EditText)findViewById(R.id.edittext2)).setOnFocusChangeListener(this);

    @Override
    public void onFocusChange(View v, boolean hasFocus) {

      // When focus is lost check that the text field has valid values.

      if (!hasFocus) {
        switch (view.getId()) {
           case R.id.edittext1:
                 // Validate EditText1
                 break;
           case R.id.edittext2:
                 // Validate EditText2
                 break;
        }
      }
    }

Comments

यह काम नहीं करता है अगर केवल एक ध्यान देने योग्य है EditText। यह कभी भी ध्यान नहीं खोएगा।

— बार्ट फ्रेडरिक्स 16

अगर हमारे पास केवल एक ही है तो सबसे अच्छा तरीका क्या है EditText? क्या मुझे उपयोग करना है onEditorAction?

— टक्स

यदि केवल एक ही है EditText, तो आप उपयोगकर्ता को स्क्रीन छोड़ने के लिए जो कुछ भी करते हैं, उस पर मान्य करते हैं।

— क्रिस्टीन

मैंने यह कोशिश की लेकिन बात नहीं बनी। हर बार जब मैंने प्रवेश किया तो यह मुझे इसी तरह का संदेश देगा: W/ViewRootImpl: Cancelling event due to no window focus: MotionEvent { action=ACTION_CANCEL, actionButton=0, id[0]=0, x[0]=605.52246, y[0]=969.4336, toolType[0]=TOOL_TYPE_FINGER, buttonState=0, metaState=0, flags=0x0, edgeFlags=0x0, pointerCount=1, historySize=0, eventTime=238238, downTime=235422, deviceId=0, source=0x1002 }भले ही मैंने कुछ टाइप किया हो। यह एक ऐसा एडिटेक्स है जो केवल संख्याओं को स्वीकार करता है।

— आहिट ६३४५

OnFocusChange श्रोता का उपयोग करने का एक पक्ष बिंदु है: इसे संपादित नहीं किया जाएगा अगर EditText पर ध्यान केंद्रित किया गया है और डिवाइस घुमाया जाता है! मैंने कुछ ओनएक्टिव व्यू.requestFocus () एक्टिविटी ऑनपॉज () में डालकर इसे हल किया। (Super.onPause () से पहले) इस तरह यह सुरक्षित है कि EditText फोकस खो देता है और श्रोता कहलाता है।

— ऑलफॉमेक्स

Answer 3

मैं व्यक्तिगत रूप से टाइपिंग के अंत के बाद स्वचालित जमा को प्राथमिकता देता हूं। यहां आप इस घटना का पता लगा सकते हैं।

घोषणाएँ और आरंभीकरण:

private Timer timer = new Timer();
private final long DELAY = 1000; // in ms

श्रोता जैसे onCreate ()

EditText editTextStop = (EditText) findViewById(R.id.editTextStopId);
    editTextStop.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) {
            if(timer != null)
                timer.cancel();
        }
        @Override
        public void afterTextChanged(final Editable s) {
            //avoid triggering event when text is too short
            if (s.length() >= 3) {              

                timer = new Timer();
                timer.schedule(new TimerTask() {
                    @Override
                    public void run() {
                        // TODO: do what you need here (refresh list)
                        // you will probably need to use
                        // runOnUiThread(Runnable action) for some specific
                        // actions
                        serviceConnector.getStopPoints(s.toString());
                    }

                }, DELAY);
            }
        }
    });

इसलिए, जब पाठ को बदल दिया जाता है तो टाइमर किसी भी अगले परिवर्तन के होने की प्रतीक्षा करना शुरू कर देता है। जब वे टाइमर को रद्द कर देते हैं और फिर एक बार फिर से शुरू हो जाते हैं।

Comments

यह भयानक है, लेकिन सावधान रहें कि टाइमर मेमोरी लीक का कारण बन सकते हैं इसलिए Handlerइसके बजाय का उपयोग करें

— मो मह

यह बहुत अच्छा है, थानस्क।

— विप्रपंकजोशर्स द्रोपदी

सर्विसकॉन्क्टर क्या है?

— परोपकारी

@altruistic यह सिर्फ मेरे कोड का टुकड़ा है जिसमें से मैंने उत्तर को निकाल दिया है। यह वह जगह है जहाँ तर्क जाना चाहिए।

— ZimaXXX

Answer 4

आप इसे setOnKeyListener का उपयोग करके या एक textWatcher का उपयोग करके कर सकते हैं जैसे:

टेक्स्ट वॉचर सेट करें editText.addTextChangedListener(textWatcher);

फिर कॉल करो

private TextWatcher textWatcher = new TextWatcher() {

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

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

        @Override
        public void afterTextChanged(Editable s) {

        }
    };

Comments

मुझे डर है कि यह (पूर्ण) समाधान नहीं है - टेक्स्टवॉकर प्रत्येक संपादन के बाद आग लगाता है - यदि आप हैलो टाइप करते हैं तो यह एच, ई, एल, एल और ओ के लिए आग लगाने वाला है - यह वास्तव में नहीं पता है कि उपयोगकर्ता कब "किया गया" है । बहुत अच्छा होगा अगर TextWatcher वास्तव में पता चलेगा कि विजेट ने फ़ोकस खो दिया और उपयोगकर्ता आगे बढ़ गया ...

— AgentKnopf

Answer 5

हालाँकि बहुत से उत्तर सही दिशा में इशारा करते हैं लेकिन मुझे लगता है कि उनमें से कोई भी उत्तर नहीं देता है कि प्रश्न के लेखक के बारे में क्या सोच रहा था। या कम से कम मैंने सवाल को अलग तरह से समझा क्योंकि मैं इसी तरह की समस्या के जवाब की तलाश में था। समस्या यह है कि "कैसे पता चलेगा जब उपयोगकर्ता एक बटन दबाए बिना टाइप करना बंद कर देता है" और कुछ कार्रवाई को ट्रिगर करता है (उदाहरण के लिए ऑटो-पूर्ण)। यदि आप इसे शुरू करना चाहते हैं तो टाइमर को देरी से चालू करें ताकि आप उस उपयोगकर्ता पर विचार करना बंद कर दें (उदाहरण के लिए 500-700ms), प्रत्येक नए पत्र के लिए जब आप टाइमर शुरू करते हैं तो पहले वाले को रद्द कर दें (या कम से कम किसी प्रकार का उपयोग करें झंडा है कि जब वे टिक करते हैं तो वे कुछ भी नहीं करते हैं)। यहाँ वही कोड है जो मैंने उपयोग किया है:

new Timer().schedule(new TimerTask() {
  @Override
  public void run() {
     if (!running) {                            
        new DoPost().execute(s.toString());
  });
 }
}, 700);

ध्यान दें कि मैं अपने async कार्य के अंदर बूलियन ध्वज को संशोधित करता हूं (टास्क को ऑटो-पूर्ण के लिए सर्वर से जौन मिलता है)।

यह भी ध्यान रखें कि यह कई टाइमर कार्य बनाता है (मुझे लगता है कि वे एक ही थ्रेड पर निर्धारित हैं, लेकिन आपको यह जांचना होगा), इसलिए संभवतः सुधार करने के लिए कई स्थान हैं लेकिन यह दृष्टिकोण भी काम करता है और लब्बोलुआब यह है कि आपको चाहिए "उपयोगकर्ता द्वारा टाइपिंग इवेंट बंद कर दिया गया" होने के बाद से एक टाइमर का उपयोग करें

Comments

क्या आप कृपया इस पर अधिक जानकारी और नमूना कोड दे सकते हैं?

— जॉन अर्नेस्ट ग्वाडालूपे

कोड का सार उत्तर में है, अधिक विस्तृत उदाहरण के लिए कृपया इसी पृष्ठ पर ZimaXXX द्वारा उत्तर देखें जो समान दृष्टिकोण का उपयोग करता है। मुझे नहीं पता कि मैं और क्या जानकारी जोड़ सकता हूं, अगर आप यह निर्दिष्ट कर सकते हैं कि क्या स्पष्ट नहीं है तो मैं विवरण जोड़ने की कोशिश करूंगा।

— इगोर 46ordaš

Answer 6

यदि कार्रवाई के बाद कीबोर्ड छिपाना चाहते हैं तो @Reno और @Vinayak B दोनों एक साथ उत्तर देते हैं

textView.setOnEditorActionListener(new EditText.OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        if (actionId == EditorInfo.IME_ACTION_SEARCH || actionId == EditorInfo.IME_ACTION_DONE) {
            InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
            imm.hideSoftInputFromWindow(textView.getWindowToken(), 0);
            return true;
        }
        return false;
    }
});

textView.setOnFocusChangeListener(new View.OnFocusChangeListener() {
    @Override
    public void onFocusChange(View v, boolean hasFocus) {
        if (!hasFocus) {
             // your action here
        }
    }
});

Answer 7

एक अलग दृष्टिकोण ... यहां एक उदाहरण है: यदि टाइप करने पर उपयोगकर्ता के पास 600-1000ms की देरी है, तो आप सोच सकते हैं कि वह रुक गया है।

 myEditText.addTextChangedListener(new TextWatcher() {
             
            private String s;
            private long after;
			private Thread t;
            private Runnable runnable_EditTextWatcher = new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        if ((System.currentTimeMillis() - after) > 600)
                        {
                            Log.d("Debug_EditTEXT_watcher", "(System.currentTimeMillis()-after)>600 ->  " + (System.currentTimeMillis() - after) + " > " + s);
                            // Do your stuff
                            t = null;
                            break;
                        }
                    }
                }
            };
            
            @Override
            public void onTextChanged(CharSequence ss, int start, int before, int count) {
                s = ss.toString();
            }
            
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
            }
            
            @Override
            public void afterTextChanged(Editable ss) {
                after = System.currentTimeMillis();
                if (t == null)
                {
                    t = new Thread(runnable_EditTextWatcher);
                      t.start();
                }
            }
        });

Answer 8

ठीक है यह सुनिश्चित करने के लिए 100% काम करेगा।

यदि कीबोर्ड शो या छिपा है तो सबसे पहले आपको श्रोता को सेटअप करना होगा। यदि कीबोर्ड दिखा रहा है तो संभवतः उपयोगकर्ता टाइप कर रहा है, अन्यथा टाइपिंग की गई है।

final View activityRootView = findViewById(android.R.id.content);
        activityRootView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {

                    Rect r = new Rect();
                    //r will be populated with the coordinates of your view that area still visible.
                    activityRootView.getWindowVisibleDisplayFrame(r);

                    int heightDiff = activityRootView.getRootView().getHeight() - (r.bottom - r.top);
                    if (heightDiff > 100) { // if more than 100 pixels, its probably a keyboard...

                        isTyping = true;
                    } else {
//to make sure this will call only once when keyboard is hide.
                        if(isTyping){
                            isTyping = false;
                        }
                    }
            }
        });

Comments

कई टेक्स्ट संपादन के बारे में क्या? और heightDiff > 100सामान डरावना imho है।

— बॉन्डैक्स डेस

कोई बात नहीं, यह ठीक काम करता है। इस stackoverflow.com/questions/2150078/…

— Krit

Answer 9

मैंने इस समस्या को इस तरह हल किया। मैंने कोटलिन का इस्तेमाल किया।

        var timer = Timer()
        var DELAY:Long = 2000

        editText.addTextChangedListener(object : TextWatcher {

            override fun afterTextChanged(s: Editable?) {
                Log.e("TAG","timer start")
                timer = Timer()
                timer.schedule(object : TimerTask() {
                    override fun run() {
                        //do something
                    }
                }, DELAY)
            }

            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}

            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                Log.e("TAG","timer cancel ")
                timer.cancel() //Terminates this timer,discarding any currently scheduled tasks.
                timer.purge() //Removes all cancelled tasks from this timer's task queue.
            }
        })

Answer 10

मेरे पास एक ही मुद्दा था और डोन या एंटर दबाने वाले उपयोगकर्ता पर भरोसा नहीं करना चाहता था।

मेरा पहला प्रयास onFocusChange श्रोता का उपयोग करना था, लेकिन यह हुआ कि मेरे EditText को डिफ़ॉल्ट रूप से फोकस मिला। जब उपयोगकर्ता ने कुछ और दृश्य दबाया, तो उपयोगकर्ता को बिना फोकस दिए इसे ऑनफोकसचेंज चालू कर दिया गया।

अगला समाधान यह मेरे लिए किया था, जहां उपयोगकर्ता द्वारा EditText को छूने पर onFocusChange संलग्न है:

final myEditText = new EditText(myContext); //make final to refer in onTouch
myEditText.setOnTouchListener(new OnTouchListener() {

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            myEditText.setOnFocusChangeListener(new OnFocusChangeListener() {

                @Override
                public void onFocusChange(View v, boolean hasFocus) {
                    if(!hasFocus){
                        // user is done editing
                    }
                }
            }
        }
}

मेरे मामले में, जब उपयोगकर्ता को संपादित किया गया था तो स्क्रीन को फिर से जोड़ा गया था, जिससे myEditText ऑब्जेक्ट को नवीनीकृत किया गया था। यदि समान ऑब्जेक्ट रखा जाता है, तो आपको संभवतः इस पोस्ट की शुरुआत में वर्णित ऑनफोकसचेंज मुद्दे को रोकने के लिए onFocusChange में onFocusChange श्रोता को हटा देना चाहिए।

Comments

आप हर बार एक टच ईवेंट होने पर फ़ोकस चेंज श्रोता सेट कर रहे हैं, जो एक सेकंड में कई बार होगा। यह मत करो।

— jsonfry

Answer 11

चैट एप पर 'अब टाइपिंग' को लागू करने की कोशिश करते समय मुझे यही समस्या थी। EditText को इस प्रकार विस्तारित करने का प्रयास करें:

public class TypingEditText extends EditText implements TextWatcher {

private static final int TypingInterval = 2000;


public interface OnTypingChanged {
    public void onTyping(EditText view, boolean isTyping);
}
private OnTypingChanged t;
private Handler handler;
{
    handler = new Handler();
}
public TypingEditText(Context context, AttributeSet attrs, int defStyleAttr) {
    super(context, attrs, defStyleAttr);
    this.addTextChangedListener(this);
}

public TypingEditText(Context context, AttributeSet attrs) {
    super(context, attrs);
    this.addTextChangedListener(this);
}

public TypingEditText(Context context) {
    super(context);
    this.addTextChangedListener(this);
}

public void setOnTypingChanged(OnTypingChanged t) {
    this.t = t;
}

@Override
public void afterTextChanged(Editable s) {
    if(t != null){
        t.onTyping(this, true);
        handler.removeCallbacks(notifier);
        handler.postDelayed(notifier, TypingInterval);
    }

}

private Runnable notifier = new Runnable() {

    @Override
    public void run() {
        if(t != null)
            t.onTyping(TypingEditText.this, false);
    }
};

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


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

}

Answer 12

मैंने उसे उसी समस्या के साथ समाप्त कर दिया और मैं समाधान का उपयोग onEditorAction या onFocusChange के साथ नहीं कर सका और टाइमर को आज़माना नहीं चाहता था। एक टाइमर स्वाद के लिए बहुत खतरनाक है, क्योंकि सभी धागे और बहुत अप्रत्याशित हैं, जैसा कि आप नहीं जानते कि जब आप कोड निष्पादित करते हैं।

जब उपयोगकर्ता एक बटन का उपयोग किए बिना छोड़ता है तो onEditorAction नहीं पकड़ता है और यदि आप इसका उपयोग करते हैं तो कृपया ध्यान दें कि KeyEvent शून्य हो सकता है। फ़ोकस अविश्वसनीय है दोनों सिरों पर उपयोगकर्ता फ़ोकस प्राप्त कर सकता है और बिना किसी पाठ को दर्ज किए या फ़ील्ड का चयन किए बिना छोड़ सकता है और उपयोगकर्ता को अंतिम EditText फ़ील्ड छोड़ने की आवश्यकता नहीं है।

मेरा समाधान onFocusChange और एक ध्वज सेट का उपयोग करता है जब उपयोगकर्ता पाठ को संपादित करना शुरू करता है और पाठ को अंतिम ध्यान केंद्रित दृश्य से प्राप्त करने के लिए एक फ़ंक्शन होता है, जिसे मैं आवश्यकता होने पर कॉल करता हूं।

मैं सिर्फ अपने सभी टेक्स्ट फ़ील्ड पर ध्यान केंद्रित करता हूं कि टेक्स्ट को देखने के कोड को छोड़ दें, क्लीयरफोकस कोड को केवल तभी निष्पादित किया जाता है जब फ़ील्ड फोकस होता है। मैं onSaveInstanceState में फ़ंक्शन को कॉल करता हूं, इसलिए मुझे EditText दृश्य की स्थिति के रूप में और महत्वपूर्ण बटन क्लिक किए जाने पर और गतिविधि बंद होने पर ध्वज (mEditing) को सहेजने की आवश्यकता नहीं है।

टेक्सवर्चर के साथ सावधान रहें क्योंकि यह कॉल है अक्सर मैं ध्यान केंद्रित करने पर स्थिति का उपयोग करता हूं जब पाठ में प्रवेश करने वाले onRestoreInstanceState कोड पर प्रतिक्रिया न करें। मैं

final EditText mEditTextView = (EditText) getView();

    mEditTextView.addTextChangedListener(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) {

        }

        @Override
        public void afterTextChanged(Editable s) {
            if (!mEditing && mEditTextView.hasFocus()) {
                mEditing = true;
            }
        }
    });
    mEditTextView.setOnFocusChangeListener(new View.OnFocusChangeListener() {

        @Override
        public void onFocusChange(View v, boolean hasFocus) {
            if (!hasFocus && mEditing) {
                mEditing = false;
                ///Do the thing
            }
        }
    });
protected void saveLastOpenField(){
    for (EditText view:getFields()){
            view.clearFocus();
    }
}

Answer 13

मैंने इस सार वर्ग की तरह कुछ किया है जिसका उपयोग TextView.OnEditorActionListener प्रकार के स्थान पर किया जा सकता है।

abstract class OnTextEndEditingListener : TextView.OnEditorActionListener {

    override fun onEditorAction(textView: TextView?, actionId: Int, event: KeyEvent?): Boolean {

        if(actionId == EditorInfo.IME_ACTION_SEARCH ||
                actionId == EditorInfo.IME_ACTION_DONE ||
                actionId == EditorInfo.IME_ACTION_NEXT ||
                event != null &&
                event.action == KeyEvent.ACTION_DOWN &&
                event.keyCode == KeyEvent.KEYCODE_ENTER) {

            if(event == null || !event.isShiftPressed) {
                // the user is done typing.
                return onTextEndEditing(textView, actionId, event)
            }
        }
        return false // pass on to other listeners
    }

    abstract fun onTextEndEditing(textView: TextView?, actionId: Int, event: KeyEvent?) : Boolean
}

Answer 14

EditText में फिनिश टाइपिंग को ट्रिगर करना सरल है

मेरे लिए काम किया है, अगर आप जावा का उपयोग कर इसे परिवर्तित करते हैं

कोटलिन में

youredittext.doAfterTextChanged { searchTerm ->
val currentTextLength = searchTerm?.length
    Handler().postDelayed({
        if (currentTextLength == searchTerm?.length) {
            // your code 
           Log.d("aftertextchange", "ON FINISH TRIGGER")
          }
       }, 3000)
}