Android - एक EditText में "Enter" हैंडल करें


459

मुझे आश्चर्य हो रहा है कि क्या Enterटाइप करते समय उपयोगकर्ता को संभालने का एक तरीका है EditText, कुछ ऐसा है जैसे onSubmit HTML घटना।

यह भी सोच रहा था कि क्या वर्चुअल कीबोर्ड को इस तरह से हेरफेर करने का एक तरीका है कि "डन" बटन को कुछ और लेबल किया जाता है (उदाहरण के लिए "गो") और क्लिक किए जाने पर एक निश्चित कार्रवाई करता है (फिर से ऑनसुमिट की तरह)।


1
कोटलिन और एक्सटेंशन: यहां एक नज़र डालें: stackoverflow.com/a/48810268/1912924
फ्रांसेस्को डोनज़ेलो

जवाबों:


374

मुझे आश्चर्य हो रहा है कि क्या कोई Enterएडिटटेक्स्ट टाइप करते समय दबाने वाले उपयोगकर्ता को संभालने का एक तरीका है , कुछ ऐसा है जैसे कि ऑनसुमिट HTML ईवेंट।

हाँ।

यह भी सोच रहा था कि क्या वर्चुअल कीबोर्ड को इस तरह से हेरफेर करने का एक तरीका है कि "डन" बटन को कुछ और लेबल किया जाता है (उदाहरण के लिए "गो") और क्लिक किए जाने पर एक निश्चित कार्रवाई करता है (फिर से ऑनसुमिट की तरह)।

हाँ भी।

तुम android:imeActionIdऔर android:imeOptionsविशेषताओं को देखना चाहते हो जाएगा , प्लस setOnEditorActionListener()विधि, सब परTextView

"Done" बटन के टेक्स्ट को कस्टम स्ट्रिंग में बदलने के लिए, उपयोग करें:

mEditText.setImeActionLabel("Custom text", KeyEvent.KEYCODE_ENTER);

26
(PS EditText TextView का विस्तार करता है, इस प्रकार आप जिन गुणों को देखना चाहते हैं, वे TextView पर हैं - जब मैंने पहली बार उस अंतिम वाक्य को पढ़ा था तो मैंने डबल-लिया :))
रिक

15
नोट के रूप में। सभी कीबोर्ड मानक एंड्रॉइड का समर्थन नहीं करते हैं: imeOptions विशेषता। जो वास्तव में विघटनकारी है। उदाहरण के लिए, IME_ACTION_DONE को 6 के रूप में परिभाषित किया गया है, जहां HTC डिफ़ॉल्ट कीबोर्ड (अतुल्य, ईवो 4 जी जैसे फोन) रिटर्न कुंजी को
0.22 के

13
इसके अलावा अगर आपका उपयोग करने वाले imeOptions सुनिश्चित करते हैं कि आप भी इनपुट टाइप = "टेक्स्ट" या किसी अन्य समकक्ष का उपयोग करते हैं। यह सुनिश्चित करने के लिए कीबोर्ड आपको सुनता है! Nexus1
ब्लंडेल

6
"हाँ" - क्या आप इससे अधिक वर्णनात्मक होंगे? वह संभावना पूछेंगे कि समाधान कैसे लागू किया जाए।
अल वांग

4
@ अलवांग: सबसे पहले, आपकी चिंता का क्षेत्र उत्तर में है (देखें "आप चाहते हैं ..." से शुरू होगा)। दूसरा, यह जवाब छह साल पहले का है , और इसलिए यह माना जाएगा कि ओपी की समस्या हल हो गई है। आखिरकार, ओपी ने जवाब स्वीकार कर लिया।
कॉमन्सवेअर

267
final EditText edittext = (EditText) findViewById(R.id.edittext);
edittext.setOnKeyListener(new OnKeyListener() {
    public boolean onKey(View v, int keyCode, KeyEvent event) {
        // If the event is a key-down event on the "enter" button
        if ((event.getAction() == KeyEvent.ACTION_DOWN) &&
            (keyCode == KeyEvent.KEYCODE_ENTER)) {
          // Perform action on key press
          Toast.makeText(HelloFormStuff.this, edittext.getText(), Toast.LENGTH_SHORT).show();
          return true;
        }
        return false;
    }
});

1
किसी कारण से जब मैं enterअपने संपादन पाठ में क्लिक करता हूं, तो संपूर्ण संपादन पाठ नीचे चला जाता है ... मैं इसे कैसे ठीक कर सकता हूं?
रुचिर बैरोनिया

