How to have both singleLine="false" AND imeOptions="actionNext" for EditText?

Question

Background

Suppose you have multiple EditText instances.

You wish to be able to switch between them using the next button of the keyboard (that is used as a replacement of the ENTER key).

Each EditText might have a long content that can be shown in multiple lines (suppose I wish to limit it to 3 lines, and if the text is still too long, use ellipsize).

The Problem

As I've noticed, both TextView and EditText have really weird behaviors and lack on some basic features. One of them is that if you wish to go to the next view, you need to have a singleLine="true" for each of the EditText instances.

What I've tried

I've tried the next xml layout (and other trials), but it doesn't work :

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
  android:layout_height="match_parent" android:orientation="vertical"
  android:gravity="center" tools:context=".MainActivity">

  <EditText android:id="@+id/editText1" android:layout_width="wrap_content"
    android:layout_height="wrap_content" android:nextFocusDown="@+id/editText2"
    android:singleLine="false" android:imeOptions="actionNext"
    android:maxLines="3" android:ellipsize="end"
    android:text="@string/very_long_text" />

  <EditText android:id="@+id/editText2" android:layout_width="wrap_content"
    android:layout_height="wrap_content" android:nextFocusDown="@+id/editText3"
    android:singleLine="false" android:imeOptions="actionNext"
    android:maxLines="3" android:ellipsize="end"
    android:text="@string/very_long_text" />

  <EditText android:id="@+id/editText3" android:layout_width="wrap_content"
    android:layout_height="wrap_content" android:singleLine="false"
    android:maxLines="3" android:ellipsize="end"
    android:text="@string/very_long_text"/>

</LinearLayout>

I've also tried the next code, but it's really a silly solution:

...
final EditText editText=(EditText)findViewById(R.id.editText1);
editText.setOnEditorActionListener(new OnEditorActionListener()
  {
    @Override
    public boolean onEditorAction(final TextView v,final int actionId,final KeyEvent event)
      {
      if(actionId==EditorInfo.IME_NULL)
        {
        final View view=findViewById(editText.getNextFocusDownId());
        if(view!=null)
          {
          view.requestFocus();
          return true;
          }
        }
      return false;
      }
  });

It works, but it's a silly solution because of the next reasons:

• I need to set this behavior per each EditText (or extend EditText and add some kind of logic there).
• It doesn't show "next" for the key in the soft keyboard. Instead it shows the ENTER key.
• Playing with the XML didn't allow me to set the ellipsize at the end and i kept getting a scrolling behavior.

The Question

Is there a better way to achieve this? One that is elegant, works and shows the "next" key instead of the ENTER key ?

Answer 1

For an answer here- you can set them both if you want. However forcing it to actually display next and have the enter key act as a next key depends on the keyboard. I know at Swype we purposely overrode any text field that was multi-line to ALWAYS display the enter key and act as a newline and NEVER show the next key. There's no way to force this to work like you want across all keyboards.

Answer 2

I find this question similar to the Multi-line EditText with Done action button post. Since I have already written an answer for that, let me put it in again. Though, I will be able to answer only your first 2 points, for I have yet to use Ellipsize (I think it should be relatively easy once you are set up with the next button part).

The following Java Code can be used to change the Keyboard Enter to "DONE"/"NEXT" button:

////////////Code to Hide SoftKeyboard on Enter (DONE) Press///////////////
editText1.setRawInputType(InputType.TYPE_CLASS_TEXT|InputType.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD|InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS);
editText1.setImeActionLabel("DONE",EditorInfo.IME_ACTION_DONE);              //Set Return Carriage as "DONE"
editText1.setImeOptions(EditorInfo.IME_ACTION_DONE);

editText1.setOnEditorActionListener(new TextView.OnEditorActionListener() {
    @Override
    public boolean onEditorAction(TextView v, 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
                        // This one is useful for the new list case, when there are no existing ListItems
                        editText1.clearFocus();

                        editText2.requestFocus();       //Call the next Edit_Text into Focus  
                        //Comment above requestFocus() for edit_text3

                        //Hiding SoftKeyboard. Uncomment it for edit_text3
                        //InputMethodManager inputMethodManager = (InputMethodManager)  getActivity().getSystemService(Activity.INPUT_METHOD_SERVICE);
                        //inputMethodManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(), 0);

                    }

                    else if (actionId == EditorInfo.IME_ACTION_NEXT) {
                        // Capture soft enters in other singleLine EditTexts
                    } else if (actionId == EditorInfo.IME_ACTION_GO) {
                    } else {
                        // Let the system handle all other null KeyEvents
                        return false;
                    }
                } 
        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 the key is first pressed.
                    } else {
                        // We consume the event when the key is released.
                        return true;
                    }
                } 
        else {
                    // We let the system handle it when the listener is triggered by something that
                    // wasn't an enter.
                    return false;
                }
                return true;
        }
});