Removed VIRTUAL_KEYBOARD check in TextInputPlugin

[matthew-carroll]

Removed VIRTUAL_KEYBOARD check in TextInputPlugin because it's blocking Espresso work and we don't know why it exists.

[adazh]

Matt, thanks for making this change! It will totally unblock us from implementing the typing text action in Espresso.

[tvolkert]

FYI @slightfoot

[tvolkert]

LGTM

[slightfoot]

@matthew-carroll did you verify this doesn't break soft and hard keyboard input on AVD and Genymotion?
I can't build the engine where atm, or I'd test it myself.

[matthew-carroll]

@slightfoot it was tested on a Pixel emulator, which is where I originally repro'd the bug that lead to this if-statement being introduced. There was no problem on the Pixel emulator now without the if-statement.

Is there any reason to believe that Genymotion would behave differently? And even if it does, is that something that Flutter would need to support, given that this conditional is blocking other work?

[slightfoot]

@matthew-carroll I managed to dig out one of my original mock from last year. I've run it on Genymotion with Android 9.0 API 28 and Android 4.1 API 16 without issue. I don't see virtual key events coming in, so I think it's Ok to remove. I include the mock source here as it might be helpful in someway.

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v7.app.AppCompatActivity;
import android.text.DynamicLayout;
import android.text.Editable;
import android.text.InputType;
import android.text.Layout;
import android.text.Selection;
import android.text.TextPaint;
import android.util.Log;
import android.view.KeyCharacterMap;
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.BaseInputConnection;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputMethodManager;
import java.util.HashMap;


/**
 * Created by Simon Lightfoot <simon@devangels.london> on 20/05/2018.
 */
public class InputTestActivity extends AppCompatActivity
{
	private static final String TAG = InputTestActivity.class.getSimpleName();

	@Override
	protected void onCreate(@Nullable Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);