1
@RuchirBaronia Android जोड़ें: अपने एडिट टेक्स्ट में अधिकतम 1 = "1"। आपका EditText "नीचे" नहीं चल रहा है, बल्कि दर्ज किए गए पाठ में एक पंक्ति विराम सम्मिलित कर रहा है। अधिकतम 1 को सेट करना लाइन ब्रेक को डालने से रोकता है।
लस्टिग

3
यह समाधान केवल हार्डवेयर कीबोर्ड के लिए काम करता है, न कि सॉफ्ट / वर्चुअल कीबोर्ड के लिए। यदि आप इस पर भरोसा करते हैं, तो आपके ऐप को बिना कीबोर्ड वाले उपयोगकर्ताओं के लिए तोड़ दिया जाएगा।
user3562927

12
CommonsWare, लेकिन उसकी RTFM जवाब देने के लिए कोई अपराध था जिस तरह से इस सरल वास्तव में दिखा इसे कैसे करना उदाहरण से कम उपयोगी है। धन्यवाद!
ऑटोनोमस

1
@AutonomousApps, मैं अक्सर कॉमन्सवेयर जवाब देखता हूं। वह 2009 से जवाब देने के लिए भाग्यशाली था, जब एंड्रॉइड शुरू हुआ। अक्सर "हाँ", "नहीं", "असंभव" और इसी तरह, आमतौर पर बिना कोड के। अक्सर उनके जवाब अब पुराने हैं, इसलिए मैं उनकी सिफारिशों का पालन नहीं करने की कोशिश करता हूं।
CoolMind

215

यहाँ आप क्या करते हैं। यह एंड्रॉइड डेवलपर के सैंपल कोड 'ब्लूटूथ चैट' में भी छिपा है। बोल्ड भागों को बदलें जो "उदाहरण" कहते हैंअपने स्वयं के चर और तरीकों के साथ ।

सबसे पहले, मुख्य गतिविधि में आपकी आवश्यकता के अनुसार आयात करें जहाँ आप कुछ विशेष करने के लिए रिटर्न बटन चाहते हैं:

import android.view.inputmethod.EditorInfo;
import android.widget.TextView;
import android.view.KeyEvent;

अब, अपनी वापसी कुंजी के लिए TextView.OnEditorActionListener का एक चर बनाएं (यहां मैं उदाहरणListener का उपयोग करता हूं );

TextView.OnEditorActionListener exampleListener = new TextView.OnEditorActionListener(){

फिर आपको श्रोता को दो बातें बतानी होंगी कि रिटर्न बटन दबाने पर क्या करना चाहिए। यह जानने की जरूरत है कि हम किस EditText के बारे में बात कर रहे हैं (यहाँ मैं exampleView का उपयोग करता हूँ ), और फिर यह जानना आवश्यक है कि एंटर कुंजी दबाने पर क्या करना है (यहाँ, example_confirm () )। यदि यह आपकी गतिविधि का अंतिम या एकमात्र EditText है, तो यह आपके सबमिट (या ओके, कन्फर्म, सेंड, सेव, आदि) बटन के लिए ऑनक्लिक विधि जैसा ही काम करना चाहिए।

public boolean onEditorAction(TextView exampleView, int actionId, KeyEvent event) {
   if (actionId == EditorInfo.IME_NULL  
      && event.getAction() == KeyEvent.ACTION_DOWN) { 
      example_confirm();//match this behavior to your 'Send' (or Confirm) button
   }
   return true;
}

अंत में, श्रोता को सेट करें (आपके ऑनक्रिएट विधि में सबसे अधिक संभावना है);

exampleView.setOnEditorActionListener(exampleListener);

20
अच्छा, मैंने EditorInfo.IME_ACTION_SEND का उपयोग किया है और मेरे पास XML पर imeOptions = "actionSend" Android है।
बानी

EditorInfo.IME_ACTION_SEND की तलाश में मेरे (एमुलेटर) के लिए कोई प्रभाव नहीं था, इसलिए एक बेवकूफ ट्रिगर के रूप में मैंने KeyEvent.KEYCODE_ENTER को भी देखा। यहां देखें: stackoverflow.com/questions/2004344/…
किसी

4
आमतौर पर कार्रवाई करना बेहतर होता है KeyEvent.ACTION_UP। काम करने के लिए इस के लिए आदेश में, आप पहली बार उपभोग करने के लिए की जरूरत है ACTION_DOWNघटना: if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_DOWN) { return true; }। फिर आप ACTION_UPघटना की जांच कर सकते हैं और कार्रवाई कर सकते हैं (उपरोक्त उत्तर के समान)। यदि आप ACTION_DOWNईवेंट का उपभोग नहीं करते हैं , तो onEditorActionआपको इसके लिए नहीं बुलाया जाएगा ACTION_UP
ashughes

