Android - 편집 텍스트에서 "Enter" 처리

Android - 편집 텍스트에서 "Enter" 처리

사용자가 입력할 때 누르는 것을 처리할 수 있는 것인지 궁금합니다.EditText eventonSubmit HTML 벤것은같과 입니다.

또한 "완료" 단추에 다른 레이블을 지정하고(예: "이동") 클릭 시 특정 작업을 수행하는(예: "제출") 가상 키보드를 조작하는 방법이 있는지 궁금합니다.

onSubmit HTML 이벤트와 같은 EditText를 입력하면서 사용자가 누르는 것을 처리할 수 있는 방법이 있는지 궁금합니다.

네.

또한 "완료" 단추에 다른 레이블을 지정하고(예: "이동") 클릭 시 특정 작업을 수행하는(예: "제출") 가상 키보드를 조작하는 방법이 있는지 궁금합니다.

또한 그렇습니다.

및 특성과 메소드를 모두 확인할 수 있습니다.TextView.

완료 단추의 텍스트를 사용자 정의 문자열로 변경하려면 다음을 사용합니다.

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

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

이게 당신이 할 일 입니다.안드로이드 개발자의 샘플 코드 '블루투스 채팅'에도 숨겨져 있습니다.예제라고 표시된 굵게 표시된 부분을 사용자 고유의 변수 및 방법으로 대체합니다.

먼저, 돌아가기 단추가 특별한 작업을 수행할 기본 활동으로 필요한 항목을 가져옵니다.

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

이제 TextView 유형의 변수를 만듭니다.반환 키(여기서는 exampleListener를 사용함)에 대한 편집자 작업 수신기 하나;

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

그러면 당신은 청취자에게 리턴 버튼을 눌렀을 때 해야 할 일에 대해 두 가지를 말해야 합니다.여기서는 텍스트 편집에 대해 설명하는 내용(예시 보기 사용)을 알고 Enter 키(예시_confirm())를 눌렀을 때 수행할 작업을 알아야 합니다.활동에서 마지막 또는 유일한 텍스트 편집인 경우, 제출(또는 확인, 보내기, 저장 등) 단추의 onClick 방법과 동일한 작업을 수행해야 합니다.

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

마지막으로 수신기를 설정합니다(대부분 onCreate 메서드에서).

exampleView.setOnEditorActionListener(exampleListener);

이 페이지에서는 이 작업을 수행하는 방법을 정확하게 설명합니다.

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

Android:imeOptions를 설정한 다음 EditorAction에서 actionId를 확인합니다.따라서 timeOptions를 'actionDone'으로 설정하면 한 EditorAction에서 'actionId == EditorInfo.IME_ACTION_DONE'을 확인할 수 있습니다.또한 Android:inputType을 설정해야 합니다.

재료 설계를 사용하는 경우 텍스트 입력 편집 텍스트에 코드를 입력합니다.

다음은 위에 연결된 예제의 텍스트 편집입니다.

<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) 기능을 사용하여 프로그래밍 방식으로 설정할 수도 있습니다.위에 링크된 예제의 OnEditor Action Listener는 다음과 같습니다.

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

하드웨어 키보드는 항상 이벤트 입력을 허용하지만 소프트웨어 키보드는 다른 작업을 반환합니다.단일 줄 편집 텍스트의 ID 및 null입니다.이 코드는 편집 텍스트 또는 키보드 유형에 관계없이 이 수신기가 설정된 편집 텍스트에서 입력을 누를 때마다 응답합니다.

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에서 Enter 키의 기본 모양은 구부러진 화살표 키패드를 제공합니다.마지막 EditText에서 singleLine=true인 경우 키는 DONE으로 표시되고 EditText에서는 NEXT로 표시됩니다.기본적으로 이 동작은 모든 바닐라, 안드로이드 및 구글 에뮬레이터에서 일관됩니다.ScrollHorizontal 속성은 아무런 차이가 없습니다.null 테스트는 소프트 입력에 대한 전화기의 응답이 제조업체에 맡겨지고 에뮬레이터에서도 바닐라 레벨 16 에뮬레이터가 다중 행의 긴 소프트 입력에 응답하고 actionId가 NEXT이고 이벤트에 대한 null인 수평 편집 텍스트를 스크롤하기 때문에 중요합니다.

이것이 1년 전의 것이라는 것을 알지만, 저는 이것이 텍스트 편집에 완벽하게 작동한다는 것을 발견했습니다.

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

텍스트와 공간을 제외한 모든 것을 방지합니다.탭, "반품"("\n") 등을 할 수 없었습니다.

xml에서 imeOptions 속성을 editText에 추가합니다.

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

그런 다음 Java 코드에서 OnEditorActionListener를 동일한 EditText에 추가합니다.

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