		FakeInputView fakeInputView = new FakeInputView(this);
		fakeInputView.setBackgroundColor(Color.BLACK);
		setContentView(fakeInputView);
	}

	public static class FakeInputView extends View
	{
		private static final String TAG = FakeInputView.class.getSimpleName();
		private final InputMethodManager mImm;
		private final TextPaint mPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
		private final Paint mCursor = new Paint(Paint.ANTI_ALIAS_FLAG);
		private Editable mEditable;

		private DynamicLayout mTextLayout;

		public FakeInputView(Context context)
		{
			super(context);
			setFocusable(true);
			setFocusableInTouchMode(true);
			setClickable(true);
			mImm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
			mEditable = Editable.Factory.getInstance().newEditable("");
			mPaint.setColor(Color.WHITE);
			mPaint.setTextSize(50.0f);
			mCursor.setColor(Color.YELLOW);
			mCursor.setStrokeWidth(2.0f);
		}

		@SuppressLint("DrawAllocation")
		@Override
		protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
		{
			super.onMeasure(widthMeasureSpec, heightMeasureSpec);
			final int width = MeasureSpec.getSize(widthMeasureSpec);
			mTextLayout = new DynamicLayout(mEditable, mPaint, width, Layout.Alignment.ALIGN_NORMAL, 0.0f, 0.0f, false);
		}

		@Override
		public boolean performClick()
		{
			super.performClick();
			Log.w(TAG, "performClick");
			requestFocus();
			mImm.showSoftInput(this, 0);
			return true;
		}

		@Override
		public boolean onCheckIsTextEditor()
		{
			return true;
		}

		@Override
		protected void onDetachedFromWindow()
		{
			super.onDetachedFromWindow();
			Log.w(TAG, "onDetachedFromWindow");
			mImm.hideSoftInputFromWindow(getApplicationWindowToken(), 0);
		}

		private InputConnection mLastInputConnection;

		@Override
		public InputConnection onCreateInputConnection(EditorInfo outAttrs)
		{
			Log.w(TAG, "onCreateInputConnection");
			mLastInputConnection = new TestInputConnection(this, mEditable);
			outAttrs.inputType = InputType.TYPE_CLASS_TEXT;
			outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;
			outAttrs.initialSelStart = Selection.getSelectionStart(mEditable);
			outAttrs.initialSelEnd = Selection.getSelectionEnd(mEditable);
			return mLastInputConnection;
		}

		@Override
		protected void onDraw(Canvas canvas)
		{
			super.onDraw(canvas);
			mTextLayout.draw(canvas);
			final int offset = Selection.getSelectionStart(mEditable);
			if(offset != -1){
				final int line = mTextLayout.getLineForOffset(offset);
				final int top = mTextLayout.getLineTop(line);
				final int bottom = mTextLayout.getLineTop(line + 1);
				final int left = (int) mTextLayout.getPrimaryHorizontal(offset);
				canvas.drawLine(left, top, left, bottom, mCursor);
			}
			//canvas.drawText(mEditable, 0, mEditable.length(), 0, 100, mPaint);
		}

		@Override
		public boolean onKeyUp(int keyCode, KeyEvent event)
		{
			boolean isVirtual = (event.getDeviceId() == KeyCharacterMap.VIRTUAL_KEYBOARD);
			Log.d(TAG, "onKeyUp: device=" + isVirtual);
			Log.d(TAG, "onKeyUp: " + keyCode + ", event: " + event.toString());
			if(mImm.isAcceptingText() && mLastInputConnection != null){
				mLastInputConnection.sendKeyEvent(event);
				return true;
			}
			return super.onKeyUp(keyCode, event);
		}

		@Override
		public boolean onKeyDown(int keyCode, KeyEvent event)
		{
			boolean isVirtual = (event.getDeviceId() == KeyCharacterMap.VIRTUAL_KEYBOARD);
			Log.d(TAG, "onKeyDown: device=" + isVirtual);
			Log.d(TAG, "onKeyDown: " + keyCode + ", event: " + event.toString());
			if(mImm.isAcceptingText() && mLastInputConnection != null){
				mLastInputConnection.sendKeyEvent(event);
				return true;
			}
			return super.onKeyDown(keyCode, event);
		}
	}


	public static class TestInputConnection extends BaseInputConnection
	{
		private final View mView;
		private final Editable mEditable;
		private int mBatchCount;
		private InputMethodManager mImm;

		public TestInputConnection(View view, Editable editable)
		{
			super(view, true);
			mView = view;
			mEditable = editable;
			mBatchCount = 0;
			mImm = (InputMethodManager) view.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
		}

		// Send the current state of the editable to Flutter.
		private void updateEditingState()
		{
			// If the IME is in the middle of a batch edit, then wait until it completes.
			if(mBatchCount > 0){
				return;
			}

			int selectionStart = Selection.getSelectionStart(mEditable);
			int selectionEnd = Selection.getSelectionEnd(mEditable);
			int composingStart = BaseInputConnection.getComposingSpanStart(mEditable);
			int composingEnd = BaseInputConnection.getComposingSpanEnd(mEditable);

			mImm.updateSelection(mView, selectionStart, selectionEnd, composingStart, composingEnd);

			HashMap<Object, Object> state = new HashMap<Object, Object>();
			state.put("text", mEditable.toString());
			state.put("selectionBase", selectionStart);
			state.put("selectionExtent", selectionEnd);
			state.put("composingBase", composingStart);
			state.put("composingExtent", composingEnd);
			//mFlutterChannel.invokeMethod("TextInputClient.updateEditingState", Arrays.asList(mClient, state));]
			Log.d("INPUT", "### " + mEditable.toString());
			mView.invalidate();
		}

		@Override
		public Editable getEditable()
		{
			return mEditable;
		}

		@Override
		public boolean beginBatchEdit()
		{
			mBatchCount++;
			return super.beginBatchEdit();
		}

		@Override
		public boolean endBatchEdit()
		{
			boolean result = super.endBatchEdit();
			mBatchCount--;
			updateEditingState();
			return result;
		}

		@Override
		public boolean commitText(CharSequence text, int newCursorPosition)
		{
			boolean result = super.commitText(text, newCursorPosition);
			updateEditingState();
			return result;
		}

		@Override
		public boolean deleteSurroundingText(int beforeLength, int afterLength)
		{
			if(Selection.getSelectionStart(mEditable) == -1 || Selection.getSelectionStart(mEditable) == -1){
				return true;
			}

			boolean result = super.deleteSurroundingText(beforeLength, afterLength);
			updateEditingState();
			return result;
		}

		@Override
		public boolean setComposingRegion(int start, int end)
		{
			boolean result = super.setComposingRegion(start, end);
			updateEditingState();
			return result;
		}

		@Override
		public boolean setComposingText(CharSequence text, int newCursorPosition)
		{
			boolean result;
			if(text.length() == 0){
				result = super.commitText(text, newCursorPosition);
			}
			else{
				result = super.setComposingText(text, newCursorPosition);
			}
			updateEditingState();
			return result;
		}

		@Override
		public boolean setSelection(int start, int end)
		{
			boolean result = super.setSelection(start, end);
			updateEditingState();
			return result;
		}

		@Override
		public boolean sendKeyEvent(KeyEvent event)
		{
			if(event.getAction() == KeyEvent.ACTION_DOWN){
				final int keyCode = event.getKeyCode();
				if(keyCode == KeyEvent.KEYCODE_DEL){
					int selStart = Math.max(0, Selection.getSelectionStart(mEditable));
					int selEnd = Selection.getSelectionEnd(mEditable);
					if(selEnd > selStart){
						// Delete the selection.
						Selection.setSelection(mEditable, selStart);
						mEditable.delete(selStart, selEnd);
						updateEditingState();
						return true;
					}
					else if(selStart > 0){
						// Delete to the left of the cursor.
						int newSel = Math.max(selStart - 1, 0);
						Selection.setSelection(mEditable, newSel);
						mEditable.delete(newSel, selStart);
						updateEditingState();
						return true;
					}
				}
				else if(keyCode == KeyEvent.KEYCODE_DPAD_LEFT){
					int selStart = Selection.getSelectionStart(mEditable);
					int newSel = Math.max(selStart - 1, 0);
					setSelection(newSel, newSel);
					return true;
				}
				else if(keyCode == KeyEvent.KEYCODE_DPAD_RIGHT){
					int selStart = Selection.getSelectionStart(mEditable);
					int newSel = Math.min(selStart + 1, mEditable.length());
					setSelection(newSel, newSel);
					return true;
				}
				else{
					int character = event.getUnicodeChar();
					if(character != 0){
						int selStart = Math.max(0, Selection.getSelectionStart(mEditable));
						mEditable.insert(selStart, String.valueOf((char) character));
						setSelection(selStart + 1, selStart + 1);
						updateEditingState();
					}
					return true;
				}
			}
			return false;
		}

		@Override
		public boolean performEditorAction(int actionCode)
		{
			/*switch(actionCode){
				case EditorInfo.IME_ACTION_NONE:
					mFlutterChannel.invokeMethod("TextInputClient.performAction",
						Arrays.asList(mClient, "TextInputAction.newline"));
					break;
				default:
				case EditorInfo.IME_ACTION_DONE:
					mFlutterChannel.invokeMethod("TextInputClient.performAction",
						Arrays.asList(mClient, "TextInputAction.done"));
					break;
			}*/
			return true;
		}
	}
}

[matthew-carroll]

Great. Thanks for checking on that @slightfoot. I'll go ahead and merge.