2
यह मेरे लिए काम किया है: if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN) {...}- काम करने के लिए अन्य तरीकों में से कोई भी नहीं मिल सका
जोनाथन एलिस

38

हार्डवेयर कीबोर्ड हमेशा ईवेंट दर्ज करते हैं, लेकिन सॉफ़्टवेयर कीबोर्ड एकल एलाइनटैक्सट में अलग-अलग एक्शनआईडी और नल लौटाते हैं। यह कोड हर बार जवाब देता है कि उपयोगकर्ता किसी एडिट टेक्स्ट में प्रविष्ट होता है, जिसे एडिट टेक्स्ट या कीबोर्ड प्रकार की परवाह किए बिना इस श्रोता पर सेट किया गया है।

import android.view.inputmethod.EditorInfo;
import android.view.KeyEvent;
import android.widget.TextView.OnEditorActionListener;

listener=new TextView.OnEditorActionListener() {
  @Override
  public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {
    if (event==null) {
      if (actionId==EditorInfo.IME_ACTION_DONE);
      // Capture soft enters in a singleLine EditText that is the last EditText.
      else if (actionId==EditorInfo.IME_ACTION_NEXT);
      // Capture soft enters in other singleLine EditTexts
      else return false;  // Let system handle all other null KeyEvents
    }
    else if (actionId==EditorInfo.IME_NULL) { 
    // Capture most soft enters in multi-line EditTexts and all hard enters.
    // They supply a zero actionId and a valid KeyEvent rather than
    // a non-zero actionId and a null event like the previous cases.
      if (event.getAction()==KeyEvent.ACTION_DOWN); 
      // We capture the event when key is first pressed.
      else  return true;   // We consume the event when the key is released.  
    }
    else  return false; 
    // We let the system handle it when the listener
    // is triggered by something that wasn't an enter.


    // Code from this point on will execute whenever the user
    // presses enter in an attached view, regardless of position, 
    // keyboard, or singleLine status.

    if (view==multiLineEditText)  multiLineEditText.setText("You pressed enter");
    if (view==singleLineEditText)  singleLineEditText.setText("You pressed next");
    if (view==lastSingleLineEditText)  lastSingleLineEditText.setText("You pressed done");
    return true;   // Consume the event
  }
};

SingleLine = false में एंटर कुंजी का डिफ़ॉल्ट रूप एक तुला तीर कुंजीपैड दर्ज करता है। जब OneLine = अंतिम EditText में सही होता है, तो DONE कहता है, और इससे पहले कि यह NEXT कहता है, EditTexts पर। डिफ़ॉल्ट रूप से, यह व्यवहार सभी वैनिला, एंड्रॉइड, और Google एमुलेटरों के अनुरूप है। स्क्रॉलहॉर्बल विशेषता से कोई अंतर नहीं पड़ता है। अशक्त परीक्षण महत्वपूर्ण है क्योंकि सॉफ्ट एंटर्स को फोन की प्रतिक्रिया निर्माता को छोड़ दी जाती है और यहां तक ​​कि एमुलेटर में भी, वेनिला लेवल 16 के एमुलेटर मल्टी-लाइन और स्क्रॉलहॉर्गेनिक एडिटटेक्स्ट में लंबे सॉफ्ट एंटर्स का जवाब देते हैं, जो NEXT के एक्शन डीआर और एक नल के लिए अशक्त है। घटना।


जब मैंने जावा को अपग्रेड किया, तो मेरा एंड्रॉइड टूल-चेन टूट गया। यह 32-बिट था। मैंने 64-बिट सब कुछ फिर से स्थापित किया और पता चला कि अब कई सार्वजनिक एमुलेटर संस्करण उपलब्ध हैं। मुझे यह स्वीकार करना चाहिए कि मुझे केवल यह पता है कि EditorActionListener का व्यवहार उन एमुलेटरों के अनुरूप है, जिनका मैंने परीक्षण किया था।
21

जब मैंने इसे अपने ब्लॉग पर पोस्ट किया, तो किसी ने टिप्पणी की कि इसे ग्रहण पर काम करने के लिए आपको डिफ़ॉल्ट ime कार्रवाई को बदलने की आवश्यकता है, एंड्रॉइड को जोड़ना: imeOptions = "actionGo"।
इयरक्लासपर