다음은 설명입니다. TimeOptions=actionDone은 EnterKey에 "actionDone"을 할당합니다.키보드의 EnterKey가 "Enter"에서 "Done"으로 변경됩니다.Enter Key를 누르면 이 작업이 트리거되므로 이 작업을 처리할 수 있습니다.

저도 비슷한 목적이 있었습니다.자동 완성에서 키보드의 "Enter" 키(사용자 지정)를 누르는 문제를 해결하려고 합니다.텍스트 보기를 확장하는 텍스트 보기입니다.위와 다른 솔루션을 시도해보니 작동하는 것 같았지만, 기기의 입력 유형(AOKP ROM이 포함된 넥서스 4)을 스위프트키 3(완벽하게 작동하는 위치)에서 표준 안드로이드 키보드(청취자에서 코드를 처리하는 대신 "Enter" 키를 누른 후 새 줄을 입력했을 때 몇 가지 문제가 발생했습니다.이 문제를 처리하는 데 시간이 좀 걸렸지만 어떤 입력 유형을 사용하든 모든 상황에서 작동할지 모르겠습니다.

제 해결책은 다음과 같습니다.

xml에서 TextView의 입력 유형 특성을 "text"로 설정합니다.

android:inputType="text"

키보드에서 "Enter" 키의 레이블을 사용자 정의합니다.

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

텍스트 보기에 OnEditor 작업 수신기를 설정합니다.

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

저는 이것이 다른 사람들이 제가 가진 문제들을 피하는 데 도움이 되기를 바랍니다. 왜냐하면 그들은 저를 거의 미치게 만들었기 때문입니다.

Chad의 답변(거의 완벽하게 작동함)에 대한 부록처럼, 코드가 두 번 실행되지 않도록 키 이벤트 작업 유형에 대한 검사를 추가해야 한다는 것을 알게 되었습니다(키 업 시와 키 다운 시).

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

반복 작업 이벤트(Enter 키를 누른 상태) 등에 대한 자세한 내용은 http://developer.android.com/reference/android/view/KeyEvent.html 를 참조하십시오.

당신도 할 수 있습니다.

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

DataBinding을 사용하는 경우 https://stackoverflow.com/a/52902266/2914140 및 https://stackoverflow.com/a/67933283/2914140 을 참조하십시오.

bindings.kt:

@BindingAdapter("onEditorEnterAction")
fun EditText.onEditorEnterAction(callback: OnActionListener?) {
    if (callback == null) setOnEditorActionListener(null)
    else setOnEditorActionListener { v, actionId, event ->
        val imeAction = when (actionId) {
            EditorInfo.IME_ACTION_DONE,
            EditorInfo.IME_ACTION_SEND,
            EditorInfo.IME_ACTION_GO -> true
            else -> false
        }

        val keydownEvent = event?.keyCode == KeyEvent.KEYCODE_ENTER 
            && event.action == KeyEvent.ACTION_DOWN

        if (imeAction or keydownEvent) {
            callback.enterPressed()
            return@setOnEditorActionListener true
        }
        return@setOnEditorActionListener false
    }
}

interface OnActionListener {
    fun enterPressed()
}

layout.xml:

<data>
    <variable
        name="viewModel"
        type="YourViewModel" />
</data>    

<EditText
    android:imeOptions="actionDone|actionSend|actionGo"
    android:singleLine="true"
    android:text="@={viewModel.message}"
    app:onEditorEnterAction="@{() -> viewModel.send()}" />

먼저, 당신은 EditText를 설정하고 키를 눌러야 합니다.

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

}

둘째, TextView의 텍스트를 설정하는 이벤트와 같이 키를 누른 상태에서 이벤트를 정의합니다.

@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;

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

잘 작동합니다.
를 숨깁니다.

완벽하게 작동하는

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

        }
    });
}

}

완벽하게 작동하는

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" />

이것은 효과가 있을 것입니다.

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

필요한 모듈을 가져올 수 있도록 편집기에 이 코드를 입력합니다.

 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.setOnEditorActionListener((v, actionId, event) -> {
       if (actionId == EditorInfo.IME_ACTION_DONE) {
          // Do some things      
          return true;
       }
       return false;
});

당신은 그곳에서 행동 목록을 볼 수 있습니다.

예:

IME_ACTION_GO

IME_ACTION_SEARCH

IME_ACTION_SEND

이것은 LG 안드로이드 폰에서 잘 작동합니다.그것은 막습니다.ENTER기타 특수 문자를 일반 문자로 해석해야 합니다. Next또는Done버튼이 자동으로 나타납니다.ENTER예상대로 작동합니다.

edit.setInputType(InputType.TYPE_CLASS_TEXT);

다음은 간단한 정적 기능을 사용하여 데이터를 저장할 수 있는 기능입니다.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;
        }
    };
}

