| /* |
| * 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.animation.Animator; |
| import android.animation.ValueAnimator; |
| import android.speech.RecognitionListener; |
| import android.os.Bundle; |
| |
| import com.android.inputmethod.leanback.LeanbackKeyboardController.InputListener; |
| import com.android.inputmethod.leanback.voice.RecognizerView; |
| import com.android.inputmethod.leanback.voice.SpeechLevelSource; |
| import com.android.inputmethod.leanback.service.LeanbackImeService; |
| |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.res.Resources; |
| import android.view.KeyEvent; |
| import android.view.View; |
| import android.view.View.OnFocusChangeListener; |
| import android.view.ViewGroup; |
| import android.view.ViewGroup.LayoutParams; |
| import android.view.ViewGroup.MarginLayoutParams; |
| import android.view.accessibility.AccessibilityEvent; |
| import android.view.accessibility.AccessibilityManager; |
| import android.view.animation.AccelerateInterpolator; |
| import android.animation.ValueAnimator.AnimatorUpdateListener; |
| import android.animation.Animator.AnimatorListener; |
| import android.view.animation.Animation; |
| import android.view.animation.DecelerateInterpolator; |
| import android.view.animation.Interpolator; |
| import android.view.animation.Transformation; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputMethodManager; |
| import android.view.inputmethod.InputMethodSubtype; |
| import android.graphics.PointF; |
| import android.graphics.Rect; |
| import android.speech.RecognizerIntent; |
| import android.speech.SpeechRecognizer; |
| import android.text.TextUtils; |
| import android.text.method.QwertyKeyListener; |
| import android.text.style.LocaleSpan; |
| import android.widget.Button; |
| import android.widget.FrameLayout; |
| import android.widget.HorizontalScrollView; |
| import android.widget.LinearLayout; |
| import android.widget.RelativeLayout; |
| import android.widget.ScrollView; |
| import android.util.Log; |
| import android.inputmethodservice.Keyboard; |
| import android.inputmethodservice.Keyboard.Key; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Locale; |
| |
| /** |
| * This is the keyboard container for GridIme that contains the following views: |
| * <ul> |
| * <li>voice button</li> |
| * <li>main keyboard</li> |
| * <li>action button</li> |
| * <li>focus bubble</li> |
| * <li>touch indicator</li> |
| * <li>candidate view</li> |
| * </ul> |
| * Keyboard grid layout: |
| * |
| * <pre> |
| * | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |OTH| | |
| * |<- | - | - | - | - | - | - | - | - | ->|ER |ACT| |
| * |<- | - | - | M | A | I | N | - | - | ->| | | |
| * |<- | K | E | Y | B | O | A | R | D | ->|KEY|ION| |
| * |<- | - | - | - | - | - | - | - | - | ->|S | | |
| * </pre> |
| */ |
| public class LeanbackKeyboardContainer { |
| |
| private static final String TAG = "LbKbContainer"; |
| private static final boolean DEBUG = false; |
| private static final boolean VOICE_SUPPORTED = true; |
| private static final String IME_PRIVATE_OPTIONS_ESCAPE_NORTH_LEGACY = "EscapeNorth=1"; |
| private static final String IME_PRIVATE_OPTIONS_ESCAPE_NORTH = "escapeNorth"; |
| private static final String IME_PRIVATE_OPTIONS_VOICE_DISMISS_LEGACY = "VoiceDismiss=1"; |
| private static final String IME_PRIVATE_OPTIONS_VOICE_DISMISS = "voiceDismiss"; |
| |
| /** |
| * This is the length of animations that move an indicator across the keys. Snaps and flicks |
| * will use this duration for the movement. |
| */ |
| private static final long MOVEMENT_ANIMATION_DURATION = 150; |
| |
| /** |
| * This interpolator is used for movement animations. |
| */ |
| public static final Interpolator sMovementInterpolator = new DecelerateInterpolator(1.5f); |
| |
| /** |
| * These are the states that the view can be in and affect the icon appearance. NO_TOUCH is when |
| * there are no fingers down on the input device. |
| */ |
| public static final int TOUCH_STATE_NO_TOUCH = 0; |
| |
| /** |
| * TOUCH_SNAP indicates that a finger is down but the indicator is still considered snapped to a |
| * letter. Once the user moves a given distance from the snapped position it will change to |
| * TOUCH_MOVE. |
| */ |
| public static final int TOUCH_STATE_TOUCH_SNAP = 1; |
| |
| /** |
| * TOUCH_MOVE indicates the user is moving freely around the space and is not snapped to any |
| * letter. |
| */ |
| public static final int TOUCH_STATE_TOUCH_MOVE = 2; |
| |
| /** |
| * CLICK indicates the selection button is currently pressed. When the button is released we |
| * will transition back to snap or no touch depending on whether there is still a finger down on |
| * the input device or not. |
| */ |
| public static final int TOUCH_STATE_CLICK = 3; |
| |
| // The minimum distance the user must move their finger to transition from |
| // the SNAP to the MOVE state |
| public static final double TOUCH_MOVE_MIN_DISTANCE = .1; |
| |
| /** |
| * When processing a flick or dpad event it is easier to move a key width + a fudge factor than |
| * to directly compute what the next key position should be. This is the fudge factor. |
| */ |
| public static final double DIRECTION_STEP_MULTIPLIER = 1.25; |
| |
| /** |
| * Directions sent to event listeners. |
| */ |
| public static final int DIRECTION_LEFT = 1 << 0; |
| public static final int DIRECTION_DOWN = 1 << 1; |
| public static final int DIRECTION_RIGHT = 1 << 2; |
| public static final int DIRECTION_UP = 1 << 3; |
| public static final int DIRECTION_DOWN_LEFT = DIRECTION_DOWN | DIRECTION_LEFT; |
| public static final int DIRECTION_DOWN_RIGHT = DIRECTION_DOWN | DIRECTION_RIGHT; |
| public static final int DIRECTION_UP_RIGHT = DIRECTION_UP | DIRECTION_RIGHT; |
| public static final int DIRECTION_UP_LEFT = DIRECTION_UP | DIRECTION_LEFT; |
| |
| /** |
| * handler messages |
| */ |
| // align selector in onStartInputView |
| private static final int MSG_START_INPUT_VIEW = 0; |
| |
| // If this were a physical keyboard the width in cm. This will be mapped |
| // to the width in pixels but is representative of the mapping from the |
| // remote input to the screen. Higher values will require larger moves to |
| // get across the keyboard |
| protected static final float PHYSICAL_WIDTH_CM = 12; |
| // If this were a physical keyboard the height in cm. This will be mapped |
| // to the height in pixels but is representative of the mapping from the |
| // remote input to the screen. Higher values will require larger moves to |
| // get across the keyboard |
| protected static final float PHYSICAL_HEIGHT_CM = 5; |
| |
| /** |
| * Listener for publishing voice input result to {@link LeanbackKeyboardController} |
| */ |
| public static interface VoiceListener { |
| public void onVoiceResult(String result); |
| } |
| |
| public static interface DismissListener { |
| public void onDismiss(boolean fromVoice); |
| } |
| |
| /** |
| * Class for holding information about the currently focused key. |
| */ |
| public static class KeyFocus { |
| public static final int TYPE_INVALID = -1; |
| public static final int TYPE_MAIN = 0; |
| public static final int TYPE_VOICE = 1; |
| public static final int TYPE_ACTION = 2; |
| public static final int TYPE_SUGGESTION = 3; |
| |
| /** |
| * The bounding box for the current focused key/view |
| */ |
| final Rect rect; |
| |
| /** |
| * The index of the focused key or suggestion. This is invalid for views that don't have |
| * indexed items. |
| */ |
| int index; |
| |
| /** |
| * The type of key which indicates which view/keyboard the focus is in. |
| */ |
| int type; |
| |
| /** |
| * The key code for the focused key. This is invalid for views that don't use key codes. |
| */ |
| int code; |
| |
| /** |
| * The text label for the focused key. This is invalid for views that don't use labels. |
| */ |
| CharSequence label; |
| |
| public KeyFocus() { |
| type = TYPE_INVALID; |
| rect = new Rect(); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder bob = new StringBuilder(); |
| bob.append("[type: ").append(type) |
| .append(", index: ").append(index) |
| .append(", code: ").append(code) |
| .append(", label: ").append(label) |
| .append(", rect: ").append(rect) |
| .append("]"); |
| return bob.toString(); |
| } |
| |
| public void set(KeyFocus focus) { |
| index = focus.index; |
| type = focus.type; |
| code = focus.code; |
| label = focus.label; |
| rect.set(focus.rect); |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) { |
| return true; |
| } |
| if (o == null || getClass() != o.getClass()) { |
| return false; |
| } |
| |
| KeyFocus keyFocus = (KeyFocus) o; |
| |
| if (code != keyFocus.code) { |
| return false; |
| } |
| if (index != keyFocus.index) { |
| return false; |
| } |
| if (type != keyFocus.type) { |
| return false; |
| } |
| if (label != null ? !label.equals(keyFocus.label) : keyFocus.label != null) { |
| return false; |
| } |
| if (!rect.equals(keyFocus.rect)) { |
| return false; |
| } |
| |
| return true; |
| } |
| |
| @Override |
| public int hashCode() { |
| int result = rect.hashCode(); |
| result = 31 * result + index; |
| result = 31 * result + type; |
| result = 31 * result + code; |
| result = 31 * result + (label != null ? label.hashCode() : 0); |
| return result; |
| } |
| } |
| |
| private class VoiceIntroAnimator { |
| private AnimatorListener mEnterListener; |
| private AnimatorListener mExitListener; |
| private ValueAnimator mValueAnimator; |
| |
| public VoiceIntroAnimator(AnimatorListener enterListener, AnimatorListener exitListener) { |
| mEnterListener = enterListener; |
| mExitListener = exitListener; |
| |
| mValueAnimator = ValueAnimator.ofFloat(mAlphaOut, mAlphaIn); |
| mValueAnimator.setDuration(mVoiceAnimDur); |
| mValueAnimator.setInterpolator(new AccelerateInterpolator()); |
| } |
| |
| void startEnterAnimation() { |
| if (!isVoiceVisible() && !mValueAnimator.isRunning()) { |
| start(true); |
| } |
| } |
| |
| void startExitAnimation() { |
| if (isVoiceVisible() && !mValueAnimator.isRunning()) { |
| start(false); |
| } |
| } |
| |
| private void start(final boolean enterVoice) { |
| // TODO make animation continous |
| mValueAnimator.cancel(); |
| |
| mValueAnimator.removeAllListeners(); |
| mValueAnimator.addListener(enterVoice ? mEnterListener : mExitListener); |
| mValueAnimator.removeAllUpdateListeners(); |
| mValueAnimator.addUpdateListener(new AnimatorUpdateListener() { |
| |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| float progress = (Float) mValueAnimator.getAnimatedValue(); |
| float antiProgress = mAlphaIn + mAlphaOut - progress; |
| |
| float kbAlpha = enterVoice ? antiProgress : progress; |
| float voiceAlpha = enterVoice ? progress : antiProgress; |
| |
| mMainKeyboardView.setAlpha(kbAlpha); |
| mActionButtonView.setAlpha(kbAlpha); |
| mVoiceButtonView.setAlpha(voiceAlpha); |
| |
| if (progress == mAlphaOut) { |
| // first pass |
| if (enterVoice) { |
| mVoiceButtonView.setVisibility(View.VISIBLE); |
| } else { |
| mMainKeyboardView.setVisibility(View.VISIBLE); |
| mActionButtonView.setVisibility(View.VISIBLE); |
| } |
| } else if (progress == mAlphaIn) { |
| // done |
| if (enterVoice) { |
| mMainKeyboardView.setVisibility(View.INVISIBLE); |
| mActionButtonView.setVisibility(View.INVISIBLE); |
| } else { |
| mVoiceButtonView.setVisibility(View.INVISIBLE); |
| } |
| } |
| } |
| }); |
| |
| mValueAnimator.start(); |
| } |
| } |
| |
| /** |
| * keyboard flags based on the edittext types |
| */ |
| // if suggestions are enabled and suggestion view is visible |
| private boolean mSuggestionsEnabled; |
| // if auto entering space after period or suggestions is enabled |
| private boolean mAutoEnterSpaceEnabled; |
| // if voice button is enabled |
| private boolean mVoiceEnabled; |
| // initial main keyboard to show for the specific edittext |
| private Keyboard mInitialMainKeyboard; |
| // text resource id of the enter key. If set to 0, show enter key image |
| private int mEnterKeyTextResId; |
| private CharSequence mEnterKeyText; |
| |
| /** |
| * This animator controls the way the touch indicator grows and shrinks when changing states. |
| */ |
| private ValueAnimator mSelectorAnimator; |
| |
| /** |
| * The current state of touch. |
| */ |
| private int mTouchState = TOUCH_STATE_NO_TOUCH; |
| |
| private VoiceListener mVoiceListener; |
| |
| private DismissListener mDismissListener; |
| |
| private LeanbackImeService mContext; |
| private RelativeLayout mRootView; |
| |
| private View mKeyboardsContainer; |
| private View mSuggestionsBg; |
| private HorizontalScrollView mSuggestionsContainer; |
| private LinearLayout mSuggestions; |
| private LeanbackKeyboardView mMainKeyboardView; |
| private Button mActionButtonView; |
| private ScaleAnimation mSelectorAnimation; |
| private View mSelector; |
| private float mOverestimate; |
| |
| // The modeled physical position of the current selection in cm |
| private PointF mPhysicalSelectPos = new PointF(2, .5f); |
| // The position of the touch indicator in cm |
| private PointF mPhysicalTouchPos = new PointF(2, .5f); |
| // A point for doing temporary calculations |
| private PointF mTempPoint = new PointF(); |
| |
| private KeyFocus mCurrKeyInfo = new KeyFocus(); |
| private KeyFocus mDownKeyInfo = new KeyFocus(); |
| private KeyFocus mTempKeyInfo = new KeyFocus(); |
| |
| private LeanbackKeyboardView mPrevView; |
| private Rect mRect = new Rect(); |
| private Float mX; |
| private Float mY; |
| private int mMiniKbKeyIndex; |
| |
| private final int mClickAnimDur; |
| private final int mVoiceAnimDur; |
| private final float mAlphaIn; |
| private final float mAlphaOut; |
| |
| private Keyboard mAbcKeyboard; |
| private Keyboard mSymKeyboard; |
| private Keyboard mNumKeyboard; |
| |
| // if we should capitalize the first letter in each sentence |
| private boolean mCapSentences; |
| |
| // if we should capitalize the first letter in each word |
| private boolean mCapWords; |
| |
| // if we should capitalize every character |
| private boolean mCapCharacters; |
| |
| // if voice is on |
| private boolean mVoiceOn; |
| |
| // Whether to allow escaping north or not |
| private boolean mEscapeNorthEnabled; |
| |
| // Whether to dismiss when voice button is pressed |
| private boolean mVoiceKeyDismissesEnabled; |
| |
| /** |
| * Voice |
| */ |
| private Intent mRecognizerIntent; |
| private SpeechRecognizer mSpeechRecognizer; |
| private SpeechLevelSource mSpeechLevelSource; |
| private RecognizerView mVoiceButtonView; |
| |
| private class ScaleAnimation extends Animation { |
| private final ViewGroup.LayoutParams mParams; |
| private final View mView; |
| private float mStartX; |
| private float mStartY; |
| private float mStartWidth; |
| private float mStartHeight; |
| private float mEndX; |
| private float mEndY; |
| private float mEndWidth; |
| private float mEndHeight; |
| |
| public ScaleAnimation(FrameLayout view) { |
| mView = view; |
| mParams = view.getLayoutParams(); |
| setDuration(MOVEMENT_ANIMATION_DURATION); |
| setInterpolator(sMovementInterpolator); |
| } |
| |
| public void setAnimationBounds(float x, float y, float width, float height) { |
| mEndX = x; |
| mEndY = y; |
| mEndWidth = width; |
| mEndHeight = height; |
| } |
| |
| @Override |
| protected void applyTransformation(float interpolatedTime, Transformation t) { |
| if (interpolatedTime == 0) { |
| mStartX = mView.getX(); |
| mStartY = mView.getY(); |
| mStartWidth = mParams.width; |
| mStartHeight = mParams.height; |
| } else { |
| setValues(((mEndX - mStartX) * interpolatedTime + mStartX), |
| ((mEndY - mStartY) * interpolatedTime + mStartY), |
| ((int)((mEndWidth - mStartWidth) * interpolatedTime + mStartWidth)), |
| ((int)((mEndHeight - mStartHeight) * interpolatedTime + mStartHeight))); |
| } |
| } |
| |
| public void setValues(float x, float y, float width, float height) { |
| mView.setX(x); |
| mView.setY(y); |
| mParams.width = (int)(width); |
| mParams.height = (int)(height); |
| mView.setLayoutParams(mParams); |
| mView.requestLayout(); |
| } |
| }; |
| |
| private AnimatorListener mVoiceEnterListener = new AnimatorListener() { |
| |
| @Override |
| public void onAnimationStart(Animator animation) { |
| mSelector.setVisibility(View.INVISIBLE); |
| startRecognition(mContext); |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animator animation) { |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| } |
| |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| } |
| }; |
| |
| private AnimatorListener mVoiceExitListener = new AnimatorListener() { |
| |
| @Override |
| public void onAnimationStart(Animator animation) { |
| mVoiceButtonView.showNotListening(); |
| mSpeechRecognizer.cancel(); |
| mSpeechRecognizer.setRecognitionListener(null); |
| mVoiceOn = false; |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animator animation) { |
| } |
| |
| @Override |
| public void onAnimationEnd(Animator animation) { |
| mSelector.setVisibility(View.VISIBLE); |
| } |
| |
| @Override |
| public void onAnimationCancel(Animator animation) { |
| } |
| }; |
| |
| private final VoiceIntroAnimator mVoiceAnimator; |
| |
| // Tracks whether or not a touch event is in progress. This is true while |
| // a finger is down on the pad. |
| private boolean mTouchDown = false; |
| |
| public LeanbackKeyboardContainer(Context context) { |
| mContext = (LeanbackImeService) context; |
| |
| final Resources res = mContext.getResources(); |
| mVoiceAnimDur = res.getInteger(R.integer.voice_anim_duration); |
| mAlphaIn = res.getFraction(R.fraction.alpha_in, 1, 1); |
| mAlphaOut = res.getFraction(R.fraction.alpha_out, 1, 1); |
| |
| mVoiceAnimator = new VoiceIntroAnimator(mVoiceEnterListener, mVoiceExitListener); |
| |
| initKeyboards(); |
| |
| mRootView = (RelativeLayout) mContext.getLayoutInflater() |
| .inflate(R.layout.root_leanback, null); |
| mKeyboardsContainer = mRootView.findViewById(R.id.keyboard); |
| mSuggestionsBg = mRootView.findViewById(R.id.candidate_background); |
| mSuggestionsContainer = |
| (HorizontalScrollView) mRootView.findViewById(R.id.suggestions_container); |
| mSuggestions = (LinearLayout) mSuggestionsContainer.findViewById(R.id.suggestions); |
| |
| mMainKeyboardView = (LeanbackKeyboardView) mRootView.findViewById(R.id.main_keyboard); |
| mVoiceButtonView = (RecognizerView) mRootView.findViewById(R.id.voice); |
| |
| mActionButtonView = (Button) mRootView.findViewById(R.id.enter); |
| |
| mSelector = mRootView.findViewById(R.id.selector); |
| mSelectorAnimation = new ScaleAnimation((FrameLayout) mSelector); |
| |
| mOverestimate = mContext.getResources().getFraction(R.fraction.focused_scale, 1, 1); |
| float scale = context.getResources().getFraction(R.fraction.clicked_scale, 1, 1); |
| mClickAnimDur = context.getResources().getInteger(R.integer.clicked_anim_duration); |
| mSelectorAnimator = ValueAnimator.ofFloat(1.0f, scale); |
| mSelectorAnimator.setDuration(mClickAnimDur); |
| mSelectorAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() { |
| @Override |
| public void onAnimationUpdate(ValueAnimator animation) { |
| float scale = (Float) animation.getAnimatedValue(); |
| mSelector.setScaleX(scale); |
| mSelector.setScaleY(scale); |
| } |
| }); |
| |
| mSpeechLevelSource = new SpeechLevelSource(); |
| mVoiceButtonView.setSpeechLevelSource(mSpeechLevelSource); |
| mSpeechRecognizer = SpeechRecognizer.createSpeechRecognizer(mContext); |
| mVoiceButtonView.setCallback(new RecognizerView.Callback() { |
| @Override |
| public void onStartRecordingClicked() { |
| startVoiceRecording(); |
| } |
| |
| @Override |
| public void onStopRecordingClicked() { |
| cancelVoiceRecording(); |
| } |
| |
| @Override |
| public void onCancelRecordingClicked() { |
| cancelVoiceRecording(); |
| } |
| }); |
| |
| } |
| |
| public void startVoiceRecording() { |
| if (mVoiceEnabled) { |
| if (mVoiceKeyDismissesEnabled) { |
| if (DEBUG) Log.v(TAG, "Voice Dismiss"); |
| mDismissListener.onDismiss(true); |
| } else { |
| mVoiceAnimator.startEnterAnimation(); |
| } |
| } |
| } |
| |
| public void cancelVoiceRecording() { |
| mVoiceAnimator.startExitAnimation(); |
| } |
| |
| public void resetVoice() { |
| mMainKeyboardView.setAlpha(mAlphaIn); |
| mActionButtonView.setAlpha(mAlphaIn); |
| mVoiceButtonView.setAlpha(mAlphaOut); |
| |
| mMainKeyboardView.setVisibility(View.VISIBLE); |
| mActionButtonView.setVisibility(View.VISIBLE); |
| mVoiceButtonView.setVisibility(View.INVISIBLE); |
| } |
| |
| public boolean isVoiceVisible() { |
| return mVoiceButtonView.getVisibility() == View.VISIBLE; |
| } |
| |
| private void initKeyboards() { |
| Locale locale = Locale.getDefault(); |
| |
| if (isMatch(locale, LeanbackLocales.QWERTY_GB)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_en_gb); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_en_gb); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_IN)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_en_in); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_en_in); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_ES_EU)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_es_eu); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_ES_US)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_es_us); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_us); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_AZ)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_az); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_CA)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_ca); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_DA)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_da); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_ET)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_et); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_FI)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_fi); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_NB)) { |
| // in the LatinIME nb uses the US symbols (usd instead of euro) |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_nb); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_us); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_SV)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_sv); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTY_US)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_us); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_us); |
| } else if (isMatch(locale, LeanbackLocales.QWERTZ_CH)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwertz_ch); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.QWERTZ)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwertz); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } else if (isMatch(locale, LeanbackLocales.AZERTY)) { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.azerty); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_azerty); |
| } else { |
| mAbcKeyboard = new Keyboard(mContext, R.xml.qwerty_eu); |
| mSymKeyboard = new Keyboard(mContext, R.xml.sym_eu); |
| } |
| |
| mNumKeyboard = new Keyboard(mContext, R.xml.number); |
| } |
| |
| private boolean isMatch(Locale locale, Locale[] list) { |
| for (Locale compare : list) { |
| // comparison language is either blank or they match |
| if (TextUtils.isEmpty(compare.getLanguage()) || |
| TextUtils.equals(locale.getLanguage(), compare.getLanguage())) { |
| // comparison country is either blank or they match |
| if (TextUtils.isEmpty(compare.getCountry()) || |
| TextUtils.equals(locale.getCountry(), compare.getCountry())) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * This method is called when we start the input at a NEW input field to set up the IME options, |
| * such as suggestions, voice, and action |
| */ |
| public void onStartInput(EditorInfo attribute) { |
| setImeOptions(mContext.getResources(), attribute); |
| mVoiceOn = false; |
| } |
| |
| /** |
| * This method is called whenever we bring up the IME at an input field. |
| */ |
| public void onStartInputView() { |
| // This must be done here because modifying the views before it is |
| // shown can cause selection handles to be shown if using a USB |
| // keyboard in a WebView. |
| clearSuggestions(); |
| |
| RelativeLayout.LayoutParams lp = |
| (RelativeLayout.LayoutParams) mKeyboardsContainer.getLayoutParams(); |
| if (mSuggestionsEnabled) { |
| lp.removeRule(RelativeLayout.ALIGN_PARENT_TOP); |
| mSuggestionsContainer.setVisibility(View.VISIBLE); |
| mSuggestionsBg.setVisibility(View.VISIBLE); |
| } else { |
| lp.addRule(RelativeLayout.ALIGN_PARENT_TOP); |
| mSuggestionsContainer.setVisibility(View.GONE); |
| mSuggestionsBg.setVisibility(View.GONE); |
| } |
| mKeyboardsContainer.setLayoutParams(lp); |
| |
| mMainKeyboardView.setKeyboard(mInitialMainKeyboard); |
| // TODO fix this for number keyboard |
| mVoiceButtonView.setMicEnabled(mVoiceEnabled); |
| resetVoice(); |
| dismissMiniKeyboard(); |
| |
| // setImeOptions will be called before this, setting the text resource value |
| if (!TextUtils.isEmpty(mEnterKeyText)) { |
| mActionButtonView.setText(mEnterKeyText); |
| mActionButtonView.setContentDescription(mEnterKeyText); |
| } else { |
| mActionButtonView.setText(mEnterKeyTextResId); |
| mActionButtonView.setContentDescription(mContext.getString(mEnterKeyTextResId)); |
| } |
| |
| if (mCapCharacters) { |
| setShiftState(LeanbackKeyboardView.SHIFT_LOCKED); |
| } else if (mCapSentences || mCapWords) { |
| setShiftState(LeanbackKeyboardView.SHIFT_ON); |
| } else { |
| setShiftState(LeanbackKeyboardView.SHIFT_OFF); |
| } |
| } |
| |
| /** |
| * This method is called when the keyboard layout is complete, to set up the initial focus and |
| * visibility. This method gets called later than {@link onStartInput} and |
| * {@link onStartInputView}. |
| */ |
| public void onInitInputView() { |
| resetFocusCursor(); |
| mSelector.setVisibility(View.VISIBLE); |
| } |
| |
| public RelativeLayout getView() { |
| return mRootView; |
| } |
| |
| public void setVoiceListener(VoiceListener listener) { |
| mVoiceListener = listener; |
| } |
| |
| public void setDismissListener(DismissListener listener) { |
| mDismissListener = listener; |
| } |
| |
| private void setImeOptions(Resources resources, EditorInfo attribute) { |
| mSuggestionsEnabled = true; |
| mAutoEnterSpaceEnabled = true; |
| mVoiceEnabled = true; |
| mInitialMainKeyboard = mAbcKeyboard; |
| mEscapeNorthEnabled = false; |
| mVoiceKeyDismissesEnabled = false; |
| |
| // set keyboard properties |
| switch (LeanbackUtils.getInputTypeClass(attribute)) { |
| case EditorInfo.TYPE_CLASS_NUMBER: |
| case EditorInfo.TYPE_CLASS_DATETIME: |
| case EditorInfo.TYPE_CLASS_PHONE: |
| mSuggestionsEnabled = false; |
| mVoiceEnabled = false; |
| // TODO use number keyboard for these input types |
| mInitialMainKeyboard = mAbcKeyboard; |
| break; |
| case EditorInfo.TYPE_CLASS_TEXT: |
| switch (LeanbackUtils.getInputTypeVariation(attribute)) { |
| case EditorInfo.TYPE_TEXT_VARIATION_PASSWORD: |
| case EditorInfo.TYPE_TEXT_VARIATION_WEB_PASSWORD: |
| case EditorInfo.TYPE_TEXT_VARIATION_VISIBLE_PASSWORD: |
| case EditorInfo.TYPE_TEXT_VARIATION_PERSON_NAME: |
| mSuggestionsEnabled = false; |
| mVoiceEnabled = false; |
| mInitialMainKeyboard = mAbcKeyboard; |
| break; |
| case EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS: |
| case EditorInfo.TYPE_TEXT_VARIATION_URI: |
| case EditorInfo.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT: |
| case EditorInfo.TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS: |
| mSuggestionsEnabled = true; |
| mAutoEnterSpaceEnabled = false; |
| mVoiceEnabled = false; |
| mInitialMainKeyboard = mAbcKeyboard; |
| break; |
| } |
| break; |
| } |
| |
| if (mSuggestionsEnabled) { |
| mSuggestionsEnabled = (attribute.inputType |
| & EditorInfo.TYPE_TEXT_FLAG_NO_SUGGESTIONS) == 0; |
| } |
| if (mAutoEnterSpaceEnabled) { |
| mAutoEnterSpaceEnabled = mSuggestionsEnabled && mAutoEnterSpaceEnabled; |
| } |
| mCapSentences = (attribute.inputType |
| & EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES) != 0; |
| mCapWords = ((attribute.inputType & EditorInfo.TYPE_TEXT_FLAG_CAP_WORDS) != 0) || |
| (LeanbackUtils.getInputTypeVariation(attribute) |
| == EditorInfo.TYPE_TEXT_VARIATION_PERSON_NAME); |
| mCapCharacters = (attribute.inputType |
| & EditorInfo.TYPE_TEXT_FLAG_CAP_CHARACTERS) != 0; |
| |
| if (attribute.privateImeOptions != null) { |
| if (attribute.privateImeOptions.contains(IME_PRIVATE_OPTIONS_ESCAPE_NORTH) || |
| attribute.privateImeOptions.contains( |
| IME_PRIVATE_OPTIONS_ESCAPE_NORTH_LEGACY)) { |
| mEscapeNorthEnabled = true; |
| } |
| if (attribute.privateImeOptions.contains(IME_PRIVATE_OPTIONS_VOICE_DISMISS) || |
| attribute.privateImeOptions.contains( |
| IME_PRIVATE_OPTIONS_VOICE_DISMISS_LEGACY)) { |
| mVoiceKeyDismissesEnabled = true; |
| } |
| } |
| |
| if (DEBUG) { |
| Log.d(TAG, "sugg: " + mSuggestionsEnabled + " | capSentences: " + mCapSentences |
| + " | capWords: " + mCapWords + " | capChar: " + mCapCharacters |
| + " | escapeNorth: " + mEscapeNorthEnabled |
| + " | voiceDismiss : " + mVoiceKeyDismissesEnabled |
| ); |
| } |
| |
| // set enter key |
| mEnterKeyText = attribute.actionLabel; |
| if (TextUtils.isEmpty(mEnterKeyText)) { |
| switch (LeanbackUtils.getImeAction(attribute)) { |
| case EditorInfo.IME_ACTION_GO: |
| mEnterKeyTextResId = R.string.label_go_key; |
| break; |
| case EditorInfo.IME_ACTION_NEXT: |
| mEnterKeyTextResId = R.string.label_next_key; |
| break; |
| case EditorInfo.IME_ACTION_SEARCH: |
| mEnterKeyTextResId = R.string.label_search_key; |
| break; |
| case EditorInfo.IME_ACTION_SEND: |
| mEnterKeyTextResId = R.string.label_send_key; |
| break; |
| default: |
| mEnterKeyTextResId = R.string.label_done_key; |
| break; |
| } |
| } |
| |
| if (!VOICE_SUPPORTED) { |
| mVoiceEnabled = false; |
| } |
| } |
| |
| public boolean isVoiceEnabled() { |
| return mVoiceEnabled; |
| } |
| |
| public boolean areSuggestionsEnabled() { |
| return mSuggestionsEnabled; |
| } |
| |
| public boolean enableAutoEnterSpace() { |
| return mAutoEnterSpaceEnabled; |
| } |
| |
| private PointF getAlignmentPosition(float posXCm, float posYCm, PointF result) { |
| float width = mRootView.getWidth() - mRootView.getPaddingRight() |
| - mRootView.getPaddingLeft() |
| - mContext.getResources().getDimension(R.dimen.selector_size); |
| float height = mRootView.getHeight() - mRootView.getPaddingTop() |
| - mRootView.getPaddingBottom() |
| - mContext.getResources().getDimension(R.dimen.selector_size); |
| result.x = posXCm / PHYSICAL_WIDTH_CM * width + mRootView.getPaddingLeft(); |
| result.y = posYCm / PHYSICAL_HEIGHT_CM * height + mRootView.getPaddingTop(); |
| return result; |
| } |
| |
| private void getPhysicalPosition(float x, float y, PointF result) { |
| x -= mSelector.getWidth() / 2; |
| y -= mSelector.getHeight() / 2; |
| float width = mRootView.getWidth() - mRootView.getPaddingRight() |
| - mRootView.getPaddingLeft() |
| - mContext.getResources().getDimension(R.dimen.selector_size); |
| float height = mRootView.getHeight() - mRootView.getPaddingTop() |
| - mRootView.getPaddingBottom() |
| - mContext.getResources().getDimension(R.dimen.selector_size); |
| float posXCm = (x - mRootView.getPaddingLeft()) * PHYSICAL_WIDTH_CM / width; |
| float posYCm = (y - mRootView.getPaddingTop()) * PHYSICAL_HEIGHT_CM / height; |
| result.x = posXCm; |
| result.y = posYCm; |
| } |
| |
| private void offsetRect(Rect rect, View view) { |
| rect.left = 0; |
| rect.top = 0; |
| rect.right = view.getWidth(); |
| rect.bottom = view.getHeight(); |
| ((ViewGroup) mRootView).offsetDescendantRectToMyCoords(view, rect); |
| } |
| |
| /** |
| * Finds the {@link KeyFocus} on screen that best matches the given pixel positions |
| * |
| * @param x position in pixels, if null, use the last valid x value |
| * @param y position in pixels, if null, use the last valid y value |
| * @param focus the focus object to update with the result |
| * @return true if focus was successfully found, false otherwise. |
| */ |
| public boolean getBestFocus(Float x, Float y, KeyFocus focus) { |
| boolean validFocus = true; |
| |
| offsetRect(mRect, mActionButtonView); |
| int actionLeft = mRect.left; |
| |
| offsetRect(mRect, mMainKeyboardView); |
| int keyboardTop = mRect.top; |
| |
| // use last if invalid |
| x = (x == null) ? mX : x; |
| y = (y == null) ? mY : y; |
| |
| final int count = mSuggestions.getChildCount(); |
| if (y < keyboardTop && count > 0 && mSuggestionsEnabled) { |
| for (int i = 0; i < count; i++) { |
| View suggestView = mSuggestions.getChildAt(i); |
| offsetRect(mRect, suggestView); |
| if (x < mRect.right || i+1 == count) { |
| suggestView.requestFocus(); |
| LeanbackUtils.sendAccessibilityEvent(suggestView.findViewById(R.id.text), true); |
| configureFocus(focus, mRect, i, KeyFocus.TYPE_SUGGESTION); |
| break; |
| } |
| } |
| } else if (y < keyboardTop && mEscapeNorthEnabled) { |
| validFocus = false; |
| escapeNorth(); |
| } else if (x > actionLeft) { |
| // closest is the action button |
| offsetRect(mRect, mActionButtonView); |
| configureFocus(focus, mRect, 0, KeyFocus.TYPE_ACTION); |
| } else { |
| mX = x; |
| mY = y; |
| |
| // In the main view |
| offsetRect(mRect, mMainKeyboardView); |
| x = (x - mRect.left); |
| y = (y - mRect.top); |
| |
| int index = mMainKeyboardView.getNearestIndex(x, y); |
| Key key = mMainKeyboardView.getKey(index); |
| configureFocus(focus, mRect, index, key, KeyFocus.TYPE_MAIN); |
| } |
| |
| return validFocus; |
| } |
| |
| private void escapeNorth() { |
| if (DEBUG) Log.v(TAG, "Escaping north"); |
| mDismissListener.onDismiss(false); |
| } |
| |
| private void configureFocus(KeyFocus focus, Rect rect, int index, int type) { |
| focus.type = type; |
| focus.index = index; |
| focus.rect.set(rect); |
| } |
| |
| private void configureFocus(KeyFocus focus, Rect rect, int index, Key key, int type) { |
| focus.type = type; |
| if (key == null) { |
| return; |
| } |
| if (key.codes != null) { |
| focus.code = key.codes[0]; |
| } else { |
| focus.code = KeyEvent.KEYCODE_UNKNOWN; |
| } |
| focus.index = index; |
| focus.label = key.label; |
| focus.rect.left = key.x + rect.left; |
| focus.rect.top = key.y + rect.top; |
| focus.rect.right = focus.rect.left + key.width; |
| focus.rect.bottom = focus.rect.top + key.height; |
| } |
| |
| private void setKbFocus(KeyFocus focus, boolean forceFocusChange, boolean animate) { |
| if (focus.equals(mCurrKeyInfo) && !forceFocusChange) { |
| // Nothing changed |
| return; |
| } |
| LeanbackKeyboardView prevView = mPrevView; |
| mPrevView = null; |
| boolean overestimateWidth = false; |
| boolean overestimateHeight = false; |
| |
| switch (focus.type) { |
| case KeyFocus.TYPE_VOICE: |
| mVoiceButtonView.setMicFocused(true); |
| dismissMiniKeyboard(); |
| break; |
| case KeyFocus.TYPE_ACTION: |
| LeanbackUtils.sendAccessibilityEvent(mActionButtonView, true); |
| dismissMiniKeyboard(); |
| break; |
| case KeyFocus.TYPE_SUGGESTION: |
| dismissMiniKeyboard(); |
| break; |
| case KeyFocus.TYPE_MAIN: |
| overestimateHeight = true; |
| overestimateWidth = (focus.code != LeanbackKeyboardView.ASCII_SPACE); |
| mMainKeyboardView.setFocus(focus.index, mTouchState == TOUCH_STATE_CLICK, overestimateWidth); |
| mPrevView = mMainKeyboardView; |
| break; |
| } |
| |
| if (prevView != null && prevView != mPrevView) { |
| prevView.setFocus(-1, mTouchState == TOUCH_STATE_CLICK); |
| } |
| |
| setSelectorToFocus(focus.rect, overestimateWidth, overestimateHeight, animate); |
| mCurrKeyInfo.set(focus); |
| } |
| |
| public void setSelectorToFocus(Rect rect, boolean overestimateWidth, boolean overestimateHeight, |
| boolean animate) { |
| if (mSelector.getWidth() == 0 || mSelector.getHeight() == 0 |
| || rect.width() == 0 || rect.height() == 0) { |
| return; |
| } |
| |
| float width = rect.width(); |
| float height = rect.height(); |
| |
| if (overestimateHeight) { |
| height *= mOverestimate; |
| } |
| if (overestimateWidth) { |
| width *= mOverestimate; |
| } |
| |
| float major = Math.max(width, height); |
| float minor = Math.min(width, height); |
| // if the difference between the width and height is less than 10%, |
| // keep the width and height the same. |
| if (major / minor < 1.1) { |
| width = height = Math.max(width, height); |
| } |
| |
| float x = rect.exactCenterX() - width/2; |
| float y = rect.exactCenterY() - height/2; |
| mSelectorAnimation.cancel(); |
| if (animate) { |
| mSelectorAnimation.reset(); |
| mSelectorAnimation.setAnimationBounds(x, y, width, height); |
| mSelector.startAnimation(mSelectorAnimation); |
| } else { |
| mSelectorAnimation.setValues(x, y, width, height); |
| } |
| } |
| |
| public Keyboard.Key getKey(int type, int index) { |
| return (type == KeyFocus.TYPE_MAIN) ? mMainKeyboardView.getKey(index) : null; |
| } |
| |
| public int getCurrKeyCode() { |
| Key key = getKey(mCurrKeyInfo.type, mCurrKeyInfo.index); |
| if (key != null) { |
| return key.codes[0]; |
| } |
| return 0; |
| } |
| |
| public int getTouchState() { |
| return mTouchState; |
| } |
| |
| /** |
| * Set the view state which affects how the touch indicator is drawn. This code currently |
| * assumes the state changes below for simplicity. If the state machine is updated this code |
| * should probably be checked to ensure it still works. NO_TOUCH -> on touch start -> SNAP SNAP |
| * -> on enough movement -> MOVE MOVE -> on hover long enough -> SNAP SNAP -> on a click down -> |
| * CLICK CLICK -> on click released -> SNAP ANY STATE -> on touch end -> NO_TOUCH |
| * |
| * @param state The new state to transition to |
| */ |
| public void setTouchState(int state) { |
| switch (state) { |
| case TOUCH_STATE_NO_TOUCH: |
| if (mTouchState == TOUCH_STATE_TOUCH_MOVE || mTouchState == TOUCH_STATE_CLICK) { |
| // If the touch indicator was small make it big again |
| mSelectorAnimator.reverse(); |
| } |
| break; |
| case TOUCH_STATE_TOUCH_SNAP: |
| if (mTouchState == TOUCH_STATE_CLICK) { |
| // And make the touch indicator big again |
| mSelectorAnimator.reverse(); |
| } else if (mTouchState == TOUCH_STATE_TOUCH_MOVE) { |
| // Just make the touch indicator big |
| mSelectorAnimator.reverse(); |
| } |
| break; |
| case TOUCH_STATE_TOUCH_MOVE: |
| if (mTouchState == TOUCH_STATE_NO_TOUCH || mTouchState == TOUCH_STATE_TOUCH_SNAP) { |
| // Shrink the touch indicator |
| mSelectorAnimator.start(); |
| } |
| break; |
| case TOUCH_STATE_CLICK: |
| if (mTouchState == TOUCH_STATE_NO_TOUCH || mTouchState == TOUCH_STATE_TOUCH_SNAP) { |
| // Shrink the touch indicator |
| mSelectorAnimator.start(); |
| } |
| break; |
| } |
| setTouchStateInternal(state); |
| setKbFocus(mCurrKeyInfo, true, true); |
| } |
| |
| public KeyFocus getCurrFocus() { |
| return mCurrKeyInfo; |
| } |
| |
| public void onVoiceClick() { |
| if (mVoiceButtonView != null) { |
| mVoiceButtonView.onClick(); |
| } |
| } |
| |
| public void onModeChangeClick() { |
| dismissMiniKeyboard(); |
| if (mMainKeyboardView.getKeyboard().equals(mSymKeyboard)) { |
| mMainKeyboardView.setKeyboard(mAbcKeyboard); |
| } else { |
| mMainKeyboardView.setKeyboard(mSymKeyboard); |
| } |
| } |
| |
| public void onShiftClick() { |
| setShiftState(mMainKeyboardView.isShifted() ? LeanbackKeyboardView.SHIFT_OFF |
| : LeanbackKeyboardView.SHIFT_ON); |
| } |
| |
| public void onTextEntry() { |
| // reset shift if caps is not on |
| if (mMainKeyboardView.isShifted()) { |
| if (!isCapsLockOn() && !mCapCharacters) { |
| setShiftState(LeanbackKeyboardView.SHIFT_OFF); |
| } |
| } else { |
| if (isCapsLockOn() || mCapCharacters) { |
| setShiftState(LeanbackKeyboardView.SHIFT_LOCKED); |
| } |
| } |
| |
| if (dismissMiniKeyboard()) { |
| moveFocusToIndex(mMiniKbKeyIndex, KeyFocus.TYPE_MAIN); |
| } |
| } |
| |
| public void onSpaceEntry() { |
| if (mMainKeyboardView.isShifted()) { |
| if (!isCapsLockOn() && !mCapCharacters && !mCapWords) { |
| setShiftState(LeanbackKeyboardView.SHIFT_OFF); |
| } |
| } else { |
| if (isCapsLockOn() || mCapCharacters || mCapWords) { |
| setShiftState(LeanbackKeyboardView.SHIFT_ON); |
| } |
| } |
| } |
| |
| public void onPeriodEntry() { |
| if (mMainKeyboardView.isShifted()) { |
| if (!isCapsLockOn() && !mCapCharacters && !mCapWords && !mCapSentences) { |
| setShiftState(LeanbackKeyboardView.SHIFT_OFF); |
| } |
| } else { |
| if (isCapsLockOn() || mCapCharacters || mCapWords || mCapSentences) { |
| setShiftState(LeanbackKeyboardView.SHIFT_ON); |
| } |
| } |
| } |
| |
| public boolean dismissMiniKeyboard() { |
| return mMainKeyboardView.dismissMiniKeyboard(); |
| } |
| |
| public boolean isCurrKeyShifted() { |
| return mMainKeyboardView.isShifted(); |
| } |
| |
| public CharSequence getSuggestionText(int index) { |
| CharSequence text = null; |
| |
| if(index >= 0 && index < mSuggestions.getChildCount()){ |
| Button suggestion = |
| (Button) mSuggestions.getChildAt(index).findViewById(R.id.text); |
| if (suggestion != null) { |
| text = suggestion.getText(); |
| } |
| } |
| |
| return text; |
| } |
| |
| /** |
| * This method sets the keyboard focus and update the layout of the new focus |
| * |
| * @param focus the new focus of the keyboard |
| */ |
| public void setFocus(KeyFocus focus) { |
| setKbFocus(focus, false, true); |
| } |
| |
| public boolean getNextFocusInDirection(int direction, KeyFocus startFocus, KeyFocus nextFocus) { |
| boolean validNextFocus = true; |
| |
| switch (startFocus.type) { |
| case KeyFocus.TYPE_VOICE: |
| // TODO move between voice button and kb button |
| break; |
| case KeyFocus.TYPE_ACTION: |
| offsetRect(mRect, mMainKeyboardView); |
| if ((direction & DIRECTION_LEFT) != 0) { |
| // y is null, so we use the last y. This way a user can hold left and wrap |
| // around the keyboard while staying in the same row |
| validNextFocus = getBestFocus((float) mRect.right, null, nextFocus); |
| } else if ((direction & DIRECTION_UP) != 0) { |
| offsetRect(mRect, mSuggestions); |
| validNextFocus = getBestFocus( |
| (float) startFocus.rect.centerX(), (float) mRect.centerY(), nextFocus); |
| } |
| break; |
| case KeyFocus.TYPE_SUGGESTION: |
| if ((direction & DIRECTION_DOWN) != 0) { |
| offsetRect(mRect, mMainKeyboardView); |
| validNextFocus = getBestFocus( |
| (float) startFocus.rect.centerX(), (float) mRect.top, nextFocus); |
| } else if ((direction & DIRECTION_UP) != 0) { |
| if (mEscapeNorthEnabled) { |
| escapeNorth(); |
| } |
| } else { |
| boolean left = (direction & DIRECTION_LEFT) != 0; |
| boolean right = (direction & DIRECTION_RIGHT) != 0; |
| |
| if (left || right) { |
| // Cannot offset on the suggestion container because as it scrolls those |
| // values change |
| offsetRect(mRect, mRootView); |
| MarginLayoutParams lp = |
| (MarginLayoutParams) mSuggestionsContainer.getLayoutParams(); |
| int leftSide = mRect.left + lp.leftMargin; |
| int rightSide = mRect.right - lp.rightMargin; |
| int index = startFocus.index + (left ? -1 : 1); |
| |
| View suggestView = mSuggestions.getChildAt(index); |
| if (suggestView != null) { |
| offsetRect(mRect, suggestView); |
| |
| if (mRect.left < leftSide && mRect.right > rightSide) { |
| mRect.left = leftSide; |
| mRect.right = rightSide; |
| } else if (mRect.left < leftSide) { |
| mRect.right = leftSide + mRect.width(); |
| mRect.left = leftSide; |
| } else if (mRect.right > rightSide) { |
| mRect.left = rightSide - mRect.width(); |
| mRect.right = rightSide; |
| } |
| |
| suggestView.requestFocus(); |
| LeanbackUtils.sendAccessibilityEvent( |
| suggestView.findViewById(R.id.text), true); |
| configureFocus(nextFocus, mRect, index, KeyFocus.TYPE_SUGGESTION); |
| } |
| } |
| } |
| break; |
| case KeyFocus.TYPE_MAIN: |
| Key key = getKey(startFocus.type, startFocus.index); |
| // Step within the view. Using height because all keys are the same height |
| // and widths vary. Half the height is to ensure the next key is reached |
| float extraSlide = startFocus.rect.height()/2.0f; |
| float x = startFocus.rect.centerX(); |
| float y = startFocus.rect.centerY(); |
| if (startFocus.code == LeanbackKeyboardView.ASCII_SPACE) { |
| // if we're moving off of space, use the old x position for memory |
| x = mX; |
| } |
| if ((direction & DIRECTION_LEFT) != 0) { |
| if ((key.edgeFlags & Keyboard.EDGE_LEFT) == 0) { |
| // not on the left edge of the kb |
| x = startFocus.rect.left - extraSlide; |
| } |
| } else if ((direction & DIRECTION_RIGHT) != 0) { |
| if ((key.edgeFlags & Keyboard.EDGE_RIGHT) != 0) { |
| // jump to the action button |
| offsetRect(mRect, mActionButtonView); |
| x = mRect.centerX(); |
| } else { |
| x = startFocus.rect.right + extraSlide; |
| } |
| } |
| // Don't need any special handling for up/down due to |
| // layout positioning. If the layout changes this should be |
| // reconsidered. |
| if ((direction & DIRECTION_UP) != 0) { |
| y -= startFocus.rect.height() * DIRECTION_STEP_MULTIPLIER; |
| } else if ((direction & DIRECTION_DOWN) != 0) { |
| y += startFocus.rect.height() * DIRECTION_STEP_MULTIPLIER; |
| } |
| getPhysicalPosition(x, y, mTempPoint); |
| validNextFocus = getBestFocus(x, y, nextFocus); |
| break; |
| } |
| |
| return validNextFocus; |
| } |
| |
| private PointF getTouchSnapPosition() { |
| PointF snapPos = new PointF(); |
| getPhysicalPosition(mCurrKeyInfo.rect.centerX(), mCurrKeyInfo.rect.centerY(), snapPos); |
| return snapPos; |
| } |
| |
| public void clearSuggestions() { |
| mSuggestions.removeAllViews(); |
| |
| if (getCurrFocus().type == KeyFocus.TYPE_SUGGESTION) { |
| resetFocusCursor(); |
| } |
| } |
| |
| public void updateSuggestions(ArrayList<String> suggestions) { |
| final int oldCount = mSuggestions.getChildCount(); |
| final int newCount = suggestions.size(); |
| |
| if (newCount < oldCount) { |
| // remove excess views |
| mSuggestions.removeViews(newCount, oldCount-newCount); |
| } else if (newCount > oldCount) { |
| // add more |
| for (int i = oldCount; i < newCount; i++) { |
| View suggestion = mContext.getLayoutInflater() |
| .inflate(R.layout.candidate, null); |
| mSuggestions.addView(suggestion); |
| } |
| } |
| |
| for (int i = 0; i < newCount; i++) { |
| Button suggestion = |
| (Button) mSuggestions.getChildAt(i).findViewById(R.id.text); |
| suggestion.setText(suggestions.get(i)); |
| suggestion.setContentDescription(suggestions.get(i)); |
| } |
| |
| if (getCurrFocus().type == KeyFocus.TYPE_SUGGESTION) { |
| resetFocusCursor(); |
| } |
| } |
| |
| /** |
| * Moves the selector back to the entry point key (T in general) |
| */ |
| public void resetFocusCursor() { |
| // T is the best starting letter, it's in the 5th column and 2nd row, |
| // this approximates that location |
| double x = 0.45; |
| double y = 0.375; |
| offsetRect(mRect, mMainKeyboardView); |
| mX = (float)(mRect.left + x*mRect.width()); |
| mY = (float)(mRect.top + y*mRect.height()); |
| getBestFocus(mX, mY, mTempKeyInfo); |
| setKbFocus(mTempKeyInfo, true, false); |
| |
| setTouchStateInternal(TOUCH_STATE_NO_TOUCH); |
| mSelectorAnimator.reverse(); |
| mSelectorAnimator.end(); |
| } |
| |
| private void setTouchStateInternal(int state) { |
| mTouchState = state; |
| } |
| |
| private void setShiftState(int state) { |
| mMainKeyboardView.setShiftState(state); |
| } |
| |
| private void startRecognition(Context context) { |
| mRecognizerIntent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH); |
| mRecognizerIntent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, |
| RecognizerIntent.LANGUAGE_MODEL_FREE_FORM); |
| mRecognizerIntent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true); |
| mSpeechRecognizer.setRecognitionListener(new RecognitionListener() { |
| float peakRmsLevel = 0; |
| int rmsCounter = 0; |
| |
| @Override |
| public void onBeginningOfSpeech() { |
| mVoiceButtonView.showRecording(); |
| } |
| |
| @Override |
| public void onEndOfSpeech() { |
| mVoiceButtonView.showRecognizing(); |
| mVoiceOn = false; |
| } |
| |
| @Override |
| public void onError(int error) { |
| cancelVoiceRecording(); |
| switch (error) { |
| case SpeechRecognizer.ERROR_NO_MATCH: |
| Log.d(TAG, "recognizer error no match"); |
| break; |
| case SpeechRecognizer.ERROR_SERVER: |
| Log.d(TAG, "recognizer error server error"); |
| break; |
| case SpeechRecognizer.ERROR_SPEECH_TIMEOUT: |
| Log.d(TAG, "recognizer error speech timeout"); |
| break; |
| case SpeechRecognizer.ERROR_CLIENT: |
| Log.d(TAG, "recognizer error client error"); |
| break; |
| default: |
| Log.d(TAG, "recognizer other error " + error); |
| break; |
| } |
| } |
| |
| @Override |
| public synchronized void onPartialResults(Bundle partialResults) { |
| } |
| |
| @Override |
| public void onReadyForSpeech(Bundle params) { |
| mVoiceButtonView.showListening(); |
| } |
| |
| @Override |
| public void onEvent(int eventType, Bundle params) { |
| } |
| |
| @Override |
| public void onBufferReceived(byte[] buffer) { |
| } |
| |
| @Override |
| public synchronized void onRmsChanged(float rmsdB) { |
| |
| mVoiceOn = true; |
| mSpeechLevelSource.setSpeechLevel((rmsdB < 0) ? 0 : (int) (10 * rmsdB)); |
| peakRmsLevel = Math.max(rmsdB, peakRmsLevel); |
| rmsCounter++; |
| |
| if (rmsCounter > 100 && peakRmsLevel == 0) { |
| mVoiceButtonView.showNotListening(); |
| } |
| } |
| |
| @Override |
| public void onResults(Bundle results) { |
| final ArrayList<String> matches = |
| results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION); |
| if (matches != null) { |
| if (mVoiceListener != null) { |
| mVoiceListener.onVoiceResult(matches.get(0)); |
| } |
| } |
| |
| cancelVoiceRecording(); |
| } |
| }); |
| mSpeechRecognizer.startListening(mRecognizerIntent); |
| } |
| |
| public boolean isMiniKeyboardOnScreen() { |
| return mMainKeyboardView.isMiniKeyboardOnScreen(); |
| } |
| |
| public boolean onKeyLongPress() { |
| if (mCurrKeyInfo.code == Keyboard.KEYCODE_SHIFT) { |
| onToggleCapsLock(); |
| setTouchState(TOUCH_STATE_NO_TOUCH); |
| return true; |
| } else if (mCurrKeyInfo.type == KeyFocus.TYPE_MAIN) { |
| mMainKeyboardView.onKeyLongPress(); |
| if (mMainKeyboardView.isMiniKeyboardOnScreen()) { |
| mMiniKbKeyIndex = mCurrKeyInfo.index; |
| moveFocusToIndex(mMainKeyboardView.getBaseMiniKbIndex(), KeyFocus.TYPE_MAIN); |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| private void moveFocusToIndex(int index, int type) { |
| Key key = mMainKeyboardView.getKey(index); |
| configureFocus(mTempKeyInfo, mRect, index, key, type); |
| setTouchState(TOUCH_STATE_NO_TOUCH); |
| setKbFocus(mTempKeyInfo, true, true); |
| } |
| |
| private void onToggleCapsLock() { |
| onShiftDoubleClick(isCapsLockOn()); |
| } |
| |
| public void onShiftDoubleClick(boolean wasCapsLockOn) { |
| setShiftState( |
| wasCapsLockOn ? LeanbackKeyboardView.SHIFT_OFF : LeanbackKeyboardView.SHIFT_LOCKED); |
| } |
| |
| public boolean isCapsLockOn() { |
| return mMainKeyboardView.getShiftState() == LeanbackKeyboardView.SHIFT_LOCKED; |
| } |
| } |