उफ़ मैंने अपने ब्लॉग पोस्ट पर टिप्पणी को गलत बताया। इसे ग्रहण पर काम करने के लिए, आपको एंड्रॉइड को जोड़ने के लिए डिफ़ॉल्ट ime एक्शन को बदलना होगा: imeOptions = "actionGo"। लेआउट xml में 'EditText' के लिए।
इयरक्लासपर

आगे के प्रतिबिंब पर मेरी आखिरी टिप्पणी चींटी और ग्रहण दोनों को संदर्भित करती है
ईयरक्लासपर

27

यह पृष्ठ बताता है कि यह कैसे करना है।

https://developer.android.com/training/keyboard-input/style.html

Android सेट करें : imeOptions तो आप बस कार्रवाई की जाँच करें में। इसलिए यदि आप imeOptions को 'actionDone' पर सेट करते हैं, तो आप onEditorAction में 'actionId == EditorInfo.IME_ACTION_DONE' के लिए जाँच करेंगे। इसके अलावा, Android सेट करने के लिए सुनिश्चित करें: inputType।

ऊपर दिए गए उदाहरण से EditText यहाँ दिया गया है:

<EditText
    android:id="@+id/search"
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:hint="@string/search_hint"
    android:inputType="text"
    android:imeOptions="actionSend" />

आप इस प्रोग्राम को setImeOptions (int) फ़ंक्शन का उपयोग करके भी सेट कर सकते हैं । यहाँ ऊपर दिए गए उदाहरण से OnEditorActionListener है:

EditText editText = (EditText) findViewById(R.id.search);
editText.setOnEditorActionListener(new OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
        boolean handled = false;
        if (actionId == EditorInfo.IME_ACTION_SEND) {
            sendMessage();
            handled = true;
        }
        return handled;
    }
});

21

मुझे पता है कि यह एक साल पुराना है, लेकिन मैंने अभी-अभी एडिटटेक्स्ट के लिए पूरी तरह से काम किया है।

EditText textin = (EditText) findViewById(R.id.editText1);
textin.setInputType(InputType.TYPE_CLASS_TEXT);

यह टेक्स्ट और स्पेस के अलावा कुछ भी रोकता है। मैं टैब नहीं कर सका, "वापसी" ("\ n"), या कुछ भी।


मेरे लिए काम किया, IME_ACTION_DONE के साथ
htafoya

1
पूरी तरह से ठीक काम करता है अगर आप "एंटर" कुंजी को निष्क्रिय करना चाहते हैं।
डे जूल

16

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

if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_DOWN)
{
    // your code here
}

कार्रवाई की घटनाओं को दोहराने के बारे में जानकारी के लिए http://developer.android.com/reference/android/view/KeyEvent.html देखें (एंटर कुंजी दबाए रखें) आदि।


16

मेरा भी ऐसा ही उद्देश्य था। मैं AutoCompleteTextView में TextView को निकालने वाले कीबोर्ड पर "Enter" कुंजी (जिसे मैं अनुकूलित करना चाहता था) को दबाने का संकल्प करना चाहता था। मैंने ऊपर से विभिन्न समाधानों की कोशिश की और वे काम करने लगे। लेकिन जब मैंने स्विफ्टके 3 (जहां यह पूरी तरह से काम किया है) से अपने डिवाइस पर इनपुट प्रकार (Nexus 4, AOKP ROM के साथ नेक्सस स्विच) को मानक एंड्रॉइड कीबोर्ड में बदल दिया, जहां (श्रोता से मेरा कोड संभालने के बजाय, एक नई लाइन) "एन्टर" कुंजी को दबाने के बाद दर्ज किया गया। मुझे इस समस्या को संभालने में थोड़ा समय लगा, लेकिन मुझे नहीं पता कि यह सभी परिस्थितियों में काम करेगा चाहे आप किस प्रकार के इनपुट का उपयोग करें।

तो यहाँ मेरा समाधान है:

"पाठ" के लिए xml में TextView के इनपुट प्रकार विशेषता सेट करें:

android:inputType="text"

कीबोर्ड पर "Enter" कुंजी के लेबल को अनुकूलित करें:

myTextView.setImeActionLabel("Custom text", KeyEvent.KEYCODE_ENTER);

एक OnEditorActionListener को TextView पर सेट करें:

