/*
* 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.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.res.Configuration;
import android.inputmethodservice.InputMethodService;
import android.os.Handler;
import android.os.IBinder;
import android.os.RemoteException;
import android.preference.PreferenceManager;
import android.util.Log;
import android.view.Gravity;
import android.view.GestureDetector;
import android.view.LayoutInflater;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.View.MeasureSpec;
import android.view.ViewGroup.LayoutParams;
import android.view.inputmethod.CompletionInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputMethodManager;
import android.widget.LinearLayout;
import android.widget.PopupWindow;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
/**
* Main class of the Pinyin input method.
*/
public class PinyinIME extends InputMethodService {
/**
* TAG for debug.
*/
static final String TAG = "PinyinIME";
/**
* If is is true, IME will simulate key events for delete key, and send the
* events back to the application.
*/
private static final boolean SIMULATE_KEY_DELETE = true;
/**
* Necessary environment configurations like screen size for this IME.
*/
private Environment mEnvironment;
/**
* Used to switch input mode.
*/
private InputModeSwitcher mInputModeSwitcher;
/**
* Soft keyboard container view to host real soft keyboard view.
*/
private SkbContainer mSkbContainer;
/**
* The floating container which contains the composing view. If necessary,
* some other view like candiates container can also be put here.
*/
private LinearLayout mFloatingContainer;
/**
* View to show the composing string.
*/
private ComposingView mComposingView;
/**
* Window to show the composing string.
*/
private PopupWindow mFloatingWindow;
/**
* Used to show the floating window.
*/
private PopupTimer mFloatingWindowTimer = new PopupTimer();
/**
* View to show candidates list.
*/
private CandidatesContainer mCandidatesContainer;
/**
* Balloon used when user presses a candidate.
*/
private BalloonHint mCandidatesBalloon;
/**
* Used to notify the input method when the user touch a candidate.
*/
private ChoiceNotifier mChoiceNotifier;
/**
* Used to notify gestures from soft keyboard.
*/
private OnGestureListener mGestureListenerSkb;
/**
* Used to notify gestures from candidates view.
*/
private OnGestureListener mGestureListenerCandidates;
/**
* The on-screen movement gesture detector for soft keyboard.
*/
private GestureDetector mGestureDetectorSkb;
/**
* The on-screen movement gesture detector for candidates view.
*/
private GestureDetector mGestureDetectorCandidates;
/**
* Option dialog to choose settings and other IMEs.
*/
private AlertDialog mOptionsDialog;
/**
* Connection used to bind the decoding service.
*/
private PinyinDecoderServiceConnection mPinyinDecoderServiceConnection;
/**
* The current IME status.
*
* @see com.android.inputmethod.pinyin.PinyinIME.ImeState
*/
private ImeState mImeState = ImeState.STATE_IDLE;
/**
* The decoding information, include spelling(Pinyin) string, decoding
* result, etc.
*/
private DecodingInfo mDecInfo = new DecodingInfo();
/**
* For English input.
*/
private EnglishInputProcessor mImEn;
// receive ringer mode changes
private BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
SoundManager.getInstance(context).updateRingerMode();
}
};
@Override
public void onCreate() {
mEnvironment = Environment.getInstance();
if (mEnvironment.needDebug()) {
Log.d(TAG, "onCreate.");
}
super.onCreate();
startPinyinDecoderService();
mImEn = new EnglishInputProcessor();
Settings.getInstance(PreferenceManager
.getDefaultSharedPreferences(getApplicationContext()));
mInputModeSwitcher = new InputModeSwitcher(this);
mChoiceNotifier = new ChoiceNotifier(this);
mGestureListenerSkb = new OnGestureListener(false);
mGestureListenerCandidates = new OnGestureListener(true);
mGestureDetectorSkb = new GestureDetector(this, mGestureListenerSkb);
mGestureDetectorCandidates = new GestureDetector(this,
mGestureListenerCandidates);
mEnvironment.onConfigurationChanged(getResources().getConfiguration(),
this);
}
@Override
public void onDestroy() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onDestroy.");
}
unbindService(mPinyinDecoderServiceConnection);
Settings.releaseInstance();
super.onDestroy();
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
Environment env = Environment.getInstance();
if (mEnvironment.needDebug()) {
Log.d(TAG, "onConfigurationChanged");
Log.d(TAG, "--last config: " + env.getConfiguration().toString());
Log.d(TAG, "---new config: " + newConfig.toString());
}
// We need to change the local environment first so that UI components
// can get the environment instance to handle size issues. When
// super.onConfigurationChanged() is called, onCreateCandidatesView()
// and onCreateInputView() will be executed if necessary.
env.onConfigurationChanged(newConfig, this);
// Clear related UI of the previous configuration.
if (null != mSkbContainer) {
mSkbContainer.dismissPopups();
}
if (null != mCandidatesBalloon) {
mCandidatesBalloon.dismiss();
}
super.onConfigurationChanged(newConfig);
resetToIdleState(false);
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
if (processKey(event, 0 != event.getRepeatCount())) return true;
return super.onKeyDown(keyCode, event);
}
@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
if (processKey(event, true)) return true;
return super.onKeyUp(keyCode, event);
}
private boolean processKey(KeyEvent event, boolean realAction) {
if (ImeState.STATE_BYPASS == mImeState) return false;
int keyCode = event.getKeyCode();
// SHIFT-SPACE is used to switch between Chinese and English
// when HKB is on.
if (KeyEvent.KEYCODE_SPACE == keyCode && event.isShiftPressed()) {
if (!realAction) return true;
updateIcon(mInputModeSwitcher.switchLanguageWithHkb());
resetToIdleState(false);
int allMetaState = KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON
| KeyEvent.META_ALT_RIGHT_ON | KeyEvent.META_SHIFT_ON
| KeyEvent.META_SHIFT_LEFT_ON
| KeyEvent.META_SHIFT_RIGHT_ON | KeyEvent.META_SYM_ON;
getCurrentInputConnection().clearMetaKeyStates(allMetaState);
return true;
}
// If HKB is on to input English, by-pass the key event so that
// default key listener will handle it.
if (mInputModeSwitcher.isEnglishWithHkb()) {
return false;
}
if (processFunctionKeys(keyCode, realAction)) {
return true;
}
int keyChar = 0;
if (keyCode >= KeyEvent.KEYCODE_A && keyCode <= KeyEvent.KEYCODE_Z) {
keyChar = keyCode - KeyEvent.KEYCODE_A + 'a';
} else if (keyCode >= KeyEvent.KEYCODE_0
&& keyCode <= KeyEvent.KEYCODE_9) {
keyChar = keyCode - KeyEvent.KEYCODE_0 + '0';
} else if (keyCode == KeyEvent.KEYCODE_COMMA) {
keyChar = ',';
} else if (keyCode == KeyEvent.KEYCODE_PERIOD) {
keyChar = '.';
} else if (keyCode == KeyEvent.KEYCODE_SPACE) {
keyChar = ' ';
} else if (keyCode == KeyEvent.KEYCODE_APOSTROPHE) {
keyChar = '\'';
}
if (mInputModeSwitcher.isEnglishWithSkb()) {
return mImEn.processKey(getCurrentInputConnection(), event,
mInputModeSwitcher.isEnglishUpperCaseWithSkb(), realAction);
} else if (mInputModeSwitcher.isChineseText()) {
if (mImeState == ImeState.STATE_IDLE ||
mImeState == ImeState.STATE_APP_COMPLETION) {
mImeState = ImeState.STATE_IDLE;
return processStateIdle(keyChar, keyCode, event, realAction);
} else if (mImeState == ImeState.STATE_INPUT) {
return processStateInput(keyChar, keyCode, event, realAction);
} else if (mImeState == ImeState.STATE_PREDICT) {
return processStatePredict(keyChar, keyCode, event, realAction);
} else if (mImeState == ImeState.STATE_COMPOSING) {
return processStateEditComposing(keyChar, keyCode, event,
realAction);
}
} else {
if (0 != keyChar && realAction) {
commitResultText(String.valueOf((char) keyChar));
}
}
return false;
}
// keyCode can be from both hard key or soft key.
private boolean processFunctionKeys(int keyCode, boolean realAction) {
// Back key is used to dismiss all popup UI in a soft keyboard.
if (keyCode == KeyEvent.KEYCODE_BACK) {
if (isInputViewShown()) {
if (mSkbContainer.handleBack(realAction)) return true;
}
}
// Chinese related input is handle separately.
if (mInputModeSwitcher.isChineseText()) {
return false;
}
if (null != mCandidatesContainer && mCandidatesContainer.isShown()
&& !mDecInfo.isCandidatesListEmpty()) {
if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
if (!realAction) return true;
chooseCandidate(-1);
return true;
}
if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
if (!realAction) return true;
mCandidatesContainer.activeCurseBackward();
return true;
}
if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (!realAction) return true;
mCandidatesContainer.activeCurseForward();
return true;
}
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
if (!realAction) return true;
mCandidatesContainer.pageBackward(false, true);
return true;
}
if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
if (!realAction) return true;
mCandidatesContainer.pageForward(false, true);
return true;
}
if (keyCode == KeyEvent.KEYCODE_DEL &&
ImeState.STATE_PREDICT == mImeState) {
if (!realAction) return true;
resetToIdleState(false);
return true;
}
} else {
if (keyCode == KeyEvent.KEYCODE_DEL) {
if (!realAction) return true;
if (SIMULATE_KEY_DELETE) {
simulateKeyEventDownUp(keyCode);
} else {
getCurrentInputConnection().deleteSurroundingText(1, 0);
}
return true;
}
if (keyCode == KeyEvent.KEYCODE_ENTER) {
if (!realAction) return true;
sendKeyChar('\n');
return true;
}
if (keyCode == KeyEvent.KEYCODE_SPACE) {
if (!realAction) return true;
sendKeyChar(' ');
return true;
}
}
return false;
}
private boolean processStateIdle(int keyChar, int keyCode, KeyEvent event,
boolean realAction) {
// In this status, when user presses keys in [a..z], the status will
// change to input state.
if (keyChar >= 'a' && keyChar <= 'z' && !event.isAltPressed()) {
if (!realAction) return true;
mDecInfo.addSplChar((char) keyChar, true);
chooseAndUpdate(-1);
return true;
} else if (keyCode == KeyEvent.KEYCODE_DEL) {
if (!realAction) return true;
if (SIMULATE_KEY_DELETE) {
simulateKeyEventDownUp(keyCode);
} else {
getCurrentInputConnection().deleteSurroundingText(1, 0);
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_ENTER) {
if (!realAction) return true;
sendKeyChar('\n');
return true;
} else if (keyCode == KeyEvent.KEYCODE_ALT_LEFT
|| keyCode == KeyEvent.KEYCODE_ALT_RIGHT
|| keyCode == KeyEvent.KEYCODE_SHIFT_LEFT
|| keyCode == KeyEvent.KEYCODE_SHIFT_RIGHT) {
return true;
} else if (event.isAltPressed()) {
char fullwidth_char = KeyMapDream.getChineseLabel(keyCode);
if (0 != fullwidth_char) {
if (realAction) {
String result = String.valueOf(fullwidth_char);
commitResultText(result);
}
return true;
} else {
if (keyCode >= KeyEvent.KEYCODE_A
&& keyCode <= KeyEvent.KEYCODE_Z) {
return true;
}
}
} else if (keyChar != 0 && keyChar != '\t') {
if (realAction) {
if (keyChar == ',' || keyChar == '.') {
inputCommaPeriod("", keyChar, false, ImeState.STATE_IDLE);
} else {
if (0 != keyChar) {
String result = String.valueOf((char) keyChar);
commitResultText(result);
}
}
}
return true;
}
return false;
}
private boolean processStateInput(int keyChar, int keyCode, KeyEvent event,
boolean realAction) {
// If ALT key is pressed, input alternative key. But if the
// alternative key is quote key, it will be used for input a splitter
// in Pinyin string.
if (event.isAltPressed()) {
if ('\'' != event.getUnicodeChar(event.getMetaState())) {
if (realAction) {
char fullwidth_char = KeyMapDream.getChineseLabel(keyCode);
if (0 != fullwidth_char) {
commitResultText(mDecInfo
.getCurrentFullSent(mCandidatesContainer
.getActiveCandiatePos()) +
String.valueOf(fullwidth_char));
resetToIdleState(false);
}
}
return true;
} else {
keyChar = '\'';
}
}
if (keyChar >= 'a' && keyChar <= 'z' || keyChar == '\''
&& !mDecInfo.charBeforeCursorIsSeparator()
|| keyCode == KeyEvent.KEYCODE_DEL) {
if (!realAction) return true;
return processSurfaceChange(keyChar, keyCode);
} else if (keyChar == ',' || keyChar == '.') {
if (!realAction) return true;
inputCommaPeriod(mDecInfo.getCurrentFullSent(mCandidatesContainer
.getActiveCandiatePos()), keyChar, true,
ImeState.STATE_IDLE);
return true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP
|| keyCode == KeyEvent.KEYCODE_DPAD_DOWN
|| keyCode == KeyEvent.KEYCODE_DPAD_LEFT
|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (!realAction) return true;
if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
mCandidatesContainer.activeCurseBackward();
} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
mCandidatesContainer.activeCurseForward();
} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
// If it has been the first page, a up key will shift
// the state to edit composing string.
if (!mCandidatesContainer.pageBackward(false, true)) {
mCandidatesContainer.enableActiveHighlight(false);
changeToStateComposing(true);
updateComposingText(true);
}
} else if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
mCandidatesContainer.pageForward(false, true);
}
return true;
} else if (keyCode >= KeyEvent.KEYCODE_1
&& keyCode <= KeyEvent.KEYCODE_9) {
if (!realAction) return true;
int activePos = keyCode - KeyEvent.KEYCODE_1;
int currentPage = mCandidatesContainer.getCurrentPage();
if (activePos < mDecInfo.getCurrentPageSize(currentPage)) {
activePos = activePos
+ mDecInfo.getCurrentPageStart(currentPage);
if (activePos >= 0) {
chooseAndUpdate(activePos);
}
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_ENTER) {
if (!realAction) return true;
if (mInputModeSwitcher.isEnterNoramlState()) {
commitResultText(mDecInfo.getOrigianlSplStr().toString());
resetToIdleState(false);
} else {
commitResultText(mDecInfo
.getCurrentFullSent(mCandidatesContainer
.getActiveCandiatePos()));
sendKeyChar('\n');
resetToIdleState(false);
}
return true;
} else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
|| keyCode == KeyEvent.KEYCODE_SPACE) {
if (!realAction) return true;
chooseCandidate(-1);
return true;
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
if (!realAction) return true;
resetToIdleState(false);
requestHideSelf(0);
return true;
}
return false;
}
private boolean processStatePredict(int keyChar, int keyCode,
KeyEvent event, boolean realAction) {
if (!realAction) return true;
// If ALT key is pressed, input alternative key.
if (event.isAltPressed()) {
char fullwidth_char = KeyMapDream.getChineseLabel(keyCode);
if (0 != fullwidth_char) {
commitResultText(mDecInfo.getCandidate(mCandidatesContainer
.getActiveCandiatePos()) +
String.valueOf(fullwidth_char));
resetToIdleState(false);
}
return true;
}
// In this status, when user presses keys in [a..z], the status will
// change to input state.
if (keyChar >= 'a' && keyChar <= 'z') {
changeToStateInput(true);
mDecInfo.addSplChar((char) keyChar, true);
chooseAndUpdate(-1);
} else if (keyChar == ',' || keyChar == '.') {
inputCommaPeriod("", keyChar, true, ImeState.STATE_IDLE);
} else if (keyCode == KeyEvent.KEYCODE_DPAD_UP
|| keyCode == KeyEvent.KEYCODE_DPAD_DOWN
|| keyCode == KeyEvent.KEYCODE_DPAD_LEFT
|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT) {
mCandidatesContainer.activeCurseBackward();
}
if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
mCandidatesContainer.activeCurseForward();
}
if (keyCode == KeyEvent.KEYCODE_DPAD_UP) {
mCandidatesContainer.pageBackward(false, true);
}
if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
mCandidatesContainer.pageForward(false, true);
}
} else if (keyCode == KeyEvent.KEYCODE_DEL) {
resetToIdleState(false);
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
resetToIdleState(false);
requestHideSelf(0);
} else if (keyCode >= KeyEvent.KEYCODE_1
&& keyCode <= KeyEvent.KEYCODE_9) {
int activePos = keyCode - KeyEvent.KEYCODE_1;
int currentPage = mCandidatesContainer.getCurrentPage();
if (activePos < mDecInfo.getCurrentPageSize(currentPage)) {
activePos = activePos
+ mDecInfo.getCurrentPageStart(currentPage);
if (activePos >= 0) {
chooseAndUpdate(activePos);
}
}
} else if (keyCode == KeyEvent.KEYCODE_ENTER) {
sendKeyChar('\n');
resetToIdleState(false);
} else if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER
|| keyCode == KeyEvent.KEYCODE_SPACE) {
chooseCandidate(-1);
}
return true;
}
private boolean processStateEditComposing(int keyChar, int keyCode,
KeyEvent event, boolean realAction) {
if (!realAction) return true;
ComposingView.ComposingStatus cmpsvStatus =
mComposingView.getComposingStatus();
// If ALT key is pressed, input alternative key. But if the
// alternative key is quote key, it will be used for input a splitter
// in Pinyin string.
if (event.isAltPressed()) {
if ('\'' != event.getUnicodeChar(event.getMetaState())) {
char fullwidth_char = KeyMapDream.getChineseLabel(keyCode);
if (0 != fullwidth_char) {
String retStr;
if (ComposingView.ComposingStatus.SHOW_STRING_LOWERCASE ==
cmpsvStatus) {
retStr = mDecInfo.getOrigianlSplStr().toString();
} else {
retStr = mDecInfo.getComposingStr();
}
commitResultText(retStr + String.valueOf(fullwidth_char));
resetToIdleState(false);
}
return true;
} else {
keyChar = '\'';
}
}
if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
if (!mDecInfo.selectionFinished()) {
changeToStateInput(true);
}
} else if (keyCode == KeyEvent.KEYCODE_DPAD_LEFT
|| keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
mComposingView.moveCursor(keyCode);
} else if ((keyCode == KeyEvent.KEYCODE_ENTER && mInputModeSwitcher
.isEnterNoramlState())
|| keyCode == KeyEvent.KEYCODE_DPAD_CENTER
|| keyCode == KeyEvent.KEYCODE_SPACE) {
if (ComposingView.ComposingStatus.SHOW_STRING_LOWERCASE == cmpsvStatus) {
String str = mDecInfo.getOrigianlSplStr().toString();
if (!tryInputRawUnicode(str)) {
commitResultText(str);
}
} else if (ComposingView.ComposingStatus.EDIT_PINYIN == cmpsvStatus) {
String str = mDecInfo.getComposingStr();
if (!tryInputRawUnicode(str)) {
commitResultText(str);
}
} else {
commitResultText(mDecInfo.getComposingStr());
}
resetToIdleState(false);
} else if (keyCode == KeyEvent.KEYCODE_ENTER
&& !mInputModeSwitcher.isEnterNoramlState()) {
String retStr;
if (!mDecInfo.isCandidatesListEmpty()) {
retStr = mDecInfo.getCurrentFullSent(mCandidatesContainer
.getActiveCandiatePos());
} else {
retStr = mDecInfo.getComposingStr();
}
commitResultText(retStr);
sendKeyChar('\n');
resetToIdleState(false);
} else if (keyCode == KeyEvent.KEYCODE_BACK) {
resetToIdleState(false);
requestHideSelf(0);
return true;
} else {
return processSurfaceChange(keyChar, keyCode);
}
return true;
}
private boolean tryInputRawUnicode(String str) {
if (str.length() > 7) {
if (str.substring(0, 7).compareTo("unicode") == 0) {
try {
String digitStr = str.substring(7);
int startPos = 0;
int radix = 10;
if (digitStr.length() > 2 && digitStr.charAt(0) == '0'
&& digitStr.charAt(1) == 'x') {
startPos = 2;
radix = 16;
}
digitStr = digitStr.substring(startPos);
int unicode = Integer.parseInt(digitStr, radix);
if (unicode > 0) {
char low = (char) (unicode & 0x0000ffff);
char high = (char) ((unicode & 0xffff0000) >> 16);
commitResultText(String.valueOf(low));
if (0 != high) {
commitResultText(String.valueOf(high));
}
}
return true;
} catch (NumberFormatException e) {
return false;
}
} else if (str.substring(str.length() - 7, str.length()).compareTo(
"unicode") == 0) {
String resultStr = "";
for (int pos = 0; pos < str.length() - 7; pos++) {
if (pos > 0) {
resultStr += " ";
}
resultStr += "0x" + Integer.toHexString(str.charAt(pos));
}
commitResultText(String.valueOf(resultStr));
return true;
}
}
return false;
}
private boolean processSurfaceChange(int keyChar, int keyCode) {
if (mDecInfo.isSplStrFull() && KeyEvent.KEYCODE_DEL != keyCode) {
return true;
}
if ((keyChar >= 'a' && keyChar <= 'z')
|| (keyChar == '\'' && !mDecInfo.charBeforeCursorIsSeparator())
|| (((keyChar >= '0' && keyChar <= '9') || keyChar == ' ') && ImeState.STATE_COMPOSING == mImeState)) {
mDecInfo.addSplChar((char) keyChar, false);
chooseAndUpdate(-1);
} else if (keyCode == KeyEvent.KEYCODE_DEL) {
mDecInfo.prepareDeleteBeforeCursor();
chooseAndUpdate(-1);
}
return true;
}
private void changeToStateComposing(boolean updateUi) {
mImeState = ImeState.STATE_COMPOSING;
if (!updateUi) return;
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.toggleCandidateMode(true);
}
}
private void changeToStateInput(boolean updateUi) {
mImeState = ImeState.STATE_INPUT;
if (!updateUi) return;
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.toggleCandidateMode(true);
}
showCandidateWindow(true);
}
private void simulateKeyEventDownUp(int keyCode) {
InputConnection ic = getCurrentInputConnection();
if (null == ic) return;
ic.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, keyCode));
ic.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, keyCode));
}
private void commitResultText(String resultText) {
InputConnection ic = getCurrentInputConnection();
if (null != ic) ic.commitText(resultText, 1);
if (null != mComposingView) {
mComposingView.setVisibility(View.INVISIBLE);
mComposingView.invalidate();
}
}
private void updateComposingText(boolean visible) {
if (!visible) {
mComposingView.setVisibility(View.INVISIBLE);
} else {
mComposingView.setDecodingInfo(mDecInfo, mImeState);
mComposingView.setVisibility(View.VISIBLE);
}
mComposingView.invalidate();
}
private void inputCommaPeriod(String preEdit, int keyChar,
boolean dismissCandWindow, ImeState nextState) {
if (keyChar == ',')
preEdit += '\uff0c';
else if (keyChar == '.')
preEdit += '\u3002';
else
return;
commitResultText(preEdit);
if (dismissCandWindow) resetCandidateWindow();
mImeState = nextState;
}
private void resetToIdleState(boolean resetInlineText) {
if (ImeState.STATE_IDLE == mImeState) return;
mImeState = ImeState.STATE_IDLE;
mDecInfo.reset();
if (null != mComposingView) mComposingView.reset();
if (resetInlineText) commitResultText("");
resetCandidateWindow();
}
private void chooseAndUpdate(int candId) {
if (!mInputModeSwitcher.isChineseText()) {
String choice = mDecInfo.getCandidate(candId);
if (null != choice) {
commitResultText(choice);
}
resetToIdleState(false);
return;
}
if (ImeState.STATE_PREDICT != mImeState) {
// Get result candidate list, if choice_id < 0, do a new decoding.
// If choice_id >=0, select the candidate, and get the new candidate
// list.
mDecInfo.chooseDecodingCandidate(candId);
} else {
// Choose a prediction item.
mDecInfo.choosePredictChoice(candId);
}
if (mDecInfo.getComposingStr().length() > 0) {
String resultStr;
resultStr = mDecInfo.getComposingStrActivePart();
// choiceId >= 0 means user finishes a choice selection.
if (candId >= 0 && mDecInfo.canDoPrediction()) {
commitResultText(resultStr);
mImeState = ImeState.STATE_PREDICT;
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.toggleCandidateMode(false);
}
// Try to get the prediction list.
if (Settings.getPrediction()) {
InputConnection ic = getCurrentInputConnection();
if (null != ic) {
CharSequence cs = ic.getTextBeforeCursor(3, 0);
if (null != cs) {
mDecInfo.preparePredicts(cs);
}
}
} else {
mDecInfo.resetCandidates();
}
if (mDecInfo.mCandidatesList.size() > 0) {
showCandidateWindow(false);
} else {
resetToIdleState(false);
}
} else {
if (ImeState.STATE_IDLE == mImeState) {
if (mDecInfo.getSplStrDecodedLen() == 0) {
changeToStateComposing(true);
} else {
changeToStateInput(true);
}
} else {
if (mDecInfo.selectionFinished()) {
changeToStateComposing(true);
}
}
showCandidateWindow(true);
}
} else {
resetToIdleState(false);
}
}
// If activeCandNo is less than 0, get the current active candidate number
// from candidate view, otherwise use activeCandNo.
private void chooseCandidate(int activeCandNo) {
if (activeCandNo < 0) {
activeCandNo = mCandidatesContainer.getActiveCandiatePos();
}
if (activeCandNo >= 0) {
chooseAndUpdate(activeCandNo);
}
}
private boolean startPinyinDecoderService() {
if (null == mDecInfo.mIPinyinDecoderService) {
Intent serviceIntent = new Intent();
serviceIntent.setClass(this, PinyinDecoderService.class);
if (null == mPinyinDecoderServiceConnection) {
mPinyinDecoderServiceConnection = new PinyinDecoderServiceConnection();
}
// Bind service
if (bindService(serviceIntent, mPinyinDecoderServiceConnection,
Context.BIND_AUTO_CREATE)) {
return true;
} else {
return false;
}
}
return true;
}
@Override
public View onCreateCandidatesView() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onCreateCandidatesView.");
}
LayoutInflater inflater = getLayoutInflater();
// Inflate the floating container view
mFloatingContainer = (LinearLayout) inflater.inflate(
R.layout.floating_container, null);
// The first child is the composing view.
mComposingView = (ComposingView) mFloatingContainer.getChildAt(0);
mCandidatesContainer = (CandidatesContainer) inflater.inflate(
R.layout.candidates_container, null);
// Create balloon hint for candidates view.
mCandidatesBalloon = new BalloonHint(this, mCandidatesContainer,
MeasureSpec.UNSPECIFIED);
mCandidatesBalloon.setBalloonBackground(getResources().getDrawable(
R.drawable.candidate_balloon_bg));
mCandidatesContainer.initialize(mChoiceNotifier, mCandidatesBalloon,
mGestureDetectorCandidates);
// The floating window
if (null != mFloatingWindow && mFloatingWindow.isShowing()) {
mFloatingWindowTimer.cancelShowing();
mFloatingWindow.dismiss();
}
mFloatingWindow = new PopupWindow(this);
mFloatingWindow.setClippingEnabled(false);
mFloatingWindow.setBackgroundDrawable(null);
mFloatingWindow.setInputMethodMode(PopupWindow.INPUT_METHOD_NOT_NEEDED);
mFloatingWindow.setContentView(mFloatingContainer);
setCandidatesViewShown(true);
return mCandidatesContainer;
}
public void responseSoftKeyEvent(SoftKey sKey) {
if (null == sKey) return;
InputConnection ic = getCurrentInputConnection();
if (ic == null) return;
int keyCode = sKey.getKeyCode();
// Process some general keys, including KEYCODE_DEL, KEYCODE_SPACE,
// KEYCODE_ENTER and KEYCODE_DPAD_CENTER.
if (sKey.isKeyCodeKey()) {
if (processFunctionKeys(keyCode, true)) return;
}
if (sKey.isUserDefKey()) {
updateIcon(mInputModeSwitcher.switchModeForUserKey(keyCode));
resetToIdleState(false);
mSkbContainer.updateInputMode();
} else {
if (sKey.isKeyCodeKey()) {
KeyEvent eDown = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
keyCode, 0, 0, 0, 0, KeyEvent.FLAG_SOFT_KEYBOARD);
KeyEvent eUp = new KeyEvent(0, 0, KeyEvent.ACTION_UP, keyCode,
0, 0, 0, 0, KeyEvent.FLAG_SOFT_KEYBOARD);
onKeyDown(keyCode, eDown);
onKeyUp(keyCode, eUp);
} else if (sKey.isUniStrKey()) {
boolean kUsed = false;
String keyLabel = sKey.getKeyLabel();
if (mInputModeSwitcher.isChineseTextWithSkb()
&& (ImeState.STATE_INPUT == mImeState || ImeState.STATE_COMPOSING == mImeState)) {
if (mDecInfo.length() > 0 && keyLabel.length() == 1
&& keyLabel.charAt(0) == '\'') {
processSurfaceChange('\'', 0);
kUsed = true;
}
}
if (!kUsed) {
if (ImeState.STATE_INPUT == mImeState) {
commitResultText(mDecInfo
.getCurrentFullSent(mCandidatesContainer
.getActiveCandiatePos()));
} else if (ImeState.STATE_COMPOSING == mImeState) {
commitResultText(mDecInfo.getComposingStr());
}
commitResultText(keyLabel);
resetToIdleState(false);
}
}
// If the current soft keyboard is not sticky, IME needs to go
// back to the previous soft keyboard automatically.
if (!mSkbContainer.isCurrentSkbSticky()) {
updateIcon(mInputModeSwitcher.requestBackToPreviousSkb());
resetToIdleState(false);
mSkbContainer.updateInputMode();
}
}
}
private void showCandidateWindow(boolean showComposingView) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "Candidates window is shown. Parent = "
+ mCandidatesContainer);
}
setCandidatesViewShown(true);
if (null != mSkbContainer) mSkbContainer.requestLayout();
if (null == mCandidatesContainer) {
resetToIdleState(false);
return;
}
updateComposingText(showComposingView);
mCandidatesContainer.showCandidates(mDecInfo,
ImeState.STATE_COMPOSING != mImeState);
mFloatingWindowTimer.postShowFloatingWindow();
}
private void dismissCandidateWindow() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "Candidates window is to be dismissed");
}
if (null == mCandidatesContainer) return;
try {
mFloatingWindowTimer.cancelShowing();
mFloatingWindow.dismiss();
} catch (Exception e) {
Log.e(TAG, "Fail to show the PopupWindow.");
}
setCandidatesViewShown(false);
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.toggleCandidateMode(false);
}
}
private void resetCandidateWindow() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "Candidates window is to be reset");
}
if (null == mCandidatesContainer) return;
try {
mFloatingWindowTimer.cancelShowing();
mFloatingWindow.dismiss();
} catch (Exception e) {
Log.e(TAG, "Fail to show the PopupWindow.");
}
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.toggleCandidateMode(false);
}
mDecInfo.resetCandidates();
if (null != mCandidatesContainer && mCandidatesContainer.isShown()) {
showCandidateWindow(false);
}
}
private void updateIcon(int iconId) {
if (iconId > 0) {
showStatusIcon(iconId);
} else {
hideStatusIcon();
}
}
@Override
public View onCreateInputView() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onCreateInputView.");
}
LayoutInflater inflater = getLayoutInflater();
mSkbContainer = (SkbContainer) inflater.inflate(R.layout.skb_container,
null);
mSkbContainer.setService(this);
mSkbContainer.setInputModeSwitcher(mInputModeSwitcher);
mSkbContainer.setGestureDetector(mGestureDetectorSkb);
return mSkbContainer;
}
@Override
public void onStartInput(EditorInfo editorInfo, boolean restarting) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onStartInput " + " ccontentType: "
+ String.valueOf(editorInfo.inputType) + " Restarting:"
+ String.valueOf(restarting));
}
updateIcon(mInputModeSwitcher.requestInputWithHkb(editorInfo));
resetToIdleState(false);
}
@Override
public void onStartInputView(EditorInfo editorInfo, boolean restarting) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onStartInputView " + " contentType: "
+ String.valueOf(editorInfo.inputType) + " Restarting:"
+ String.valueOf(restarting));
}
updateIcon(mInputModeSwitcher.requestInputWithSkb(editorInfo));
resetToIdleState(false);
mSkbContainer.updateInputMode();
setCandidatesViewShown(false);
}
@Override
public void onFinishInputView(boolean finishingInput) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onFinishInputView.");
}
resetToIdleState(false);
super.onFinishInputView(finishingInput);
}
@Override
public void onFinishInput() {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onFinishInput.");
}
resetToIdleState(false);
super.onFinishInput();
}
@Override
public void onFinishCandidatesView(boolean finishingInput) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "onFinishCandidateView.");
}
resetToIdleState(false);
super.onFinishCandidatesView(finishingInput);
}
@Override public void onDisplayCompletions(CompletionInfo[] completions) {
if (!isFullscreenMode()) return;
if (null == completions || completions.length <= 0) return;
if (null == mSkbContainer || !mSkbContainer.isShown()) return;
if (!mInputModeSwitcher.isChineseText() ||
ImeState.STATE_IDLE == mImeState ||
ImeState.STATE_PREDICT == mImeState) {
mImeState = ImeState.STATE_APP_COMPLETION;
mDecInfo.prepareAppCompletions(completions);
showCandidateWindow(false);
}
}
private void onChoiceTouched(int activeCandNo) {
if (mImeState == ImeState.STATE_COMPOSING) {
changeToStateInput(true);
} else if (mImeState == ImeState.STATE_INPUT
|| mImeState == ImeState.STATE_PREDICT) {
chooseCandidate(activeCandNo);
} else if (mImeState == ImeState.STATE_APP_COMPLETION) {
if (null != mDecInfo.mAppCompletions && activeCandNo >= 0 &&
activeCandNo < mDecInfo.mAppCompletions.length) {
CompletionInfo ci = mDecInfo.mAppCompletions[activeCandNo];
if (null != ci) {
InputConnection ic = getCurrentInputConnection();
ic.commitCompletion(ci);
}
}
resetToIdleState(false);
}
}
@Override
public void requestHideSelf(int flags) {
if (mEnvironment.needDebug()) {
Log.d(TAG, "DimissSoftInput.");
}
dismissCandidateWindow();
if (null != mSkbContainer && mSkbContainer.isShown()) {
mSkbContainer.dismissPopups();
}
super.requestHideSelf(flags);
}
public void showOptionsMenu() {
AlertDialog.Builder builder = new AlertDialog.Builder(this);
builder.setCancelable(true);
builder.setIcon(R.drawable.app_icon);
builder.setNegativeButton(android.R.string.cancel, null);
CharSequence itemSettings = getString(R.string.ime_settings_activity_name);
CharSequence itemInputMethod = getString(com.android.internal.R.string.inputMethod);
builder.setItems(new CharSequence[] {itemSettings, itemInputMethod},
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface di, int position) {
di.dismiss();
switch (position) {
case 0:
launchSettings();
break;
case 1:
InputMethodManager.getInstance(PinyinIME.this)
.showInputMethodPicker();
break;
}
}
});
builder.setTitle(getString(R.string.ime_name));
mOptionsDialog = builder.create();
Window window = mOptionsDialog.getWindow();
WindowManager.LayoutParams lp = window.getAttributes();
lp.token = mSkbContainer.getWindowToken();
lp.type = WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG;
window.setAttributes(lp);
window.addFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
mOptionsDialog.show();
}
private void launchSettings() {
Intent intent = new Intent();
intent.setClass(PinyinIME.this, SettingsActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
}
private class PopupTimer extends Handler implements Runnable {
private int mParentLocation[] = new int[2];
void postShowFloatingWindow() {
mFloatingContainer.measure(LayoutParams.WRAP_CONTENT,
LayoutParams.WRAP_CONTENT);
mFloatingWindow.setWidth(mFloatingContainer.getMeasuredWidth());
mFloatingWindow.setHeight(mFloatingContainer.getMeasuredHeight());
post(this);
}
void cancelShowing() {
if (mFloatingWindow.isShowing()) {
mFloatingWindow.dismiss();
}
removeCallbacks(this);
}
public void run() {
mCandidatesContainer.getLocationInWindow(mParentLocation);
if (!mFloatingWindow.isShowing()) {
mFloatingWindow.showAtLocation(mCandidatesContainer,
Gravity.LEFT | Gravity.TOP, mParentLocation[0],
mParentLocation[1] -mFloatingWindow.getHeight());
} else {
mFloatingWindow
.update(mParentLocation[0],
mParentLocation[1] - mFloatingWindow.getHeight(),
mFloatingWindow.getWidth(),
mFloatingWindow.getHeight());
}
}
}
/**
* Used to notify IME that the user selects a candidate or performs an
* gesture.
*/
public class ChoiceNotifier extends Handler implements
CandidateViewListener {
PinyinIME mIme;
ChoiceNotifier(PinyinIME ime) {
mIme = ime;
}
public void onClickChoice(int choiceId) {
if (choiceId >= 0) {
mIme.onChoiceTouched(choiceId);
}
}
public void onToLeftGesture() {
if (ImeState.STATE_COMPOSING == mImeState) {
changeToStateInput(true);
}
mCandidatesContainer.pageForward(true, false);
}
public void onToRightGesture() {
if (ImeState.STATE_COMPOSING == mImeState) {
changeToStateInput(true);
}
mCandidatesContainer.pageBackward(true, false);
}
public void onToTopGesture() {
}
public void onToBottomGesture() {
}
}
public class OnGestureListener extends
GestureDetector.SimpleOnGestureListener {
/**
* When user presses and drags, the minimum x-distance to make a
* response to the drag event.
*/
private static final int MIN_X_FOR_DRAG = 60;
/**
* When user presses and drags, the minimum y-distance to make a
* response to the drag event.
*/
private static final int MIN_Y_FOR_DRAG = 40;
/**
* Velocity threshold for a screen-move gesture. If the minimum
* x-velocity is less than it, no gesture.
*/
static private final float VELOCITY_THRESHOLD_X1 = 0.3f;
/**
* Velocity threshold for a screen-move gesture. If the maximum
* x-velocity is less than it, no gesture.
*/
static private final float VELOCITY_THRESHOLD_X2 = 0.7f;
/**
* Velocity threshold for a screen-move gesture. If the minimum
* y-velocity is less than it, no gesture.
*/
static private final float VELOCITY_THRESHOLD_Y1 = 0.2f;
/**
* Velocity threshold for a screen-move gesture. If the maximum
* y-velocity is less than it, no gesture.
*/
static private final float VELOCITY_THRESHOLD_Y2 = 0.45f;
/** If it false, we will not response detected gestures. */
private boolean mReponseGestures;
/** The minimum X velocity observed in the gesture. */
private float mMinVelocityX = Float.MAX_VALUE;
/** The minimum Y velocity observed in the gesture. */
private float mMinVelocityY = Float.MAX_VALUE;
/** The first down time for the series of touch events for an action. */
private long mTimeDown;
/** The last time when onScroll() is called. */
private long mTimeLastOnScroll;
/** This flag used to indicate that this gesture is not a gesture. */
private boolean mNotGesture;
/** This flag used to indicate that this gesture has been recognized. */
private boolean mGestureRecognized;
public OnGestureListener(boolean reponseGestures) {
mReponseGestures = reponseGestures;
}
@Override
public boolean onDown(MotionEvent e) {
mMinVelocityX = Integer.MAX_VALUE;
mMinVelocityY = Integer.MAX_VALUE;
mTimeDown = e.getEventTime();
mTimeLastOnScroll = mTimeDown;
mNotGesture = false;
mGestureRecognized = false;
return false;
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2,
float distanceX, float distanceY) {
if (mNotGesture) return false;
if (mGestureRecognized) return true;
if (Math.abs(e1.getX() - e2.getX()) < MIN_X_FOR_DRAG
&& Math.abs(e1.getY() - e2.getY()) < MIN_Y_FOR_DRAG)
return false;
long timeNow = e2.getEventTime();
long spanTotal = timeNow - mTimeDown;
long spanThis = timeNow - mTimeLastOnScroll;
if (0 == spanTotal) spanTotal = 1;
if (0 == spanThis) spanThis = 1;
float vXTotal = (e2.getX() - e1.getX()) / spanTotal;
float vYTotal = (e2.getY() - e1.getY()) / spanTotal;
// The distances are from the current point to the previous one.
float vXThis = -distanceX / spanThis;
float vYThis = -distanceY / spanThis;
float kX = vXTotal * vXThis;
float kY = vYTotal * vYThis;
float k1 = kX + kY;
float k2 = Math.abs(kX) + Math.abs(kY);
if (k1 / k2 < 0.8) {
mNotGesture = true;
return false;
}
float absVXTotal = Math.abs(vXTotal);
float absVYTotal = Math.abs(vYTotal);
if (absVXTotal < mMinVelocityX) {
mMinVelocityX = absVXTotal;
}
if (absVYTotal < mMinVelocityY) {
mMinVelocityY = absVYTotal;
}
if (mMinVelocityX < VELOCITY_THRESHOLD_X1
&& mMinVelocityY < VELOCITY_THRESHOLD_Y1) {
mNotGesture = true;
return false;
}
if (vXTotal > VELOCITY_THRESHOLD_X2
&& absVYTotal < VELOCITY_THRESHOLD_Y2) {
if (mReponseGestures) onDirectionGesture(Gravity.RIGHT);
mGestureRecognized = true;
} else if (vXTotal < -VELOCITY_THRESHOLD_X2
&& absVYTotal < VELOCITY_THRESHOLD_Y2) {
if (mReponseGestures) onDirectionGesture(Gravity.LEFT);
mGestureRecognized = true;
} else if (vYTotal > VELOCITY_THRESHOLD_Y2
&& absVXTotal < VELOCITY_THRESHOLD_X2) {
if (mReponseGestures) onDirectionGesture(Gravity.BOTTOM);
mGestureRecognized = true;
} else if (vYTotal < -VELOCITY_THRESHOLD_Y2
&& absVXTotal < VELOCITY_THRESHOLD_X2) {
if (mReponseGestures) onDirectionGesture(Gravity.TOP);
mGestureRecognized = true;
}
mTimeLastOnScroll = timeNow;
return mGestureRecognized;
}
@Override
public boolean onFling(MotionEvent me1, MotionEvent me2,
float velocityX, float velocityY) {
return mGestureRecognized;
}
public void onDirectionGesture(int gravity) {
if (Gravity.NO_GRAVITY == gravity) {
return;
}
if (Gravity.LEFT == gravity || Gravity.RIGHT == gravity) {
if (mCandidatesContainer.isShown()) {
if (Gravity.LEFT == gravity) {
mCandidatesContainer.pageForward(true, true);
} else {
mCandidatesContainer.pageBackward(true, true);
}
return;
}
}
}
}
/**
* Connection used for binding to the Pinyin decoding service.
*/
public class PinyinDecoderServiceConnection implements ServiceConnection {
public void onServiceConnected(ComponentName name, IBinder service) {
mDecInfo.mIPinyinDecoderService = IPinyinDecoderService.Stub
.asInterface(service);
}
public void onServiceDisconnected(ComponentName name) {
}
}
public enum ImeState {
STATE_BYPASS, STATE_IDLE, STATE_INPUT, STATE_COMPOSING, STATE_PREDICT,
STATE_APP_COMPLETION
}
public class DecodingInfo {
/**
* Maximum length of the Pinyin string
*/
private static final int PY_STRING_MAX = 28;
/**
* Maximum number of candidates to display in one page.
*/
private static final int MAX_PAGE_SIZE_DISPLAY = 10;
/**
* Spelling (Pinyin) string.
*/
private StringBuffer mSurface;
/**
* Byte buffer used as the Pinyin string parameter for native function
* call.
*/
private byte mPyBuf[];
/**
* The length of surface string successfully decoded by engine.
*/
private int mSurfaceDecodedLen;
/**
* Composing string.
*/
private String mComposingStr;
/**
* Length of the active composing string.
*/
private int mActiveCmpsLen;
/**
* Composing string for display, it is copied from mComposingStr, and
* add spaces between spellings.
**/
private String mComposingStrDisplay;
/**
* Length of the active composing string for display.
*/
private int mActiveCmpsDisplayLen;
/**
* The first full sentence choice.
*/
private String mFullSent;
/**
* Number of characters which have been fixed.
*/
private int mFixedLen;
/**
* If this flag is true, selection is finished.
*/
private boolean mFinishSelection;
/**
* The starting position for each spelling. The first one is the number
* of the real starting position elements.
*/
private int mSplStart[];
/**
* Editing cursor in mSurface.
*/
private int mCursorPos;
/**
* Remote Pinyin-to-Hanzi decoding engine service.
*/
private IPinyinDecoderService mIPinyinDecoderService;
/**
* The complication information suggested by application.
*/
private CompletionInfo[] mAppCompletions;
/**
* The total number of choices for display. The list may only contains
* the first part. If user tries to navigate to next page which is not
* in the result list, we need to get these items.
**/
public int mTotalChoicesNum;
/**
* Candidate list. The first one is the full-sentence candidate.
*/
public List<String> mCandidatesList = new Vector<String>();
/**
* Element i stores the starting position of page i.
*/
public Vector<Integer> mPageStart = new Vector<Integer>();
/**
* Element i stores the number of characters to page i.
*/
public Vector<Integer> mCnToPage = new Vector<Integer>();
/**
* The position to delete in Pinyin string. If it is less than 0, IME
* will do an incremental search, otherwise IME will do a deletion
* operation. if {@link #mIsPosInSpl} is true, IME will delete the whole
* string for mPosDelSpl-th spelling, otherwise it will only delete
* mPosDelSpl-th character in the Pinyin string.
*/
public int mPosDelSpl = -1;
/**
* If {@link #mPosDelSpl} is big than or equal to 0, this member is used
* to indicate that whether the postion is counted in spelling id or
* character.
*/
public boolean mIsPosInSpl;
public DecodingInfo() {
mSurface = new StringBuffer();
mSurfaceDecodedLen = 0;
}
public void reset() {
mSurface.delete(0, mSurface.length());
mSurfaceDecodedLen = 0;
mCursorPos = 0;
mFullSent = "";
mFixedLen = 0;
mFinishSelection = false;
mComposingStr = "";
mComposingStrDisplay = "";
mActiveCmpsLen = 0;
mActiveCmpsDisplayLen = 0;
resetCandidates();
}
public boolean isCandidatesListEmpty() {
return mCandidatesList.size() == 0;
}
public boolean isSplStrFull() {
if (mSurface.length() >= PY_STRING_MAX - 1) return true;
return false;
}
public void addSplChar(char ch, boolean reset) {
if (reset) {
mSurface.delete(0, mSurface.length());
mSurfaceDecodedLen = 0;
mCursorPos = 0;
try {
mIPinyinDecoderService.imResetSearch();
} catch (RemoteException e) {
}
}
mSurface.insert(mCursorPos, ch);
mCursorPos++;
}
// Prepare to delete before cursor. We may delete a spelling char if
// the cursor is in the range of unfixed part, delete a whole spelling
// if the cursor in inside the range of the fixed part.
// This function only marks the position used to delete.
public void prepareDeleteBeforeCursor() {
if (mCursorPos > 0) {
int pos;
for (pos = 0; pos < mFixedLen; pos++) {
if (mSplStart[pos + 2] >= mCursorPos
&& mSplStart[pos + 1] < mCursorPos) {
mPosDelSpl = pos;
mCursorPos = mSplStart[pos + 1];
mIsPosInSpl = true;
break;
}
}
if (mPosDelSpl < 0) {
mPosDelSpl = mCursorPos - 1;
mCursorPos--;
mIsPosInSpl = false;
}
}
}
public int length() {
return mSurface.length();
}
public char charAt(int index) {
return mSurface.charAt(index);
}
public StringBuffer getOrigianlSplStr() {
return mSurface;
}
public int getSplStrDecodedLen() {
return mSurfaceDecodedLen;
}
public int[] getSplStart() {
return mSplStart;
}
public String getComposingStr() {
return mComposingStr;
}
public String getComposingStrActivePart() {
assert (mActiveCmpsLen <= mComposingStr.length());
return mComposingStr.substring(0, mActiveCmpsLen);
}
public int getActiveCmpsLen() {
return mActiveCmpsLen;
}
public String getComposingStrForDisplay() {
return mComposingStrDisplay;
}
public int getActiveCmpsDisplayLen() {
return mActiveCmpsDisplayLen;
}
public String getFullSent() {
return mFullSent;
}
public String getCurrentFullSent(int activeCandPos) {
try {
String retStr = mFullSent.substring(0, mFixedLen);
retStr += mCandidatesList.get(activeCandPos);
return retStr;
} catch (Exception e) {
return "";
}
}
public void resetCandidates() {
mCandidatesList.clear();
mTotalChoicesNum = 0;
mPageStart.clear();
mPageStart.add(0);
mCnToPage.clear();
mCnToPage.add(0);
}
public boolean candidatesFromApp() {
return ImeState.STATE_APP_COMPLETION == mImeState;
}
public boolean canDoPrediction() {
return mComposingStr.length() == mFixedLen;
}
public boolean selectionFinished() {
return mFinishSelection;
}
// After the user chooses a candidate, input method will do a
// re-decoding and give the new candidate list.
// If candidate id is less than 0, means user is inputting Pinyin,
// not selecting any choice.
private void chooseDecodingCandidate(int candId) {
if (mImeState != ImeState.STATE_PREDICT) {
resetCandidates();
int totalChoicesNum = 0;
try {
if (candId < 0) {
if (length() == 0) {
totalChoicesNum = 0;
} else {
if (mPyBuf == null)
mPyBuf = new byte[PY_STRING_MAX];
for (int i = 0; i < length(); i++)
mPyBuf[i] = (byte) charAt(i);
mPyBuf[length()] = 0;
if (mPosDelSpl < 0) {
totalChoicesNum = mIPinyinDecoderService
.imSearch(mPyBuf, length());
} else {
boolean clear_fixed_this_step = true;
if (ImeState.STATE_COMPOSING == mImeState) {
clear_fixed_this_step = false;
}
totalChoicesNum = mIPinyinDecoderService
.imDelSearch(mPosDelSpl, mIsPosInSpl,
clear_fixed_this_step);
mPosDelSpl = -1;
}
}
} else {
totalChoicesNum = mIPinyinDecoderService
.imChoose(candId);
}
} catch (RemoteException e) {
}
updateDecInfoForSearch(totalChoicesNum);
}
}
private void updateDecInfoForSearch(int totalChoicesNum) {
mTotalChoicesNum = totalChoicesNum;
if (mTotalChoicesNum < 0) {
mTotalChoicesNum = 0;
return;
}
try {
String pyStr;
mSplStart = mIPinyinDecoderService.imGetSplStart();
pyStr = mIPinyinDecoderService.imGetPyStr(false);
mSurfaceDecodedLen = mIPinyinDecoderService.imGetPyStrLen(true);
assert (mSurfaceDecodedLen <= pyStr.length());
mFullSent = mIPinyinDecoderService.imGetChoice(0);
mFixedLen = mIPinyinDecoderService.imGetFixedLen();
// Update the surface string to the one kept by engine.
mSurface.replace(0, mSurface.length(), pyStr);
if (mCursorPos > mSurface.length())
mCursorPos = mSurface.length();
mComposingStr = mFullSent.substring(0, mFixedLen)
+ mSurface.substring(mSplStart[mFixedLen + 1]);
mActiveCmpsLen = mComposingStr.length();
if (mSurfaceDecodedLen > 0) {
mActiveCmpsLen = mActiveCmpsLen
- (mSurface.length() - mSurfaceDecodedLen);
}
// Prepare the display string.
if (0 == mSurfaceDecodedLen) {
mComposingStrDisplay = mComposingStr;
mActiveCmpsDisplayLen = mComposingStr.length();
} else {
mComposingStrDisplay = mFullSent.substring(0, mFixedLen);
for (int pos = mFixedLen + 1; pos < mSplStart.length - 1; pos++) {
mComposingStrDisplay += mSurface.substring(
mSplStart[pos], mSplStart[pos + 1]);
if (mSplStart[pos + 1] < mSurfaceDecodedLen) {
mComposingStrDisplay += " ";
}
}
mActiveCmpsDisplayLen = mComposingStrDisplay.length();
if (mSurfaceDecodedLen < mSurface.length()) {
mComposingStrDisplay += mSurface
.substring(mSurfaceDecodedLen);
}
}
if (mSplStart.length == mFixedLen + 2) {
mFinishSelection = true;
} else {
mFinishSelection = false;
}
} catch (RemoteException e) {
Log.w(TAG, "PinyinDecoderService died", e);
} catch (Exception e) {
mTotalChoicesNum = 0;
mComposingStr = "";
}
// Prepare page 0.
if (!mFinishSelection) {
preparePage(0);
}
}
private void choosePredictChoice(int choiceId) {
if (ImeState.STATE_PREDICT != mImeState || choiceId < 0
|| choiceId >= mTotalChoicesNum) {
return;
}
String tmp = mCandidatesList.get(choiceId);
resetCandidates();
mCandidatesList.add(tmp);
mTotalChoicesNum = 1;
mSurface.replace(0, mSurface.length(), "");
mCursorPos = 0;
mFullSent = tmp;
mFixedLen = tmp.length();
mComposingStr = mFullSent;
mActiveCmpsLen = mFixedLen;
mFinishSelection = true;
}
public String getCandidate(int candId) {
// Only loaded items can be gotten, so we use mCandidatesList.size()
// instead mTotalChoiceNum.
if (candId < 0 || candId > mCandidatesList.size()) {
return null;
}
return mCandidatesList.get(candId);
}
private void getCandiagtesForCache() {
int fetchStart = mCandidatesList.size();
int fetchSize = mTotalChoicesNum - fetchStart;
if (fetchSize > MAX_PAGE_SIZE_DISPLAY) {
fetchSize = MAX_PAGE_SIZE_DISPLAY;
}
try {
List<String> newList = null;
if (ImeState.STATE_INPUT == mImeState ||
ImeState.STATE_IDLE == mImeState ||
ImeState.STATE_COMPOSING == mImeState){
newList = mIPinyinDecoderService.imGetChoiceList(
fetchStart, fetchSize, mFixedLen);
} else if (ImeState.STATE_PREDICT == mImeState) {
newList = mIPinyinDecoderService.imGetPredictList(
fetchStart, fetchSize);
} else if (ImeState.STATE_APP_COMPLETION == mImeState) {
newList = new ArrayList<String>();
if (null != mAppCompletions) {
for (int pos = fetchStart; pos < fetchSize; pos++) {
CompletionInfo ci = mAppCompletions[pos];
if (null != ci) {
CharSequence s = ci.getText();
if (null != s) newList.add(s.toString());
}
}
}
}
mCandidatesList.addAll(newList);
} catch (RemoteException e) {
Log.w(TAG, "PinyinDecoderService died", e);
}
}
public boolean pageReady(int pageNo) {
// If the page number is less than 0, return false
if (pageNo < 0) return false;
// Page pageNo's ending information is not ready.
if (mPageStart.size() <= pageNo + 1) {
return false;
}
return true;
}
public boolean preparePage(int pageNo) {
// If the page number is less than 0, return false
if (pageNo < 0) return false;
// Make sure the starting information for page pageNo is ready.
if (mPageStart.size() <= pageNo) {
return false;
}
// Page pageNo's ending information is also ready.
if (mPageStart.size() > pageNo + 1) {
return true;
}
// If cached items is enough for page pageNo.
if (mCandidatesList.size() - mPageStart.elementAt(pageNo) >= MAX_PAGE_SIZE_DISPLAY) {
return true;
}
// Try to get more items from engine
getCandiagtesForCache();
// Try to find if there are available new items to display.
// If no new item, return false;
if (mPageStart.elementAt(pageNo) >= mCandidatesList.size()) {
return false;
}
// If there are new items, return true;
return true;
}
public void preparePredicts(CharSequence history) {
if (null == history) return;
resetCandidates();
if (Settings.getPrediction()) {
String preEdit = history.toString();
int predictNum = 0;
if (null != preEdit) {
try {
mTotalChoicesNum = mIPinyinDecoderService
.imGetPredictsNum(preEdit);
} catch (RemoteException e) {
return;
}
}
}
preparePage(0);
mFinishSelection = false;
}
private void prepareAppCompletions(CompletionInfo completions[]) {
resetCandidates();
mAppCompletions = completions;
mTotalChoicesNum = completions.length;
preparePage(0);
mFinishSelection = false;
return;
}
public int getCurrentPageSize(int currentPage) {
if (mPageStart.size() <= currentPage + 1) return 0;
return mPageStart.elementAt(currentPage + 1)
- mPageStart.elementAt(currentPage);
}
public int getCurrentPageStart(int currentPage) {
if (mPageStart.size() < currentPage + 1) return mTotalChoicesNum;
return mPageStart.elementAt(currentPage);
}
public boolean pageForwardable(int currentPage) {
if (mPageStart.size() <= currentPage + 1) return false;
if (mPageStart.elementAt(currentPage + 1) >= mTotalChoicesNum) {
return false;
}
return true;
}
public boolean pageBackwardable(int currentPage) {
if (currentPage > 0) return true;
return false;
}
public boolean charBeforeCursorIsSeparator() {
int len = mSurface.length();
if (mCursorPos > len) return false;
if (mCursorPos > 0 && mSurface.charAt(mCursorPos - 1) == '\'') {
return true;
}
return false;
}
public int getCursorPos() {
return mCursorPos;
}
public int getCursorPosInCmps() {
int cursorPos = mCursorPos;
int fixedLen = 0;
for (int hzPos = 0; hzPos < mFixedLen; hzPos++) {
if (mCursorPos >= mSplStart[hzPos + 2]) {
cursorPos -= mSplStart[hzPos + 2] - mSplStart[hzPos + 1];
cursorPos += 1;
}
}
return cursorPos;
}
public int getCursorPosInCmpsDisplay() {
int cursorPos = getCursorPosInCmps();
// +2 is because: one for mSplStart[0], which is used for other
// purpose(The length of the segmentation string), and another
// for the first spelling which does not need a space before it.
for (int pos = mFixedLen + 2; pos < mSplStart.length - 1; pos++) {
if (mCursorPos <= mSplStart[pos]) {
break;
} else {
cursorPos++;
}
}
return cursorPos;
}
public void moveCursorToEdge(boolean left) {
if (left)
mCursorPos = 0;
else
mCursorPos = mSurface.length();
}
// Move cursor. If offset is 0, this function can be used to adjust
// the cursor into the bounds of the string.
public void moveCursor(int offset) {
if (offset > 1 || offset < -1) return;
if (offset != 0) {
int hzPos = 0;
for (hzPos = 0; hzPos <= mFixedLen; hzPos++) {
if (mCursorPos == mSplStart[hzPos + 1]) {
if (offset < 0) {
if (hzPos > 0) {
offset = mSplStart[hzPos]
- mSplStart[hzPos + 1];
}
} else {
if (hzPos < mFixedLen) {
offset = mSplStart[hzPos + 2]
- mSplStart[hzPos + 1];
}
}
break;
}
}
}
mCursorPos += offset;
if (mCursorPos < 0) {
mCursorPos = 0;
} else if (mCursorPos > mSurface.length()) {
mCursorPos = mSurface.length();
}
}
public int getSplNum() {
return mSplStart[0];
}
public int getFixedLen() {
return mFixedLen;
}
}
}
|