텍스트 필드의 입력 유형은 다음과 같아야 합니다.textCommonsWare에서 말한 것을 실행하기 위해.방금 이 모든 것을 시도했지만, 평가판 이전에는 inputType이 없었고 아무 것도 작동하지 않았습니다. Enter는 소프트 엔터로 계속 등록했습니다.나 뒤에inputType = textImeLabel이 작동한 세트를 포함한 모든 것.

예: android:inputType="text"

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

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" />

그 결과(경관에 표시):

람다 식을 사용하여 프레스 입력에 반응하는 Kotlin 솔루션:

        editText.setOnKeyListener { _, keyCode, event ->
            if(keyCode == KeyEvent.KEYCODE_ENTER && event.action==KeyEvent.ACTION_DOWN){
            //react to enter press here
            }
            true
        }

이벤트 유형을 추가로 확인하지 않으면 한 번 누를 때 이 수신기가 두 번 호출됩니다(ACTION_DOWN에 한 번, ACTION_UP에 한 번).

편집 텍스트에서 <입력>에 응답하는 신뢰할 수 있는 방법은 TextWatcher, Local Broadcast Manager 및 BroadcastReceiver를 사용하는 것입니다.Local Broadcast Manager를 사용하려면 v4 지원 라이브러리를 추가해야 합니다.완전한 간결한 코드 예제 때문에 저는 vogella.com : 7.3 "Local Broadcast Manager가 있는 로컬 브로드캐스트 이벤트"의 튜토리얼을 사용합니다.앞의 OnTextChanged는 변경 전의 변경 끝의 인덱스입니다. >; - 시작.TextWatcher에서 UI 스레드가 편집을 업데이트하고 있을 때텍스트는 편집 가능하므로 UI 스레드의 editText 업데이트가 완료되면 BroadcastReceiver를 깨우기 위해 Intent를 보냅니다.

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

이 질문은 버터나이프로 아직 답변되지 않았습니다.

레이아웃 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>

JAVA APP

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

"txtid"를 편집 텍스트 ID로 바꿉니다.

EditText txtinput;
txtinput=findViewById(R.id.txtid)    
txtinput.setOnEditorActionListener(new TextView.OnEditorActionListener() {
        @Override
        public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
            if ((event != null && (event.getKeyCode() == KeyEvent.KEYCODE_ENTER))     || (actionId == EditorInfo.IME_ACTION_DONE)) {
                
                //Code for the action you want to proceed with.

                InputMethodManager inputManager = (InputMethodManager)
                        getSystemService(Context.INPUT_METHOD_SERVICE);

                 inputManager.hideSoftInputFromWindow(getCurrentFocus().getWindowToken(),
                        InputMethodManager.HIDE_NOT_ALWAYS);
            }
            return false;
        }
    });

다음과 같은 종속성을 추가하면 작동합니다.

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

사용자가 리턴 키를 누르면 호출 가능한 기능이 제공됩니다.

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

새 MaterialAlertDialogBuilder를 확장하여 이에 대한 도우미 클래스를 만들었습니다.

사용.

new InputPopupBuilder(context)
        .setInput(R.string.send, 
                R.string.enter_your_message, 
                text -> sendFeedback(text, activity))
        .setTitle(R.string.contact_us)
        .show();

코드

public class InputPopupBuilder extends MaterialAlertDialogBuilder {

    private final Context context;
    private final AppCompatEditText input;

    public InputPopupBuilder(Context context) {
        super(context);
        this.context = context;
        input = new AppCompatEditText(context);
        input.setInputType(InputType.TYPE_CLASS_TEXT);
        setView(input);
    }

    public InputPopupBuilder setInput(int actionLabel, int hint, Callback callback) {
        input.setHint(hint);
        input.setImeActionLabel(context.getString(actionLabel), KeyEvent.KEYCODE_ENTER);
        input.setOnEditorActionListener((TextView.OnEditorActionListener) (v, actionId, event) -> {
            if (actionId == EditorInfo.IME_NULL
                    && event.getAction() == KeyEvent.ACTION_DOWN) {
                Editable text = input.getText();
                if (text != null) {
                    callback.onClick(text.toString());
                    return true;
                }
            }
            return false;
        });

        setPositiveButton(actionLabel, (dialog, which) -> {
            Editable text = input.getText();
            if (text != null) {
                callback.onClick(text.toString());
            }
        });

        return this;
    }

    public InputPopupBuilder setText(String text){
        input.setText(text);
        return this;
    }

    public InputPopupBuilder setInputType(int inputType){
        input.setInputType(inputType);
        return this;
    }

    public interface Callback {
        void onClick(String text);
    }
}

요구 사항

implementation 'com.google.android.material:material:1.3.0-alpha04'

언급URL : https://stackoverflow.com/questions/1489852/android-handle-enter-in-an-edittext