myTextView.setOnEditorActionListener(new OnEditorActionListener()
{
    @Override
    public boolean onEditorAction(TextView v, int actionId,
        KeyEvent event)
    {
    boolean handled = false;
    if (event.getAction() == KeyEvent.KEYCODE_ENTER)
    {
        // Handle pressing "Enter" key here

        handled = true;
    }
    return handled;
    }
});

मुझे आशा है कि इससे दूसरों को मेरी समस्याओं से बचने में मदद मिल सकती है, क्योंकि उन्होंने मुझे पागल कर दिया है।


दुर्भाग्य से यह SwiftKey के नए संस्करण 4 के साथ काम नहीं कर रहा है। और यह मुझे फिर से पागल कर रहा है ...: - /
kaolick

3
आपकी IF गलत है। उपयोग करें: 'event.getKeyCode () == KeyEvent.KEYCODE_ENTER'
Loda

मेरे लिए सही है। साथ ही IFI स्टेटमेंट में फिर से setImeActionLabel सम्मिलित करना याद रखें अन्यथा पहले प्रेस के बाद कस्टम टेक्स्ट गायब हो जाता है।
स्टीव रोजर्स

उसका आईएफ सही है, क्योंकि वह अपने एक्शनआईड को KeyEvent.KEYCODE_ENTER से ऊपर सेट करता है :-D, लेकिन हाँ हर कोई शायद Event.getKeyCode () == KeyEvent.KEYCODE_ENTER
Ray Hulha

15

अपने xml में, imeOptions विशेषता को editText में जोड़ें

<EditText
    android:id="@+id/edittext_additem"
    ...
    android:imeOptions="actionDone"
    />

फिर, अपने जावा कोड में, एक ही EditText पर OnEditorActionListener जोड़ें

mAddItemEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if(actionId == EditorInfo.IME_ACTION_DONE){
                //do stuff
                return true;
            }
            return false;
        }
    });

यहाँ स्पष्टीकरण है- imeOptions = actionDone EnterKey को "ActionDone" असाइन करेगा। कीबोर्ड में EnterKey "Enter" से "Done" में बदल जाएगा। इसलिए जब Enter कुंजी दबाया जाता है, तो यह इस क्रिया को ट्रिगर करेगा और इस प्रकार आप इसे संभाल लेंगे।


9

आप भी कर सकते हैं ।।

editText.setOnKeyListener(new OnKeyListener() {

            @Override
            public boolean onKey(View v, int keyCode, KeyEvent event)
            {
                if (event.getAction() == KeyEvent.ACTION_DOWN
                        && event.getKeyCode() ==       KeyEvent.KEYCODE_ENTER) 
                {
                    Log.i("event", "captured");

                    return false;
                } 

            return false;
        }
    });

किसी कारण से जब मैं enterअपने संपादन पाठ में क्लिक करता हूं, तो संपूर्ण संपादन पाठ नीचे चला जाता है ... मैं इसे कैसे ठीक कर सकता हूं?
रुचिर बैरोनिया

मुझे लगता है कि आप सीखना चाहते हैं stackoverflow.com/questions/10978038/… othewise मुझे अपना xml दिखाएं
Jawad Zeb

6
     password.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if(event != null && event.getKeyCode() == KeyEvent.KEYCODE_ENTER && event.getAction() == KeyEvent.ACTION_DOWN) {
                InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
                imm.toggleSoftInput(InputMethodManager.SHOW_IMPLICIT, 0);
                submit.performClick();
                return true;
            }
            return false;
        }
    });

मेरे लिए बहुत ठीक काम करता है
इसके अलावा कीबोर्ड छिपाएं


5

सबसे पहले, आपको मुख्य प्रेस को एडिट टेक्स्ट को सेट करना होगा

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main); 

    // Set the EditText listens to key press
    EditText edittextproductnumber = (EditText) findViewById(R.id.editTextproductnumber);
    edittextproductnumber.setOnKeyListener(this);

}

दूसरा, कुंजी प्रेस पर घटना को परिभाषित करें, उदाहरण के लिए, टेक्स्टव्यू के पाठ को सेट करने के लिए घटना:

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
    // TODO Auto-generated method stub

 // Listen to "Enter" key press
 if ((event.getAction() == KeyEvent.ACTION_DOWN) && (keyCode == KeyEvent.KEYCODE_ENTER))
 {
     TextView textviewmessage = (TextView) findViewById(R.id.textViewmessage);
     textviewmessage.setText("You hit 'Enter' key");
     return true;
 }

return false;   

}

