src/com/android/inputmethod/leanback/LeanbackKeyboardController.java - platform/packages/inputmethods/LeanbackIME - Git at Google

 /*
  * Copyright (C) 2019 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License
  */

 package com.android.inputmethod.leanback;

 import android.graphics.PointF;
 import android.inputmethodservice.InputMethodService;
 import android.inputmethodservice.Keyboard;
 import android.inputmethodservice.Keyboard.Key;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.inputmethod.EditorInfo;

 import com.android.inputmethod.leanback.LeanbackKeyboardContainer.KeyFocus;

 import java.util.ArrayList;
 /**
  * Holds logic for the keyboard views. This includes things like when to
  * snap, when to switch keyboards, etc. It provides callbacks for when actions
  * that need to be handled at the IME level occur (when text is entered, when
  * the action should be performed).
  */
 public class LeanbackKeyboardController implements LeanbackKeyboardContainer.VoiceListener,
         LeanbackKeyboardContainer.DismissListener {
     private static final String TAG = "LbKbController";
     private static final boolean DEBUG = false;

     /**
      * The amount of time to block movement after a button down was detected.
      */
     public static final int CLICK_MOVEMENT_BLOCK_DURATION_MS = 500;

     /**
      * The minimum distance in pixels before the view will transition to the
      * move state.
      */
     public float mResizeSquareDistance;

     // keep track of the most recent key changes and their times so we can
     // revert motion caused by clicking
     private static final int KEY_CHANGE_HISTORY_SIZE = 10;
     private static final long KEY_CHANGE_REVERT_TIME_MS = 100;

     /**
      * This listener reports high level actions that have occurred, such as
      * text entry (from keys or voice) or the action button being pressed.
      */
     public interface InputListener {
         public static final int ENTRY_TYPE_STRING = 0;
         public static final int ENTRY_TYPE_BACKSPACE = 1;
         public static final int ENTRY_TYPE_SUGGESTION = 2;
         public static final int ENTRY_TYPE_LEFT = 3;
         public static final int ENTRY_TYPE_RIGHT = 4;
         public static final int ENTRY_TYPE_ACTION = 5;
         public static final int ENTRY_TYPE_VOICE = 6;
         public static final int ENTRY_TYPE_DISMISS = 7;
         public static final int ENTRY_TYPE_VOICE_DISMISS = 8;

         /**
          * Sent when the user has selected something that should affect the text
          * field, such as entering a character, selecting the action, or
          * finishing a voice action.
          *
          * @param type The type of key selected
          * @param keyCode the key code of the key if applicable
          * @param result The text entered if applicable
          */
         public void onEntry(int type, int keyCode, CharSequence result);
     }

     private static final class KeyChange {
         public long time;
         public PointF position;

         public KeyChange(long time, PointF position) {
             this.time = time;
             this.position = position;
         }
     }

     private class DoubleClickDetector {
         final long DOUBLE_CLICK_TIMEOUT_MS = 200;
         long mFirstClickTime = 0;
         boolean mFirstClickShiftLocked;

         public void reset() {
             mFirstClickTime = 0;
         }

         public void addEvent(long currTime) {
             if (currTime - mFirstClickTime > DOUBLE_CLICK_TIMEOUT_MS) {
                 mFirstClickTime = currTime;
                 mFirstClickShiftLocked = mContainer.isCapsLockOn();
                 commitKey();
             } else {
                 mContainer.onShiftDoubleClick(mFirstClickShiftLocked);
                 reset();
             }
         }
     }

     private DoubleClickDetector mDoubleClickDetector = new DoubleClickDetector();

     private View.OnLayoutChangeListener mOnLayoutChangeListener
             = new View.OnLayoutChangeListener() {

                 @Override
                 public void onLayoutChange(View v, int left, int top, int right, int bottom,
                         int oldLeft, int oldTop, int oldRight, int oldBottom) {
                     int w = right - left;
                     int h = bottom - top;
                     int oldW = oldRight - oldLeft;
                     int oldH = oldBottom - oldTop;
                     if (w > 0 && h > 0) {
                         if (w != oldW || h != oldH) {
                             initInputView();
                         }
                     }
                 }
             };

     private InputMethodService mContext;
     private InputListener mInputListener;
     private LeanbackKeyboardContainer mContainer;

     private LeanbackKeyboardContainer.KeyFocus mDownFocus =
             new LeanbackKeyboardContainer.KeyFocus();
     private LeanbackKeyboardContainer.KeyFocus mTempFocus =
             new LeanbackKeyboardContainer.KeyFocus();

     ArrayList<KeyChange> mKeyChangeHistory = new ArrayList<KeyChange>(KEY_CHANGE_HISTORY_SIZE + 1);
     private PointF mTempPoint = new PointF();

     private boolean mKeyDownReceived = false;
     private boolean mLongPressHandled = false;
     private KeyFocus mKeyDownKeyFocus;
     private int mMoveCount;

     public LeanbackKeyboardController(InputMethodService context, InputListener listener) {
         this(context, listener, new LeanbackKeyboardContainer(context));
     }

     LeanbackKeyboardController(InputMethodService context, InputListener listener,
             LeanbackKeyboardContainer container) {
         mContext = context;
         mResizeSquareDistance = context.getResources().getDimension(R.dimen.resize_move_distance);
         mResizeSquareDistance *= mResizeSquareDistance;
         mInputListener = listener;
         setKeyboardContainer(container);
         mContainer.setVoiceListener(this);
         mContainer.setDismissListener(this);
     }

     /**
      * This method is called when we start the input at a NEW input field.
      */
     public void onStartInput(EditorInfo attribute) {
         if (mContainer != null) {
             mContainer.onStartInput(attribute);
             initInputView();
         }
     }

     /**
      * This method is called by whenever we bring up the IME at an input field.
      */
     public void onStartInputView() {
         mKeyDownReceived = false;
         if (mContainer != null) {
             mContainer.onStartInputView();
         }
         mDoubleClickDetector.reset();
     }

     /**
      * This method sets the pixel positions in mSpaceTracker to match the
      * current KeyFocus in {@link LeanbackKeyboardContainer} This method is called
      * when the keyboard layout is complete, after
      * {@link LeanbackKeyboardContainer.onInitInputView}, to initialize the starting
      * position of mSpaceTracker; and in onUp to reset the pixel position in
      * mSpaceTracker.
      */
     private void updatePositionToCurrentFocus() {
         PointF currPosition = getCurrentKeyPosition();
         if (currPosition != null) {
         }
     }

     private void initInputView() {
         mContainer.onInitInputView();
         updatePositionToCurrentFocus();
     }

     private PointF getCurrentKeyPosition() {
         if (mContainer != null) {
             LeanbackKeyboardContainer.KeyFocus initialKeyInfo = mContainer.getCurrFocus();
             return new PointF(initialKeyInfo.rect.centerX(), initialKeyInfo.rect.centerY());
         }
         return null;
     }

     private void performBestSnap(long time) {
         KeyFocus focus = mContainer.getCurrFocus();
         mTempPoint.x = focus.rect.centerX();
         mTempPoint.y = focus.rect.centerY();
         PointF bestSnap = getBestSnapPosition(mTempPoint, time);
         mContainer.getBestFocus(bestSnap.x, bestSnap.y, mTempFocus);
         mContainer.setFocus(mTempFocus);
         updatePositionToCurrentFocus();
     }

     private PointF getBestSnapPosition(PointF currPoint, long currTime) {
         if (mKeyChangeHistory.size() <= 1) {
             return currPoint;
         }
         for (int i = 0; i < mKeyChangeHistory.size() - 1; i++) {
             KeyChange change = mKeyChangeHistory.get(i);
             KeyChange nextChange = mKeyChangeHistory.get(i + 1);
             if (currTime - nextChange.time < KEY_CHANGE_REVERT_TIME_MS) {
                 if (DEBUG) {
                     Log.d(TAG, "Reverting keychange to " + change.position.toString());
                 }
                 // Return the oldest key change within the revert window and
                 // clear all key changes
                 currPoint = change.position;
                 // on a revert, clear the history and add the reverting point.
                 // This way the reverted point will be preferred if there's
                 // another fast change before the next call.
                 mKeyChangeHistory.clear();
                 mKeyChangeHistory.add(new KeyChange(currTime, currPoint));
                 break;
             }
         }
         return currPoint;
     }

     public void setKeyboardContainer(LeanbackKeyboardContainer container) {
         mContainer = container;
         container.getView().addOnLayoutChangeListener(mOnLayoutChangeListener);
     }

     public View getView() {
         if (mContainer != null) {
             return mContainer.getView();
         }
         return null;
     }

     public boolean areSuggestionsEnabled() {
         if (mContainer != null) {
             return mContainer.areSuggestionsEnabled();
         }
         return false;
     }

     public boolean enableAutoEnterSpace() {
         if (mContainer != null) {
             return mContainer.enableAutoEnterSpace();
         }
         return false;
     }

     public boolean onKeyDown(int keyCode, KeyEvent event) {
         mDownFocus.set(mContainer.getCurrFocus());
         // this will handle other events, e.g. hardware keyboard
         if (isEnterKey(keyCode)) {
             mKeyDownReceived = true;
             // first keyDown
             if (event.getRepeatCount() == 0) {
                 mContainer.setTouchState(LeanbackKeyboardContainer.TOUCH_STATE_CLICK);
             }
         }

         return handleKeyDownEvent(keyCode, event.getRepeatCount());
     }

     public boolean onKeyUp(int keyCode, KeyEvent event) {
         // this only handles InputDevice.SOURCE_TOUCH_NAVIGATION events
         if (isEnterKey(keyCode)) {
             if (!mKeyDownReceived || mLongPressHandled) {
                 mLongPressHandled = false;
                 return true;
             }
             mKeyDownReceived = false;
             if (mContainer.getTouchState() == LeanbackKeyboardContainer.TOUCH_STATE_CLICK) {
                 mContainer.setTouchState(LeanbackKeyboardContainer.TOUCH_STATE_TOUCH_SNAP);
             }
         }
         return handleKeyUpEvent(keyCode, event.getEventTime());
     }

     public boolean onGenericMotionEvent(MotionEvent event) {
         return false;
     }

     private boolean onDirectionalMove(int dir) {
         if (mContainer.getNextFocusInDirection(dir, mDownFocus, mTempFocus)) {
             mContainer.setFocus(mTempFocus);
             mDownFocus.set(mTempFocus);

             clearKeyIfNecessary();
         }

         return true;
     }

     private void clearKeyIfNecessary() {
         mMoveCount++;
         if (mMoveCount >= 3) {
             mMoveCount = 0;
             mKeyDownKeyFocus = null;
         }
     }

     private void commitKey() {
         commitKey(mContainer.getCurrFocus());
     }

     private void commitKey(LeanbackKeyboardContainer.KeyFocus keyFocus) {
         if (mContainer == null || keyFocus == null) {
             return;
         }

         switch (keyFocus.type) {
             case KeyFocus.TYPE_VOICE:
                 // voice doesn't have to go through the IME
                 mContainer.onVoiceClick();
                 break;
             case KeyFocus.TYPE_ACTION:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_ACTION, 0, null);
                 break;
             case KeyFocus.TYPE_SUGGESTION:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_SUGGESTION, 0,
                         mContainer.getSuggestionText(keyFocus.index));
                 break;
             default:
                 Key key = mContainer.getKey(keyFocus.type, keyFocus.index);
                 if (key != null) {
                     int code = key.codes[0];
                     CharSequence label = key.label;
                     handleCommitKeyboardKey(code, label);
                 }
                 break;

         }
     }

     private void handleCommitKeyboardKey(int code, CharSequence label) {
         switch (code) {
             case Keyboard.KEYCODE_MODE_CHANGE:
                 if (Log.isLoggable(TAG, Log.VERBOSE)) {
                     Log.d(TAG, "mode change");
                 }
                 mContainer.onModeChangeClick();
                 break;
             case LeanbackKeyboardView.KEYCODE_CAPS_LOCK:
                 mContainer.onShiftDoubleClick(mContainer.isCapsLockOn());
                 break;
             case Keyboard.KEYCODE_SHIFT:
                 // TODO invalidate and draw a different shift
                 // key in the function keyboard
                 if (Log.isLoggable(TAG, Log.VERBOSE)) {
                     Log.d(TAG, "shift");
                 }
                 mContainer.onShiftClick();
                 break;
             case LeanbackKeyboardView.KEYCODE_DISMISS_MINI_KEYBOARD:
                 mContainer.dismissMiniKeyboard();
                 break;
             case LeanbackKeyboardView.KEYCODE_LEFT:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_LEFT, 0, null);
                 break;
             case LeanbackKeyboardView.KEYCODE_RIGHT:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_RIGHT, 0, null);
                 break;
             case Keyboard.KEYCODE_DELETE:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_BACKSPACE, 0, null);
                 break;
             case LeanbackKeyboardView.ASCII_SPACE:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, " ");
                 mContainer.onSpaceEntry();
                 break;
             case LeanbackKeyboardView.ASCII_PERIOD:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, label);
                 mContainer.onPeriodEntry();
                 break;
             case LeanbackKeyboardView.KEYCODE_VOICE:
                 mContainer.startVoiceRecording();
                 break;
         // fall through to default with this label
             default:
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, label);
                 mContainer.onTextEntry();

                 if (mContainer.isMiniKeyboardOnScreen()) {
                     mContainer.dismissMiniKeyboard();
                 }
                 break;
         }
     }

     private boolean handleKeyDownEvent(int keyCode, int eventRepeatCount) {
         keyCode = getSimplifiedKey(keyCode);

         // never trap back
         if (keyCode == KeyEvent.KEYCODE_BACK) {
             mContainer.cancelVoiceRecording();
             return false;
         }

         // capture all key downs when voice is visible
         if (mContainer.isVoiceVisible()) {
             if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT || keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
                 mContainer.cancelVoiceRecording();
             }
             return true;
         }

         boolean handled = true;
         switch(keyCode) {
             // Direction keys are handled on down to allow repeated movement
             case KeyEvent.KEYCODE_DPAD_LEFT:
                 handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_LEFT);
                 break;
             case KeyEvent.KEYCODE_DPAD_RIGHT:
                 handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_RIGHT);
                 break;
             case KeyEvent.KEYCODE_DPAD_UP:
                 handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_UP);
                 break;
             case KeyEvent.KEYCODE_DPAD_DOWN:
                 handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_DOWN);
                 break;
             case KeyEvent.KEYCODE_BUTTON_X:
                 handleCommitKeyboardKey(Keyboard.KEYCODE_DELETE, null);
                 break;
             case KeyEvent.KEYCODE_BUTTON_Y:
                 handleCommitKeyboardKey(LeanbackKeyboardView.ASCII_SPACE, null);
                 break;
             case KeyEvent.KEYCODE_BUTTON_L1:
                 handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_LEFT, null);
                 break;
             case KeyEvent.KEYCODE_BUTTON_R1:
                 handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_RIGHT, null);
                 break;
             // these are handled on up
             case KeyEvent.KEYCODE_DPAD_CENTER:
                 if (eventRepeatCount == 0) {
                     mMoveCount = 0;
                     mKeyDownKeyFocus = new KeyFocus();
                     mKeyDownKeyFocus.set(mContainer.getCurrFocus());
                 } else if (eventRepeatCount == 1) {
                     if (handleKeyLongPress(keyCode)) {
                         mKeyDownKeyFocus = null;
                     }
                 }

                 if (isKeyHandledOnKeyDown(mContainer.getCurrKeyCode())) {
                     commitKey();
                 }
                 break;
             // also handled on up
             case KeyEvent.KEYCODE_BUTTON_THUMBL:
             case KeyEvent.KEYCODE_BUTTON_THUMBR:
             case KeyEvent.KEYCODE_ENTER:
                 break;
             default:
                 handled = false;
                 break;
         }
         return handled;
     }

     private boolean handleKeyLongPress(int keyCode) {
         mLongPressHandled = isEnterKey(keyCode) && mContainer.onKeyLongPress();
         if (mContainer.isMiniKeyboardOnScreen()) {
             Log.d(TAG, "mini keyboard shown after long press");
         }
         return mLongPressHandled;
     }

     private boolean isKeyHandledOnKeyDown(int currKeyCode) {
         return currKeyCode == Keyboard.KEYCODE_DELETE
                 || currKeyCode == LeanbackKeyboardView.KEYCODE_LEFT
                 || currKeyCode == LeanbackKeyboardView.KEYCODE_RIGHT;
     }

     /**
      * This handles all key events from an input device
      * @param keyCode
      * @return true if the key was handled, false otherwise
      */
     private boolean handleKeyUpEvent(int keyCode, long currTime) {
         keyCode = getSimplifiedKey(keyCode);

         // never trap back
         if (keyCode == KeyEvent.KEYCODE_BACK) {
             return false;
         }

         // capture all key ups when voice is visible
         if (mContainer.isVoiceVisible()) {
             return true;
         }

         boolean handled = true;
         switch(keyCode) {
             // Some keys are handled on down to allow repeats
             case KeyEvent.KEYCODE_DPAD_LEFT:
             case KeyEvent.KEYCODE_DPAD_RIGHT:
             case KeyEvent.KEYCODE_DPAD_UP:
             case KeyEvent.KEYCODE_DPAD_DOWN:
                 clearKeyIfNecessary();
                 break;
             case KeyEvent.KEYCODE_BUTTON_X:
             case KeyEvent.KEYCODE_BUTTON_Y:
             case KeyEvent.KEYCODE_BUTTON_L1:
             case KeyEvent.KEYCODE_BUTTON_R1:
                 break;
             case KeyEvent.KEYCODE_DPAD_CENTER:
                 if (mContainer.getCurrKeyCode() == Keyboard.KEYCODE_SHIFT) {
                     mDoubleClickDetector.addEvent(currTime);
                 } else if (!isKeyHandledOnKeyDown(mContainer.getCurrKeyCode())) {
                     commitKey(mKeyDownKeyFocus);
                 }
                 break;
             case KeyEvent.KEYCODE_BUTTON_THUMBL:
                 handleCommitKeyboardKey(Keyboard.KEYCODE_MODE_CHANGE, null);
                 break;
             case KeyEvent.KEYCODE_BUTTON_THUMBR:
                 handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_CAPS_LOCK, null);
                 break;
             case KeyEvent.KEYCODE_ENTER:
                 if (mContainer != null) {
                     KeyFocus keyFocus = mContainer.getCurrFocus();
                     if (keyFocus != null && keyFocus.type ==  KeyFocus.TYPE_SUGGESTION) {
                         mInputListener.onEntry(InputListener.ENTRY_TYPE_SUGGESTION, 0,
                                 mContainer.getSuggestionText(keyFocus.index));
                     }
                 }
                 mInputListener.onEntry(InputListener.ENTRY_TYPE_DISMISS, 0, null);
                 break;
             default:
                 handled = false;
                 break;
         }
         return handled;
     }

     public void updateSuggestions(ArrayList<String> suggestions) {
         if (mContainer != null) {
             mContainer.updateSuggestions(suggestions);
         }
     }

     @Override
     public void onVoiceResult(String result) {
         mInputListener.onEntry(InputListener.ENTRY_TYPE_VOICE, 0, result);
     }

     @Override
     public void onDismiss(boolean fromVoice) {
         if (fromVoice) {
             mInputListener.onEntry(InputListener.ENTRY_TYPE_VOICE_DISMISS, 0, null);
         } else {
             mInputListener.onEntry(InputListener.ENTRY_TYPE_DISMISS, 0, null);
         }
     }

     private boolean isEnterKey(int keyCode) {
         return getSimplifiedKey(keyCode) == KeyEvent.KEYCODE_DPAD_CENTER;
     }

     private int getSimplifiedKey(int keyCode) {
         // simplify for dpad center
         keyCode = (keyCode == KeyEvent.KEYCODE_DPAD_CENTER ||
                 keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER ||
                 keyCode == KeyEvent.KEYCODE_BUTTON_A) ? KeyEvent.KEYCODE_DPAD_CENTER : keyCode;

         // simply for back
         keyCode = (keyCode == KeyEvent.KEYCODE_BUTTON_B ? KeyEvent.KEYCODE_BACK : keyCode);

         return keyCode;
     }
 }
	/*
	* Copyright (C) 2019 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License
	*/

	package com.android.inputmethod.leanback;

	import android.graphics.PointF;
	import android.inputmethodservice.InputMethodService;
	import android.inputmethodservice.Keyboard;
	import android.inputmethodservice.Keyboard.Key;
	import android.util.Log;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.View;
	import android.view.inputmethod.EditorInfo;

	import com.android.inputmethod.leanback.LeanbackKeyboardContainer.KeyFocus;

	import java.util.ArrayList;
	/**
	* Holds logic for the keyboard views. This includes things like when to
	* snap, when to switch keyboards, etc. It provides callbacks for when actions
	* that need to be handled at the IME level occur (when text is entered, when
	* the action should be performed).
	*/
	public class LeanbackKeyboardController implements LeanbackKeyboardContainer.VoiceListener,
	LeanbackKeyboardContainer.DismissListener {
	private static final String TAG = "LbKbController";
	private static final boolean DEBUG = false;

	/**
	* The amount of time to block movement after a button down was detected.
	*/
	public static final int CLICK_MOVEMENT_BLOCK_DURATION_MS = 500;

	/**
	* The minimum distance in pixels before the view will transition to the
	* move state.
	*/
	public float mResizeSquareDistance;

	// keep track of the most recent key changes and their times so we can
	// revert motion caused by clicking
	private static final int KEY_CHANGE_HISTORY_SIZE = 10;
	private static final long KEY_CHANGE_REVERT_TIME_MS = 100;

	/**
	* This listener reports high level actions that have occurred, such as
	* text entry (from keys or voice) or the action button being pressed.
	*/
	public interface InputListener {
	public static final int ENTRY_TYPE_STRING = 0;
	public static final int ENTRY_TYPE_BACKSPACE = 1;
	public static final int ENTRY_TYPE_SUGGESTION = 2;
	public static final int ENTRY_TYPE_LEFT = 3;
	public static final int ENTRY_TYPE_RIGHT = 4;
	public static final int ENTRY_TYPE_ACTION = 5;
	public static final int ENTRY_TYPE_VOICE = 6;
	public static final int ENTRY_TYPE_DISMISS = 7;
	public static final int ENTRY_TYPE_VOICE_DISMISS = 8;

	/**
	* Sent when the user has selected something that should affect the text
	* field, such as entering a character, selecting the action, or
	* finishing a voice action.
	*
	* @param type The type of key selected
	* @param keyCode the key code of the key if applicable
	* @param result The text entered if applicable
	*/
	public void onEntry(int type, int keyCode, CharSequence result);
	}

	private static final class KeyChange {
	public long time;
	public PointF position;

	public KeyChange(long time, PointF position) {
	this.time = time;
	this.position = position;
	}
	}

	private class DoubleClickDetector {
	final long DOUBLE_CLICK_TIMEOUT_MS = 200;
	long mFirstClickTime = 0;
	boolean mFirstClickShiftLocked;

	public void reset() {
	mFirstClickTime = 0;
	}

	public void addEvent(long currTime) {
	if (currTime - mFirstClickTime > DOUBLE_CLICK_TIMEOUT_MS) {
	mFirstClickTime = currTime;
	mFirstClickShiftLocked = mContainer.isCapsLockOn();
	commitKey();
	} else {
	mContainer.onShiftDoubleClick(mFirstClickShiftLocked);
	reset();
	}
	}
	}

	private DoubleClickDetector mDoubleClickDetector = new DoubleClickDetector();

	private View.OnLayoutChangeListener mOnLayoutChangeListener
	= new View.OnLayoutChangeListener() {

	@Override
	public void onLayoutChange(View v, int left, int top, int right, int bottom,
	int oldLeft, int oldTop, int oldRight, int oldBottom) {
	int w = right - left;
	int h = bottom - top;
	int oldW = oldRight - oldLeft;
	int oldH = oldBottom - oldTop;
	if (w > 0 && h > 0) {
	if (w != oldW \|\| h != oldH) {
	initInputView();
	}
	}
	}
	};

	private InputMethodService mContext;
	private InputListener mInputListener;
	private LeanbackKeyboardContainer mContainer;

	private LeanbackKeyboardContainer.KeyFocus mDownFocus =
	new LeanbackKeyboardContainer.KeyFocus();
	private LeanbackKeyboardContainer.KeyFocus mTempFocus =
	new LeanbackKeyboardContainer.KeyFocus();

	ArrayList<KeyChange> mKeyChangeHistory = new ArrayList<KeyChange>(KEY_CHANGE_HISTORY_SIZE + 1);
	private PointF mTempPoint = new PointF();

	private boolean mKeyDownReceived = false;
	private boolean mLongPressHandled = false;
	private KeyFocus mKeyDownKeyFocus;
	private int mMoveCount;

	public LeanbackKeyboardController(InputMethodService context, InputListener listener) {
	this(context, listener, new LeanbackKeyboardContainer(context));
	}

	LeanbackKeyboardController(InputMethodService context, InputListener listener,
	LeanbackKeyboardContainer container) {
	mContext = context;
	mResizeSquareDistance = context.getResources().getDimension(R.dimen.resize_move_distance);
	mResizeSquareDistance *= mResizeSquareDistance;
	mInputListener = listener;
	setKeyboardContainer(container);
	mContainer.setVoiceListener(this);
	mContainer.setDismissListener(this);
	}

	/**
	* This method is called when we start the input at a NEW input field.
	*/
	public void onStartInput(EditorInfo attribute) {
	if (mContainer != null) {
	mContainer.onStartInput(attribute);
	initInputView();
	}
	}

	/**
	* This method is called by whenever we bring up the IME at an input field.
	*/
	public void onStartInputView() {
	mKeyDownReceived = false;
	if (mContainer != null) {
	mContainer.onStartInputView();
	}
	mDoubleClickDetector.reset();
	}

	/**
	* This method sets the pixel positions in mSpaceTracker to match the
	* current KeyFocus in {@link LeanbackKeyboardContainer} This method is called
	* when the keyboard layout is complete, after
	* {@link LeanbackKeyboardContainer.onInitInputView}, to initialize the starting
	* position of mSpaceTracker; and in onUp to reset the pixel position in
	* mSpaceTracker.
	*/
	private void updatePositionToCurrentFocus() {
	PointF currPosition = getCurrentKeyPosition();
	if (currPosition != null) {
	}
	}

	private void initInputView() {
	mContainer.onInitInputView();
	updatePositionToCurrentFocus();
	}

	private PointF getCurrentKeyPosition() {
	if (mContainer != null) {
	LeanbackKeyboardContainer.KeyFocus initialKeyInfo = mContainer.getCurrFocus();
	return new PointF(initialKeyInfo.rect.centerX(), initialKeyInfo.rect.centerY());
	}
	return null;
	}

	private void performBestSnap(long time) {
	KeyFocus focus = mContainer.getCurrFocus();
	mTempPoint.x = focus.rect.centerX();
	mTempPoint.y = focus.rect.centerY();
	PointF bestSnap = getBestSnapPosition(mTempPoint, time);
	mContainer.getBestFocus(bestSnap.x, bestSnap.y, mTempFocus);
	mContainer.setFocus(mTempFocus);
	updatePositionToCurrentFocus();
	}

	private PointF getBestSnapPosition(PointF currPoint, long currTime) {
	if (mKeyChangeHistory.size() <= 1) {
	return currPoint;
	}
	for (int i = 0; i < mKeyChangeHistory.size() - 1; i++) {
	KeyChange change = mKeyChangeHistory.get(i);
	KeyChange nextChange = mKeyChangeHistory.get(i + 1);
	if (currTime - nextChange.time < KEY_CHANGE_REVERT_TIME_MS) {
	if (DEBUG) {
	Log.d(TAG, "Reverting keychange to " + change.position.toString());
	}
	// Return the oldest key change within the revert window and
	// clear all key changes
	currPoint = change.position;
	// on a revert, clear the history and add the reverting point.
	// This way the reverted point will be preferred if there's
	// another fast change before the next call.
	mKeyChangeHistory.clear();
	mKeyChangeHistory.add(new KeyChange(currTime, currPoint));
	break;
	}
	}
	return currPoint;
	}

	public void setKeyboardContainer(LeanbackKeyboardContainer container) {
	mContainer = container;
	container.getView().addOnLayoutChangeListener(mOnLayoutChangeListener);
	}

	public View getView() {
	if (mContainer != null) {
	return mContainer.getView();
	}
	return null;
	}

	public boolean areSuggestionsEnabled() {
	if (mContainer != null) {
	return mContainer.areSuggestionsEnabled();
	}
	return false;
	}

	public boolean enableAutoEnterSpace() {
	if (mContainer != null) {
	return mContainer.enableAutoEnterSpace();
	}
	return false;
	}

	public boolean onKeyDown(int keyCode, KeyEvent event) {
	mDownFocus.set(mContainer.getCurrFocus());
	// this will handle other events, e.g. hardware keyboard
	if (isEnterKey(keyCode)) {
	mKeyDownReceived = true;
	// first keyDown
	if (event.getRepeatCount() == 0) {
	mContainer.setTouchState(LeanbackKeyboardContainer.TOUCH_STATE_CLICK);
	}
	}

	return handleKeyDownEvent(keyCode, event.getRepeatCount());
	}

	public boolean onKeyUp(int keyCode, KeyEvent event) {
	// this only handles InputDevice.SOURCE_TOUCH_NAVIGATION events
	if (isEnterKey(keyCode)) {
	if (!mKeyDownReceived \|\| mLongPressHandled) {
	mLongPressHandled = false;
	return true;
	}
	mKeyDownReceived = false;
	if (mContainer.getTouchState() == LeanbackKeyboardContainer.TOUCH_STATE_CLICK) {
	mContainer.setTouchState(LeanbackKeyboardContainer.TOUCH_STATE_TOUCH_SNAP);
	}
	}
	return handleKeyUpEvent(keyCode, event.getEventTime());
	}

	public boolean onGenericMotionEvent(MotionEvent event) {
	return false;
	}

	private boolean onDirectionalMove(int dir) {
	if (mContainer.getNextFocusInDirection(dir, mDownFocus, mTempFocus)) {
	mContainer.setFocus(mTempFocus);
	mDownFocus.set(mTempFocus);

	clearKeyIfNecessary();
	}

	return true;
	}

	private void clearKeyIfNecessary() {
	mMoveCount++;
	if (mMoveCount >= 3) {
	mMoveCount = 0;
	mKeyDownKeyFocus = null;
	}
	}

	private void commitKey() {
	commitKey(mContainer.getCurrFocus());
	}

	private void commitKey(LeanbackKeyboardContainer.KeyFocus keyFocus) {
	if (mContainer == null \|\| keyFocus == null) {
	return;
	}

	switch (keyFocus.type) {
	case KeyFocus.TYPE_VOICE:
	// voice doesn't have to go through the IME
	mContainer.onVoiceClick();
	break;
	case KeyFocus.TYPE_ACTION:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_ACTION, 0, null);
	break;
	case KeyFocus.TYPE_SUGGESTION:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_SUGGESTION, 0,
	mContainer.getSuggestionText(keyFocus.index));
	break;
	default:
	Key key = mContainer.getKey(keyFocus.type, keyFocus.index);
	if (key != null) {
	int code = key.codes[0];
	CharSequence label = key.label;
	handleCommitKeyboardKey(code, label);
	}
	break;

	}
	}

	private void handleCommitKeyboardKey(int code, CharSequence label) {
	switch (code) {
	case Keyboard.KEYCODE_MODE_CHANGE:
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.d(TAG, "mode change");
	}
	mContainer.onModeChangeClick();
	break;
	case LeanbackKeyboardView.KEYCODE_CAPS_LOCK:
	mContainer.onShiftDoubleClick(mContainer.isCapsLockOn());
	break;
	case Keyboard.KEYCODE_SHIFT:
	// TODO invalidate and draw a different shift
	// key in the function keyboard
	if (Log.isLoggable(TAG, Log.VERBOSE)) {
	Log.d(TAG, "shift");
	}
	mContainer.onShiftClick();
	break;
	case LeanbackKeyboardView.KEYCODE_DISMISS_MINI_KEYBOARD:
	mContainer.dismissMiniKeyboard();
	break;
	case LeanbackKeyboardView.KEYCODE_LEFT:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_LEFT, 0, null);
	break;
	case LeanbackKeyboardView.KEYCODE_RIGHT:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_RIGHT, 0, null);
	break;
	case Keyboard.KEYCODE_DELETE:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_BACKSPACE, 0, null);
	break;
	case LeanbackKeyboardView.ASCII_SPACE:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, " ");
	mContainer.onSpaceEntry();
	break;
	case LeanbackKeyboardView.ASCII_PERIOD:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, label);
	mContainer.onPeriodEntry();
	break;
	case LeanbackKeyboardView.KEYCODE_VOICE:
	mContainer.startVoiceRecording();
	break;
	// fall through to default with this label
	default:
	mInputListener.onEntry(InputListener.ENTRY_TYPE_STRING, code, label);
	mContainer.onTextEntry();

	if (mContainer.isMiniKeyboardOnScreen()) {
	mContainer.dismissMiniKeyboard();
	}
	break;
	}
	}

	private boolean handleKeyDownEvent(int keyCode, int eventRepeatCount) {
	keyCode = getSimplifiedKey(keyCode);

	// never trap back
	if (keyCode == KeyEvent.KEYCODE_BACK) {
	mContainer.cancelVoiceRecording();
	return false;
	}

	// capture all key downs when voice is visible
	if (mContainer.isVoiceVisible()) {
	if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT \|\| keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
	mContainer.cancelVoiceRecording();
	}
	return true;
	}

	boolean handled = true;
	switch(keyCode) {
	// Direction keys are handled on down to allow repeated movement
	case KeyEvent.KEYCODE_DPAD_LEFT:
	handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_LEFT);
	break;
	case KeyEvent.KEYCODE_DPAD_RIGHT:
	handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_RIGHT);
	break;
	case KeyEvent.KEYCODE_DPAD_UP:
	handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_UP);
	break;
	case KeyEvent.KEYCODE_DPAD_DOWN:
	handled = onDirectionalMove(LeanbackKeyboardContainer.DIRECTION_DOWN);
	break;
	case KeyEvent.KEYCODE_BUTTON_X:
	handleCommitKeyboardKey(Keyboard.KEYCODE_DELETE, null);
	break;
	case KeyEvent.KEYCODE_BUTTON_Y:
	handleCommitKeyboardKey(LeanbackKeyboardView.ASCII_SPACE, null);
	break;
	case KeyEvent.KEYCODE_BUTTON_L1:
	handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_LEFT, null);
	break;
	case KeyEvent.KEYCODE_BUTTON_R1:
	handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_RIGHT, null);
	break;
	// these are handled on up
	case KeyEvent.KEYCODE_DPAD_CENTER:
	if (eventRepeatCount == 0) {
	mMoveCount = 0;
	mKeyDownKeyFocus = new KeyFocus();
	mKeyDownKeyFocus.set(mContainer.getCurrFocus());
	} else if (eventRepeatCount == 1) {
	if (handleKeyLongPress(keyCode)) {
	mKeyDownKeyFocus = null;
	}
	}

	if (isKeyHandledOnKeyDown(mContainer.getCurrKeyCode())) {
	commitKey();
	}
	break;
	// also handled on up
	case KeyEvent.KEYCODE_BUTTON_THUMBL:
	case KeyEvent.KEYCODE_BUTTON_THUMBR:
	case KeyEvent.KEYCODE_ENTER:
	break;
	default:
	handled = false;
	break;
	}
	return handled;
	}

	private boolean handleKeyLongPress(int keyCode) {
	mLongPressHandled = isEnterKey(keyCode) && mContainer.onKeyLongPress();
	if (mContainer.isMiniKeyboardOnScreen()) {
	Log.d(TAG, "mini keyboard shown after long press");
	}
	return mLongPressHandled;
	}

	private boolean isKeyHandledOnKeyDown(int currKeyCode) {
	return currKeyCode == Keyboard.KEYCODE_DELETE
	\|\| currKeyCode == LeanbackKeyboardView.KEYCODE_LEFT
	\|\| currKeyCode == LeanbackKeyboardView.KEYCODE_RIGHT;
	}

	/**
	* This handles all key events from an input device
	* @param keyCode
	* @return true if the key was handled, false otherwise
	*/
	private boolean handleKeyUpEvent(int keyCode, long currTime) {
	keyCode = getSimplifiedKey(keyCode);

	// never trap back
	if (keyCode == KeyEvent.KEYCODE_BACK) {
	return false;
	}

	// capture all key ups when voice is visible
	if (mContainer.isVoiceVisible()) {
	return true;
	}

	boolean handled = true;
	switch(keyCode) {
	// Some keys are handled on down to allow repeats
	case KeyEvent.KEYCODE_DPAD_LEFT:
	case KeyEvent.KEYCODE_DPAD_RIGHT:
	case KeyEvent.KEYCODE_DPAD_UP:
	case KeyEvent.KEYCODE_DPAD_DOWN:
	clearKeyIfNecessary();
	break;
	case KeyEvent.KEYCODE_BUTTON_X:
	case KeyEvent.KEYCODE_BUTTON_Y:
	case KeyEvent.KEYCODE_BUTTON_L1:
	case KeyEvent.KEYCODE_BUTTON_R1:
	break;
	case KeyEvent.KEYCODE_DPAD_CENTER:
	if (mContainer.getCurrKeyCode() == Keyboard.KEYCODE_SHIFT) {
	mDoubleClickDetector.addEvent(currTime);
	} else if (!isKeyHandledOnKeyDown(mContainer.getCurrKeyCode())) {
	commitKey(mKeyDownKeyFocus);
	}
	break;
	case KeyEvent.KEYCODE_BUTTON_THUMBL:
	handleCommitKeyboardKey(Keyboard.KEYCODE_MODE_CHANGE, null);
	break;
	case KeyEvent.KEYCODE_BUTTON_THUMBR:
	handleCommitKeyboardKey(LeanbackKeyboardView.KEYCODE_CAPS_LOCK, null);
	break;
	case KeyEvent.KEYCODE_ENTER:
	if (mContainer != null) {
	KeyFocus keyFocus = mContainer.getCurrFocus();
	if (keyFocus != null && keyFocus.type == KeyFocus.TYPE_SUGGESTION) {
	mInputListener.onEntry(InputListener.ENTRY_TYPE_SUGGESTION, 0,
	mContainer.getSuggestionText(keyFocus.index));
	}
	}
	mInputListener.onEntry(InputListener.ENTRY_TYPE_DISMISS, 0, null);
	break;
	default:
	handled = false;
	break;
	}
	return handled;
	}

	public void updateSuggestions(ArrayList<String> suggestions) {
	if (mContainer != null) {
	mContainer.updateSuggestions(suggestions);
	}
	}

	@Override
	public void onVoiceResult(String result) {
	mInputListener.onEntry(InputListener.ENTRY_TYPE_VOICE, 0, result);
	}

	@Override
	public void onDismiss(boolean fromVoice) {
	if (fromVoice) {
	mInputListener.onEntry(InputListener.ENTRY_TYPE_VOICE_DISMISS, 0, null);
	} else {
	mInputListener.onEntry(InputListener.ENTRY_TYPE_DISMISS, 0, null);
	}
	}

	private boolean isEnterKey(int keyCode) {
	return getSimplifiedKey(keyCode) == KeyEvent.KEYCODE_DPAD_CENTER;
	}

	private int getSimplifiedKey(int keyCode) {
	// simplify for dpad center
	keyCode = (keyCode == KeyEvent.KEYCODE_DPAD_CENTER \|\|
	keyCode == KeyEvent.KEYCODE_NUMPAD_ENTER \|\|
	keyCode == KeyEvent.KEYCODE_BUTTON_A) ? KeyEvent.KEYCODE_DPAD_CENTER : keyCode;

	// simply for back
	keyCode = (keyCode == KeyEvent.KEYCODE_BUTTON_B ? KeyEvent.KEYCODE_BACK : keyCode);

	return keyCode;
	}
	}