/*
* Copyright (C) 2009 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.pinyin;
import android.content.Context;
import android.content.res.Resources;
import android.inputmethodservice.InputMethodService;
import android.os.Handler;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.widget.PopupWindow;
import android.widget.RelativeLayout;
import android.widget.ViewFlipper;
/**
* The top container to host soft keyboard view(s).
*/
public class SkbContainer extends RelativeLayout implements OnTouchListener {
/**
* For finger touch, user tends to press the bottom part of the target key,
* or he/she even presses the area out of it, so it is necessary to make a
* simple bias correction. If the input method runs on emulator, no bias
* correction will be used.
*/
private static final int Y_BIAS_CORRECTION = -10;
/**
* Used to skip these move events whose position is too close to the
* previous touch events.
*/
private static final int MOVE_TOLERANCE = 6;
/**
* If this member is true, PopupWindow is used to show on-key highlight
* effect.
*/
private static boolean POPUPWINDOW_FOR_PRESSED_UI = false;
/**
* The current soft keyboard layout.
*
* @see com.android.inputmethod.pinyin.InputModeSwitcher for detailed layout
* definitions.
*/
private int mSkbLayout = 0;
/**
* The input method service.
*/
private InputMethodService mService;
/**
* Input mode switcher used to switch between different modes like Chinese,
* English, etc.
*/
private InputModeSwitcher mInputModeSwitcher;
/**
* The gesture detector.
*/
private GestureDetector mGestureDetector;
private Environment mEnvironment;
private ViewFlipper mSkbFlipper;
/**
* The popup balloon hint for key press/release.
*/
private BalloonHint mBalloonPopup;
/**
* The on-key balloon hint for key press/release.
*/
private BalloonHint mBalloonOnKey = null;
/** The major sub soft keyboard. */
private SoftKeyboardView mMajorView;
/**
* The last parameter when function {@link #toggleCandidateMode(boolean)}
* was called.
*/
private boolean mLastCandidatesShowing;
/** Used to indicate whether a popup soft keyboard is shown. */
private boolean mPopupSkbShow = false;
/**
* Used to indicate whether a popup soft keyboard is just shown, and waits
* for the touch event to release. After the release, the popup window can
* response to touch events.
**/
private boolean mPopupSkbNoResponse = false;
/** Popup sub keyboard. */
private PopupWindow mPopupSkb;
/** The view of the popup sub soft keyboard. */
private SoftKeyboardView mPopupSkbView;
private int mPopupX;
private int mPopupY;
/**
* When user presses a key, a timer is started, when it times out, it is
* necessary to detect whether user still holds the key.
*/
private volatile boolean mWaitForTouchUp = false;
/**
* When user drags on the soft keyboard and the distance is enough, this
* drag will be recognized as a gesture and a gesture-based action will be
* taken, in this situation, ignore the consequent events.
*/
private volatile boolean mDiscardEvent = false;
/**
* For finger touch, user tends to press the bottom part of the target key,
* or he/she even presses the area out of it, so it is necessary to make a
* simple bias correction in Y.
*/
private int mYBiasCorrection = 0;
/**
* The x coordination of the last touch event.
*/
private int mXLast;
/**
* The y coordination of the last touch event.
*/
private int mYLast;
/**
* The soft keyboard view.
*/
private SoftKeyboardView mSkv;
/**
* The position of the soft keyboard view in the container.
*/
private int mSkvPosInContainer[] = new int[2];
/**
* The key pressed by user.
*/
private SoftKey mSoftKeyDown = null;
/**
* Used to timeout a press if user holds the key for a long time.
*/
private LongPressTimer mLongPressTimer;
/**
* For temporary use.
*/
private int mXyPosTmp[] = new int[2];
public SkbContainer(Context context, AttributeSet attrs) {
super(context, attrs);
mEnvironment = Environment.getInstance();
mLongPressTimer = new LongPressTimer(this);
// If it runs on an emulator, no bias correction
if ("1".equals(SystemProperties.get("ro.kernel.qemu"))) {
mYBiasCorrection = 0;
} else {
mYBiasCorrection = Y_BIAS_CORRECTION;
}
mBalloonPopup = new BalloonHint(context, this, MeasureSpec.AT_MOST);
if (POPUPWINDOW_FOR_PRESSED_UI) {
mBalloonOnKey = new BalloonHint(context, this, MeasureSpec.AT_MOST);
}
mPopupSkb = new PopupWindow(mContext);
mPopupSkb.setBackgroundDrawable(null);
mPopupSkb.setClippingEnabled(false);
}
public void setService(InputMethodService service) {
mService = service;
}
public void setInputModeSwitcher(InputModeSwitcher inputModeSwitcher) {
mInputModeSwitcher = inputModeSwitcher;
}
public void setGestureDetector(GestureDetector gestureDetector) {
mGestureDetector = gestureDetector;
}
public boolean isCurrentSkbSticky() {
if (null == mMajorView) return true;
SoftKeyboard skb = mMajorView.getSoftKeyboard();
if (null != skb) {
return skb.getStickyFlag();
}
return true;
}
public void toggleCandidateMode(boolean candidatesShowing) {
if (null == mMajorView || !mInputModeSwitcher.isChineseText()
|| mLastCandidatesShowing == candidatesShowing) return;
mLastCandidatesShowing = candidatesShowing;
SoftKeyboard skb = mMajorView.getSoftKeyboard();
if (null == skb) return;
int state = mInputModeSwitcher.getTooggleStateForCnCand();
if (!candidatesShowing) {
skb.disableToggleState(state, false);
skb.enableToggleStates(mInputModeSwitcher.getToggleStates());
} else {
skb.enableToggleState(state, false);
}
mMajorView.invalidate();
}
public void updateInputMode() {
int skbLayout = mInputModeSwitcher.getSkbLayout();
if (mSkbLayout != skbLayout) {
mSkbLayout = skbLayout;
updateSkbLayout();
}
mLastCandidatesShowing = false;
if (null == mMajorView) return;
SoftKeyboard skb = mMajorView.getSoftKeyboard();
if (null == skb) return;
skb.enableToggleStates(mInputModeSwitcher.getToggleStates());
invalidate();
return;
}
private void updateSkbLayout() {
int screenWidth = mEnvironment.getScreenWidth();
int keyHeight = mEnvironment.getKeyHeight();
int skbHeight = mEnvironment.getSkbHeight();
Resources r = mContext.getResources();
if (null == mSkbFlipper) {
mSkbFlipper = (ViewFlipper) findViewById(R.id.alpha_floatable);
}
mMajorView = (SoftKeyboardView) mSkbFlipper.getChildAt(0);
SoftKeyboard majorSkb = null;
SkbPool skbPool = SkbPool.getInstance();
switch (mSkbLayout) {
case R.xml.skb_qwerty:
majorSkb = skbPool.getSoftKeyboard(R.xml.skb_qwerty,
R.xml.skb_qwerty, screenWidth, skbHeight, mContext);
break;
case R.xml.skb_sym1:
majorSkb = skbPool.getSoftKeyboard(R.xml.skb_sym1, R.xml.skb_sym1,
screenWidth, skbHeight, mContext);
break;
case R.xml.skb_sym2:
majorSkb = skbPool.getSoftKeyboard(R.xml.skb_sym2, R.xml.skb_sym2,
screenWidth, skbHeight, mContext);
break;
case R.xml.skb_smiley:
majorSkb = skbPool.getSoftKeyboard(R.xml.skb_smiley,
R.xml.skb_smiley, screenWidth, skbHeight, mContext);
break;
case R.xml.skb_phone:
majorSkb = skbPool.getSoftKeyboard(R.xml.skb_phone,
R.xml.skb_phone, screenWidth, skbHeight, mContext);
break;
default:
}
if (null == majorSkb || !mMajorView.setSoftKeyboard(majorSkb)) {
return;
}
mMajorView.setBalloonHint(mBalloonOnKey, mBalloonPopup, false);
mMajorView.invalidate();
}
private void responseKeyEvent(SoftKey sKey) {
if (null == sKey) return;
((PinyinIME) mService).responseSoftKeyEvent(sKey);
return;
}
private SoftKeyboardView inKeyboardView(int x, int y,
int positionInParent[]) {
if (mPopupSkbShow) {
if (mPopupX <= x && mPopupX + mPopupSkb.getWidth() > x
&& mPopupY <= y && mPopupY + mPopupSkb.getHeight() > y) {
positionInParent[0] = mPopupX;
positionInParent[1] = mPopupY;
mPopupSkbView.setOffsetToSkbContainer(positionInParent);
return mPopupSkbView;
}
return null;
}
return mMajorView;
}
private void popupSymbols() {
int popupResId = mSoftKeyDown.getPopupResId();
if (popupResId > 0) {
int skbContainerWidth = getWidth();
int skbContainerHeight = getHeight();
// The paddings of the background are not included.
int miniSkbWidth = (int) (skbContainerWidth * 0.8);
int miniSkbHeight = (int) (skbContainerHeight * 0.23);
SkbPool skbPool = SkbPool.getInstance();
SoftKeyboard skb = skbPool.getSoftKeyboard(popupResId, popupResId,
miniSkbWidth, miniSkbHeight, mContext);
if (null == skb) return;
mPopupX = (skbContainerWidth - skb.getSkbTotalWidth()) / 2;
mPopupY = (skbContainerHeight - skb.getSkbTotalHeight()) / 2;
if (null == mPopupSkbView) {
mPopupSkbView = new SoftKeyboardView(mContext, null);
mPopupSkbView.onMeasure(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT);
}
mPopupSkbView.setOnTouchListener(this);
mPopupSkbView.setSoftKeyboard(skb);
mPopupSkbView.setBalloonHint(mBalloonOnKey, mBalloonPopup, true);
mPopupSkb.setContentView(mPopupSkbView);
mPopupSkb.setWidth(skb.getSkbCoreWidth()
+ mPopupSkbView.getPaddingLeft()
+ mPopupSkbView.getPaddingRight());
mPopupSkb.setHeight(skb.getSkbCoreHeight()
+ mPopupSkbView.getPaddingTop()
+ mPopupSkbView.getPaddingBottom());
getLocationInWindow(mXyPosTmp);
mPopupSkb.showAtLocation(this, Gravity.NO_GRAVITY, mPopupX, mPopupY
+ mXyPosTmp[1]);
mPopupSkbShow = true;
mPopupSkbNoResponse = true;
// Invalidate itself to dim the current soft keyboards.
dimSoftKeyboard(true);
resetKeyPress(0);
}
}
private void dimSoftKeyboard(boolean dimSkb) {
mMajorView.dimSoftKeyboard(dimSkb);
}
private void dismissPopupSkb() {
mPopupSkb.dismiss();
mPopupSkbShow = false;
dimSoftKeyboard(false);
resetKeyPress(0);
}
private void resetKeyPress(long delay) {
mLongPressTimer.removeTimer();
if (null != mSkv) {
mSkv.resetKeyPress(delay);
}
}
public boolean handleBack(boolean realAction) {
if (mPopupSkbShow) {
if (!realAction) return true;
dismissPopupSkb();
mDiscardEvent = true;
return true;
}
return false;
}
public void dismissPopups() {
handleBack(true);
resetKeyPress(0);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
Environment env = Environment.getInstance();
int measuredWidth = env.getScreenWidth();
int measuredHeight = getPaddingTop();
measuredHeight += env.getSkbHeight();
widthMeasureSpec = MeasureSpec.makeMeasureSpec(measuredWidth,
MeasureSpec.EXACTLY);
heightMeasureSpec = MeasureSpec.makeMeasureSpec(measuredHeight,
MeasureSpec.EXACTLY);
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
super.onTouchEvent(event);
if (mSkbFlipper.isFlipping()) {
resetKeyPress(0);
return true;
}
int x = (int) event.getX();
int y = (int) event.getY();
// Bias correction
y = y + mYBiasCorrection;
// Ignore short-distance movement event to get better performance.
if (event.getAction() == MotionEvent.ACTION_MOVE) {
if (Math.abs(x - mXLast) <= MOVE_TOLERANCE
&& Math.abs(y - mYLast) <= MOVE_TOLERANCE) {
return true;
}
}
mXLast = x;
mYLast = y;
if (!mPopupSkbShow) {
if (mGestureDetector.onTouchEvent(event)) {
resetKeyPress(0);
mDiscardEvent = true;
return true;
}
}
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
resetKeyPress(0);
mWaitForTouchUp = true;
mDiscardEvent = false;
mSkv = null;
mSoftKeyDown = null;
mSkv = inKeyboardView(x, y, mSkvPosInContainer);
if (null != mSkv) {
mSoftKeyDown = mSkv.onKeyPress(x - mSkvPosInContainer[0], y
- mSkvPosInContainer[1], mLongPressTimer, false);
}
break;
case MotionEvent.ACTION_MOVE:
if (x < 0 || x >= getWidth() || y < 0 || y >= getHeight()) {
break;
}
if (mDiscardEvent) {
resetKeyPress(0);
break;
}
if (mPopupSkbShow && mPopupSkbNoResponse) {
break;
}
SoftKeyboardView skv = inKeyboardView(x, y, mSkvPosInContainer);
if (null != skv) {
if (skv != mSkv) {
mSkv = skv;
mSoftKeyDown = mSkv.onKeyPress(x - mSkvPosInContainer[0], y
- mSkvPosInContainer[1], mLongPressTimer, true);
} else if (null != skv) {
if (null != mSkv) {
mSoftKeyDown = mSkv.onKeyMove(
x - mSkvPosInContainer[0], y
- mSkvPosInContainer[1]);
if (null == mSoftKeyDown) {
mDiscardEvent = true;
}
}
}
}
break;
case MotionEvent.ACTION_UP:
if (mDiscardEvent) {
resetKeyPress(0);
break;
}
mWaitForTouchUp = false;
// The view which got the {@link MotionEvent#ACTION_DOWN} event is
// always used to handle this event.
if (null != mSkv) {
mSkv.onKeyRelease(x - mSkvPosInContainer[0], y
- mSkvPosInContainer[1]);
}
if (!mPopupSkbShow || !mPopupSkbNoResponse) {
responseKeyEvent(mSoftKeyDown);
}
if (mSkv == mPopupSkbView && !mPopupSkbNoResponse) {
dismissPopupSkb();
}
mPopupSkbNoResponse = false;
break;
case MotionEvent.ACTION_CANCEL:
break;
}
if (null == mSkv) {
return false;
}
return true;
}
// Function for interface OnTouchListener, it is used to handle touch events
// which will be delivered to the popup soft keyboard view.
public boolean onTouch(View v, MotionEvent event) {
// Translate the event to fit to the container.
MotionEvent newEv = MotionEvent.obtain(event.getDownTime(), event
.getEventTime(), event.getAction(), event.getX() + mPopupX,
event.getY() + mPopupY, event.getPressure(), event.getSize(),
event.getMetaState(), event.getXPrecision(), event
.getYPrecision(), event.getDeviceId(), event
.getEdgeFlags());
boolean ret = onTouchEvent(newEv);
return ret;
}
class LongPressTimer extends Handler implements Runnable {
/**
* When user presses a key for a long time, the timeout interval to
* generate first {@link #LONG_PRESS_KEYNUM1} key events.
*/
public static final int LONG_PRESS_TIMEOUT1 = 500;
/**
* When user presses a key for a long time, after the first
* {@link #LONG_PRESS_KEYNUM1} key events, this timeout interval will be
* used.
*/
private static final int LONG_PRESS_TIMEOUT2 = 100;
/**
* When user presses a key for a long time, after the first
* {@link #LONG_PRESS_KEYNUM2} key events, this timeout interval will be
* used.
*/
private static final int LONG_PRESS_TIMEOUT3 = 100;
/**
* When user presses a key for a long time, after the first
* {@link #LONG_PRESS_KEYNUM1} key events, timeout interval
* {@link #LONG_PRESS_TIMEOUT2} will be used instead.
*/
public static final int LONG_PRESS_KEYNUM1 = 1;
/**
* When user presses a key for a long time, after the first
* {@link #LONG_PRESS_KEYNUM2} key events, timeout interval
* {@link #LONG_PRESS_TIMEOUT3} will be used instead.
*/
public static final int LONG_PRESS_KEYNUM2 = 3;
SkbContainer mSkbContainer;
private int mResponseTimes = 0;
public LongPressTimer(SkbContainer skbContainer) {
mSkbContainer = skbContainer;
}
public void startTimer() {
postAtTime(this, SystemClock.uptimeMillis() + LONG_PRESS_TIMEOUT1);
mResponseTimes = 0;
}
public boolean removeTimer() {
removeCallbacks(this);
return true;
}
public void run() {
if (mWaitForTouchUp) {
mResponseTimes++;
if (mSoftKeyDown.repeatable()) {
if (mSoftKeyDown.isUserDefKey()) {
if (1 == mResponseTimes) {
if (mInputModeSwitcher
.tryHandleLongPressSwitch(mSoftKeyDown.mKeyCode)) {
mDiscardEvent = true;
resetKeyPress(0);
}
}
} else {
responseKeyEvent(mSoftKeyDown);
long timeout;
if (mResponseTimes < LONG_PRESS_KEYNUM1) {
timeout = LONG_PRESS_TIMEOUT1;
} else if (mResponseTimes < LONG_PRESS_KEYNUM2) {
timeout = LONG_PRESS_TIMEOUT2;
} else {
timeout = LONG_PRESS_TIMEOUT3;
}
postAtTime(this, SystemClock.uptimeMillis() + timeout);
}
} else {
if (1 == mResponseTimes) {
popupSymbols();
}
}
}
}
}
}
|