और अंत में, EditText, TextView, OnKeyListener, KeyEvent को शीर्ष पर आयात करना न भूलें:

import android.view.KeyEvent;
import android.view.View.OnKeyListener;
import android.widget.EditText;
import android.widget.TextView;

5

पूरी तरह से काम कर रहा है

public class MainActivity extends AppCompatActivity {  
TextView t;
Button b;
EditText e;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    b = (Button) findViewById(R.id.b);
    e = (EditText) findViewById(R.id.e);

    e.addTextChangedListener(new TextWatcher() {

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

            if (before == 0 && count == 1 && s.charAt(start) == '\n') {

                b.performClick();
                e.getText().replace(start, start + 1, ""); //remove the <enter>
            }

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

    b.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            b.setText("ok");

        }
    });
}

}

पूरी तरह से काम कर रहा है


5
editText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if (actionId != 0 || event.getAction() == KeyEvent.ACTION_DOWN) {
                // Action
                return true;
            } else {
                return false;
            }
        }
    });

Xml

<EditText
        android:id="@+id/editText2"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:hint="@string/password"
        android:imeOptions="actionGo|flagNoFullscreen"
        android:inputType="textPassword"
        android:maxLines="1" />

4

यह काम करना चाहिए

input.addTextChangedListener(new TextWatcher() {

           @Override
           public void afterTextChanged(Editable s) {}

           @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( -1 != input.getText().toString().indexOf( "\n" ) ){
                   input.setText("Enter was pressed!");
                    }
           }
          });

4

इस कोड को अपने संपादक में टाइप करें ताकि यह आवश्यक मॉड्यूल आयात कर सके।

 query.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView textView, int actionId, KeyEvent keyEvent) {
            if(actionId == EditorInfo.IME_ACTION_DONE
                    || keyEvent.getAction() == KeyEvent.ACTION_DOWN
                        || keyEvent.getAction() == KeyEvent.KEYCODE_ENTER) {

                // Put your function here ---!

                return true;

            }
            return false;
        }
    });

क्वेरी = EditText फ़ील्ड का नाम, और इसे भी जोड़ें - EditText की xml में (android: imeOptions = "actionSearch")।
संजीत प्रसाद

3

यह एलजी एंड्रॉइड फोन पर ठीक काम करता है। यह ENTERसामान्य चरित्र के रूप में व्याख्या किए जाने वाले अन्य विशेष पात्रों को रोकता है । Nextया Doneबटन स्वचालित रूप से प्रकट होता है और ENTERअपेक्षा के अनुसार काम करता है।

edit.setInputType(InputType.TYPE_CLASS_TEXT);

यह केवल एक चीज है जो मेरे लिए काम करती है। मेरे पास एक मोटोरोला मोटो एक्स 2 है और आम तौर पर इसमें तीर और सब कुछ के साथ "रिटर्न" कुंजी है। इसने इसे एक चेकमार्क में बदल दिया और मैं आखिरकार श्रोता को उसी के साथ काम करने में सक्षम कर पाया। (इससे पहले कि यह सिर्फ एक नई लाइन बनाई)। इसलिए अगर किसी और को यह समस्या हो रही है ...
रहस्यवादी कोला

2

यहां एक सरल स्थैतिक फ़ंक्शन है जिसे आप अपने Utilsया Keyboardsवर्ग में फेंक सकते हैं जो उपयोगकर्ता द्वारा हार्डवेयर या सॉफ़्टवेयर कीबोर्ड पर रिटर्न कुंजी हिट करने पर कोड निष्पादित करेगा। यह @ earlcasper के उत्कृष्ट उत्तर का एक संशोधित संस्करण है

 /**
 * Return a TextView.OnEditorActionListener that will execute code when an enter is pressed on
 * the keyboard.<br>
 * <code>
 *     myTextView.setOnEditorActionListener(Keyboards.onEnterEditorActionListener(new Runnable()->{
 *         Toast.makeText(context,"Enter Pressed",Toast.LENGTH_SHORT).show();
 *     }));
 * </code>
 * @param doOnEnter A Runnable for what to do when the user hits enter
 * @return the TextView.OnEditorActionListener
 */
