Handling Enter Key on EditText (Kotlin, Android)

Question

How to handle Enter Key on EditText in Android Kotlin Language?

Answer 1

I used the when-expression to check if the enter-button was clicked

edittext.setOnKeyListener { v, keyCode, event ->
        
        when {

            //Check if it is the Enter-Key,      Check if the Enter Key was pressed down
            ((keyCode == KeyEvent.KEYCODE_ENTER) && (event.action == KeyEvent.ACTION_DOWN)) -> {
                
                
                //perform an action here e.g. a send message button click
                sendButton.performClick()

                //return true
                return@setOnKeyListener true
            }
            else -> false
        }


    }

Answer 2

This code handles both hardware and software enter key

Step 1 [Important] Specify in XML two attributes:

1. android:imeOptions in order to show the user the correct button to press
2. android:inputType in order to tell the user what text he has to input, numbers text etc

Step 2 Add in your Kotlin file:

yourEditText.setOnEditorActionListener { _, keyCode, event ->
        if (((event?.action ?: -1) == KeyEvent.ACTION_DOWN)
          || keyCode == EditorInfo.IME_PUT_THE_ACTION_YOU_HAVE_SET_UP_IN_STEP_1) {
          
             // Your code here

            return@setOnEditorActionListener true
        }
        return@setOnEditorActionListener false
}

The reason I choose setOnEditorActionListener is because it handles better this action. According to Docs:

   /**
     * Set a special listener to be called when an action is performed
     * on the text view.  This will be called when the enter key is pressed,
     * or when an action supplied to the IME is selected by the user.  Setting
     * this means that the normal hard key event will not insert a newline
     * into the text view, even if it is multi-line; holding down the ALT
     * modifier will, however, allow the user to insert a newline character.
     */

Answer 3

I've created a very general solution for this:

        private val DEFAULT_KEYS_TO_HANDLE_AS_DONE_FOR_EDIT_TEXT =
            arrayListOf(KeyEvent.KEYCODE_ENTER, KeyEvent.KEYCODE_NUMPAD_ENTER)
        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
            )

        @JvmOverloads
        fun EditText.setOnDoneListener(
            function: Runnable?, onKeyListener: View.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
        ) {
            //    Log.d("AppLog", "setOnDoneListener caller:${Thread.currentThread().stackTrace[4]}")
            setOnEditorActionListener { v, actionId, event ->
                if (onEditorActionListener?.onEditorAction(v, actionId, event) == true)
                    return@setOnEditorActionListener true
                if (actionsToHandle.contains(actionId)) {
                    function?.run()
                    return@setOnEditorActionListener function != null
                }
                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?.run()
                    return@setOnKeyListener function != null
                }
                return@setOnKeyListener false
            }
        }

Answer 4

The logic is that:

1. In every pair of factors (m_1, m_2), either m_1 <= m_2 or m_2 <= m_1
2. If a number n has a multiplicative factor m_1, it also has a factor m_2 = n / m_1. So factors are actually paired: m with n/m.
3. Due to (1.+2.), if m is a factor n such that m > n/m, then n/m must also be a factor of n such that (n/m) <= n/(n/m) .

So it's enough to search for the "small" factors, to verify there are no larger ones.