public static TextView.OnEditorActionListener onEnterEditorActionListener(final Runnable doOnEnter){
    return (__, actionId, event) -> {
        if (event==null) {
            if (actionId == EditorInfo.IME_ACTION_DONE) {
                // Capture soft enters in a singleLine EditText that is the last EditText.
                doOnEnter.run();
                return true;
            } else if (actionId==EditorInfo.IME_ACTION_NEXT) {
                // Capture soft enters in other singleLine EditTexts
                doOnEnter.run();
                return true;
            } else {
                return false;  // Let system handle all other null KeyEvents
            }
        } else if (actionId==EditorInfo.IME_NULL) {
            // Capture most soft enters in multi-line EditTexts and all hard enters.
            // They supply a zero actionId and a valid KeyEvent rather than
            // a non-zero actionId and a null event like the previous cases.
            if (event.getAction()==KeyEvent.ACTION_DOWN) {
                // We capture the event when key is first pressed.
                return true;
            } else {
                doOnEnter.run();
                return true;   // We consume the event when the key is released.
            }
        } else {
            // We let the system handle it when the listener
            // is triggered by something that wasn't an enter.
            return false;
        }
    };
}

ध्यान दें कि यह एक लैम्ब्डा अभिव्यक्ति का उपयोग करता है, जिसके लिए जावा 1.8 की आवश्यकता होती है, लेकिन लैम्बडा का उपयोग नहीं करने के लिए इसे परिवर्तित करने के लिए इसका आसान पर्याप्त है। हालाँकि, मैंने इस प्रकार के समाधानों के साथ जो समस्या देखी है वह यह है कि वर्चुअल कीबोर्ड ऑटो-
हाईड

2

CommonsWare textने जो काम करने के लिए कहा था, उसके लिए टेक्स्टफील्ड पर इनपुट टाइप होना चाहिए । बस इस सब की कोशिश की, ट्रायल से पहले कोई इनपुट टाइप नहीं किया और कुछ भी काम नहीं किया, एंटर ने सॉफ्ट एंटर के रूप में रजिस्टर किया। उपरांतinputType = text , setImeLabel सहित सब कुछ काम किया।

उदाहरण : android:inputType="text"


2
   final EditText edittext = (EditText) findViewById(R.id.edittext);
    edittext.setOnKeyListener(new OnKeyListener() {
        public boolean onKey(View v, int keyCode, KeyEvent event) {
            // If the event is a key-down event on the "enter" button
            if ((event.getAction() == KeyEvent.ACTION_DOWN) &&
                    (keyCode == KeyEvent.KEYCODE_ENTER)) {
                // Perform action on key press
                Toast.makeText(HelloFormStuff.this, edittext.getText(), Toast.LENGTH_SHORT).show();
                return true;
            }
            return false;
        }
    });

1

एक <दर्ज करें> के लिए जवाब एक EditText में करने के लिए एक भरोसेमंद तरीका एक साथ है TextWatcher , एक LocalBroadcastManager , और एक BroadcastReceiver । आपको LocalBroadcastManager का उपयोग करने के लिए v4 समर्थन लाइब्रेरी जोड़ने की आवश्यकता है । मैं vogella.com पर ट्यूटोरियल का उपयोग करता हूं : 7.3 "लोकल ब्रॉडकास्टमैनेजर के साथ लोकल ब्रॉडकास्ट इवेंट्स" इसके पूर्ण संक्षिप्त कोड उदाहरण के कारण। OnTextChanged में से पहले है परिवर्तन के अंत के सूचकांक बदलने से पहले >; शून्य से शुरू करते हैं। जब TextWatcher में UI थ्रेड EditText के संपादन योग्य को अपडेट करने में व्यस्त होता है, तो जब हम UI थ्रेड को एडिट करने के लिए ब्रॉडकास्टसीवर को जाप करने के लिए एक इरादा भेजते हैं, तो EditText को अपडेट किया जाता है।

import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.text.Editable;
//in onCreate:
editText.addTextChangedListener(new TextWatcher() {
  public void onTextChanged
  (CharSequence s, int start, int before, int count) {
    //check if exactly one char was added and it was an <enter>
    if (before==0 && count==1 && s.charAt(start)=='\n') {
    Intent intent=new Intent("enter")
    Integer startInteger=new Integer(start);
    intent.putExtra("Start", startInteger.toString()); // Add data
    mySendBroadcast(intent);
//in the BroadcastReceiver's onReceive:
int start=Integer.parseInt(intent.getStringExtra("Start"));
editText.getText().replace(start, start+1,""); //remove the <enter>
//respond to the <enter> here

यदि पाठ के किसी भी * इनपुट प्रकार (जैसे android:inputType="textCapSentences") का उपयोग किया जाता है, तो कैरिज-रिटर्न इनपुट से बाहर फ़िल्टर किए जाते हैं, इसलिए जब उपयोगकर्ता कुंजी दर्ज करता है तो onTextChanged () नहीं कहा जाता है।
jk7

1

इस सवाल का अभी तक जवाब नहीं दिया है

XML के बारे में

<android.support.design.widget.TextInputLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="@string/some_input_hint">

        <android.support.design.widget.TextInputEditText
            android:id="@+id/textinput"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:imeOptions="actionSend"
            android:inputType="text|textCapSentences|textAutoComplete|textAutoCorrect"/>
    </android.support.design.widget.TextInputLayout>

जावा एप

@OnEditorAction(R.id.textinput)
boolean onEditorAction(int actionId, KeyEvent key){
    boolean handled = false;
    if (actionId == EditorInfo.IME_ACTION_SEND || (key.getKeyCode() == KeyEvent.KEYCODE_ENTER)) {
        //do whatever you want
        handled = true;
    }
    return handled;
}

TextInputLayout और Butterknife: जीत!
जवाई

1

Kotlin का उपयोग करके मैंने एक फ़ंक्शन बनाया है जो कीबोर्ड सहित EditText के लिए "किए गए" जैसे सभी प्रकार के कार्यों को संभालता है, और इसे संशोधित करना संभव है और आप चाहें तो अन्य कुंजी भी संभाल सकते हैं:

private val DEFAULT_ACTIONS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT = arrayListOf(EditorInfo.IME_ACTION_SEND, EditorInfo.IME_ACTION_GO, EditorInfo.IME_ACTION_SEARCH, EditorInfo.IME_ACTION_DONE)
private val DEFAULT_KEYS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT = arrayListOf(KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_NUMPAD_ENTER)

fun EditText.setOnDoneListener(function: () -> Unit, onKeyListener: OnKeyListener? = null, onEditorActionListener: TextView.OnEditorActionListener? = null,
                               actionsToHandle: Collection<Int> = DEFAULT_ACTIONS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT,
                               keysToHandle: Collection<Int> = DEFAULT_KEYS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT) {
    setOnEditorActionListener { v, actionId, event ->
        if (onEditorActionListener?.onEditorAction(v, actionId, event) == true)
            return@setOnEditorActionListener true
        if (actionsToHandle.contains(actionId)) {
            function.invoke()
            return@setOnEditorActionListener true
        }
        return@setOnEditorActionListener false
    }
    setOnKeyListener { v, keyCode, event ->
        if (onKeyListener?.onKey(v, keyCode, event) == true)
            return@setOnKeyListener true
        if (event.action == KeyEvent.ACTION_DOWN && keysToHandle.contains(keyCode)) {
            function.invoke()
            return@setOnKeyListener true
        }
        return@setOnKeyListener false
    }
}

तो, नमूना उपयोग:

        editText.setOnDoneListener({
            //do something
        })

लेबल बदलने के लिए, मुझे लगता है कि यह कीबोर्ड ऐप पर निर्भर करता है, और यह आमतौर पर केवल परिदृश्य पर बदलता है, जैसा कि यहां लिखा गया है । वैसे भी, इसके लिए उदाहरण का उपयोग करें:

        editText.imeOptions = EditorInfo.IME_ACTION_DONE
        editText.setImeActionLabel("ASD", editText.imeOptions)

या, यदि आप XML में चाहते हैं:

    <EditText
        android:id="@+id/editText" android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:imeActionLabel="ZZZ" android:imeOptions="actionDone" />

और परिणाम (परिदृश्य में दिखाया गया है):

यहाँ छवि विवरण दर्ज करें


0

इन अवसाद को जोड़ें, और यह काम करना चाहिए:

import android.view.KeyEvent;
import android.view.View;
import android.widget.EditText;

0

जब उपयोगकर्ता रिटर्न कुंजी दबाएगा तो यह आपको कॉल करने योग्य फ़ंक्शन देगा।

fun EditText.setLineBreakListener(onLineBreak: () -> Unit) {
    val lineBreak = "\n"
    doOnTextChanged { text, _, _, _ ->
        val currentText = text.toString()

        // Check if text contains a line break
        if (currentText.contains(lineBreak)) {

            // Uncommenting the lines below will remove the line break from the string
            // and set the cursor back to the end of the line

            // val cleanedString = currentText.replace(lineBreak, "")
            // setText(cleanedString)
            // setSelection(cleanedString.length)

            onLineBreak()
        }
    }
}

प्रयोग

editText.setLineBreakListener {
    doSomething()
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.