2011-07-25 01:35:51 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2011 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.latin.spellcheck;
|
|
|
|
|
2011-08-16 10:43:16 +00:00
|
|
|
import android.content.Intent;
|
2011-08-04 11:19:12 +00:00
|
|
|
import android.content.res.Resources;
|
2011-07-25 01:35:51 +00:00
|
|
|
import android.service.textservice.SpellCheckerService;
|
2011-08-05 10:42:36 +00:00
|
|
|
import android.service.textservice.SpellCheckerService.Session;
|
2011-08-16 08:37:18 +00:00
|
|
|
import android.util.Log;
|
2011-07-25 01:35:51 +00:00
|
|
|
import android.view.textservice.SuggestionsInfo;
|
|
|
|
import android.view.textservice.TextInfo;
|
2011-08-17 06:10:56 +00:00
|
|
|
import android.text.TextUtils;
|
2011-07-25 01:35:51 +00:00
|
|
|
|
2011-08-04 11:19:12 +00:00
|
|
|
import com.android.inputmethod.compat.ArraysCompatUtils;
|
|
|
|
import com.android.inputmethod.keyboard.Key;
|
|
|
|
import com.android.inputmethod.keyboard.ProximityInfo;
|
|
|
|
import com.android.inputmethod.latin.Dictionary;
|
|
|
|
import com.android.inputmethod.latin.Dictionary.DataType;
|
|
|
|
import com.android.inputmethod.latin.Dictionary.WordCallback;
|
2011-08-18 10:29:29 +00:00
|
|
|
import com.android.inputmethod.latin.DictionaryCollection;
|
2011-08-04 11:19:12 +00:00
|
|
|
import com.android.inputmethod.latin.DictionaryFactory;
|
2011-08-26 11:22:47 +00:00
|
|
|
import com.android.inputmethod.latin.LocaleUtils;
|
2011-08-18 10:29:29 +00:00
|
|
|
import com.android.inputmethod.latin.UserDictionary;
|
2011-08-04 11:19:12 +00:00
|
|
|
import com.android.inputmethod.latin.Utils;
|
|
|
|
import com.android.inputmethod.latin.WordComposer;
|
|
|
|
|
2011-08-22 09:03:42 +00:00
|
|
|
import java.util.ArrayList;
|
2011-08-08 04:37:11 +00:00
|
|
|
import java.util.Arrays;
|
2011-08-04 11:19:12 +00:00
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.Locale;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.TreeMap;
|
|
|
|
|
2011-07-25 01:35:51 +00:00
|
|
|
/**
|
|
|
|
* Service for spell checking, using LatinIME's dictionaries and mechanisms.
|
|
|
|
*/
|
|
|
|
public class AndroidSpellCheckerService extends SpellCheckerService {
|
2011-07-28 11:55:00 +00:00
|
|
|
private static final String TAG = AndroidSpellCheckerService.class.getSimpleName();
|
2011-08-16 08:37:18 +00:00
|
|
|
private static final boolean DBG = false;
|
|
|
|
private static final int POOL_SIZE = 2;
|
2011-08-04 11:19:12 +00:00
|
|
|
|
2011-08-22 09:03:42 +00:00
|
|
|
private final static String[] EMPTY_STRING_ARRAY = new String[0];
|
2011-08-17 06:10:56 +00:00
|
|
|
private final static SuggestionsInfo EMPTY_SUGGESTIONS_INFO =
|
2011-08-22 09:03:42 +00:00
|
|
|
new SuggestionsInfo(0, EMPTY_STRING_ARRAY);
|
2011-08-16 10:43:16 +00:00
|
|
|
private Map<String, DictionaryPool> mDictionaryPools =
|
2011-08-16 08:37:18 +00:00
|
|
|
Collections.synchronizedMap(new TreeMap<String, DictionaryPool>());
|
2011-08-18 10:29:29 +00:00
|
|
|
private Map<String, Dictionary> mUserDictionaries =
|
|
|
|
Collections.synchronizedMap(new TreeMap<String, Dictionary>());
|
2011-08-04 11:19:12 +00:00
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
@Override
|
|
|
|
public Session createSession() {
|
|
|
|
return new AndroidSpellCheckerSession();
|
|
|
|
}
|
|
|
|
|
2011-08-04 11:19:12 +00:00
|
|
|
private static class SuggestionsGatherer implements WordCallback {
|
|
|
|
private final int DEFAULT_SUGGESTION_LENGTH = 16;
|
2011-08-22 09:03:42 +00:00
|
|
|
private final ArrayList<CharSequence> mSuggestions;
|
2011-08-04 11:19:12 +00:00
|
|
|
private final int[] mScores;
|
|
|
|
private final int mMaxLength;
|
|
|
|
private int mLength = 0;
|
2011-08-22 09:03:42 +00:00
|
|
|
private boolean mSeenSuggestions = false;
|
2011-08-04 11:19:12 +00:00
|
|
|
|
|
|
|
SuggestionsGatherer(final int maxLength) {
|
|
|
|
mMaxLength = maxLength;
|
2011-08-22 09:03:42 +00:00
|
|
|
mSuggestions = new ArrayList<CharSequence>(maxLength + 1);
|
2011-08-04 11:19:12 +00:00
|
|
|
mScores = new int[mMaxLength];
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
synchronized public boolean addWord(char[] word, int wordOffset, int wordLength, int score,
|
|
|
|
int dicTypeId, DataType dataType) {
|
|
|
|
final int positionIndex = ArraysCompatUtils.binarySearch(mScores, 0, mLength, score);
|
|
|
|
// binarySearch returns the index if the element exists, and -<insertion index> - 1
|
|
|
|
// if it doesn't. See documentation for binarySearch.
|
|
|
|
final int insertIndex = positionIndex >= 0 ? positionIndex : -positionIndex - 1;
|
|
|
|
|
2011-08-22 09:03:42 +00:00
|
|
|
mSeenSuggestions = true;
|
2011-08-04 11:19:12 +00:00
|
|
|
if (mLength < mMaxLength) {
|
|
|
|
final int copyLen = mLength - insertIndex;
|
|
|
|
++mLength;
|
|
|
|
System.arraycopy(mScores, insertIndex, mScores, insertIndex + 1, copyLen);
|
2011-08-22 09:03:42 +00:00
|
|
|
mSuggestions.add(insertIndex, new String(word, wordOffset, wordLength));
|
2011-08-04 11:19:12 +00:00
|
|
|
} else {
|
|
|
|
if (insertIndex == 0) return true;
|
|
|
|
System.arraycopy(mScores, 1, mScores, 0, insertIndex);
|
2011-08-22 09:03:42 +00:00
|
|
|
mSuggestions.add(insertIndex, new String(word, wordOffset, wordLength));
|
|
|
|
mSuggestions.remove(0);
|
2011-08-04 11:19:12 +00:00
|
|
|
}
|
|
|
|
mScores[insertIndex] = score;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
public String[] getGatheredSuggestions() {
|
2011-08-22 09:03:42 +00:00
|
|
|
if (!mSeenSuggestions) return null;
|
|
|
|
if (0 == mLength) return EMPTY_STRING_ARRAY;
|
2011-08-04 11:19:12 +00:00
|
|
|
|
2011-08-22 09:03:42 +00:00
|
|
|
if (DBG) {
|
|
|
|
if (mLength != mSuggestions.size()) {
|
|
|
|
Log.e(TAG, "Suggestion size is not the same as stored mLength");
|
|
|
|
}
|
2011-08-04 11:19:12 +00:00
|
|
|
}
|
2011-08-22 09:03:42 +00:00
|
|
|
Collections.reverse(mSuggestions);
|
|
|
|
Utils.removeDupes(mSuggestions);
|
|
|
|
// This returns a String[], while toArray() returns an Object[] which cannot be cast
|
|
|
|
// into a String[].
|
|
|
|
return mSuggestions.toArray(EMPTY_STRING_ARRAY);
|
2011-08-04 11:19:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-16 10:43:16 +00:00
|
|
|
@Override
|
|
|
|
public boolean onUnbind(final Intent intent) {
|
|
|
|
final Map<String, DictionaryPool> oldPools = mDictionaryPools;
|
|
|
|
mDictionaryPools = Collections.synchronizedMap(new TreeMap<String, DictionaryPool>());
|
2011-08-18 10:29:29 +00:00
|
|
|
final Map<String, Dictionary> oldUserDictionaries = mUserDictionaries;
|
|
|
|
mUserDictionaries = Collections.synchronizedMap(new TreeMap<String, Dictionary>());
|
2011-08-16 10:43:16 +00:00
|
|
|
for (DictionaryPool pool : oldPools.values()) {
|
|
|
|
pool.close();
|
|
|
|
}
|
2011-08-18 10:29:29 +00:00
|
|
|
for (Dictionary dict : oldUserDictionaries.values()) {
|
|
|
|
dict.close();
|
|
|
|
}
|
2011-08-16 10:43:16 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-08-16 08:37:18 +00:00
|
|
|
private DictionaryPool getDictionaryPool(final String locale) {
|
|
|
|
DictionaryPool pool = mDictionaryPools.get(locale);
|
|
|
|
if (null == pool) {
|
2011-08-26 11:22:47 +00:00
|
|
|
final Locale localeObject = LocaleUtils.constructLocaleFromString(locale);
|
2011-08-16 08:37:18 +00:00
|
|
|
pool = new DictionaryPool(POOL_SIZE, this, localeObject);
|
|
|
|
mDictionaryPools.put(locale, pool);
|
2011-08-04 11:19:12 +00:00
|
|
|
}
|
2011-08-16 08:37:18 +00:00
|
|
|
return pool;
|
|
|
|
}
|
|
|
|
|
|
|
|
public DictAndProximity createDictAndProximity(final Locale locale) {
|
|
|
|
final ProximityInfo proximityInfo = ProximityInfo.createSpellCheckerProximityInfo();
|
|
|
|
final Resources resources = getResources();
|
|
|
|
final int fallbackResourceId = Utils.getMainDictionaryResourceId(resources);
|
2011-08-18 10:29:29 +00:00
|
|
|
final DictionaryCollection dictionaryCollection =
|
2011-08-16 08:37:18 +00:00
|
|
|
DictionaryFactory.createDictionaryFromManager(this, locale, fallbackResourceId);
|
2011-08-18 10:29:29 +00:00
|
|
|
final String localeStr = locale.toString();
|
|
|
|
Dictionary userDict = mUserDictionaries.get(localeStr);
|
|
|
|
if (null == userDict) {
|
|
|
|
userDict = new UserDictionary(this, localeStr);
|
|
|
|
mUserDictionaries.put(localeStr, userDict);
|
|
|
|
}
|
|
|
|
dictionaryCollection.addDictionary(userDict);
|
|
|
|
return new DictAndProximity(dictionaryCollection, proximityInfo);
|
2011-08-04 11:19:12 +00:00
|
|
|
}
|
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
private class AndroidSpellCheckerSession extends Session {
|
2011-08-16 08:37:18 +00:00
|
|
|
// Immutable, but need the locale which is not available in the constructor yet
|
|
|
|
DictionaryPool mDictionaryPool;
|
2011-08-17 06:10:56 +00:00
|
|
|
// Likewise
|
|
|
|
Locale mLocale;
|
2011-08-16 08:37:18 +00:00
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
@Override
|
|
|
|
public void onCreate() {
|
2011-08-17 06:10:56 +00:00
|
|
|
final String localeString = getLocale();
|
|
|
|
mDictionaryPool = getDictionaryPool(localeString);
|
2011-08-26 11:22:47 +00:00
|
|
|
mLocale = LocaleUtils.constructLocaleFromString(localeString);
|
2011-07-28 11:55:00 +00:00
|
|
|
}
|
2011-08-04 11:19:12 +00:00
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
// Note : this must be reentrant
|
|
|
|
/**
|
|
|
|
* Gets a list of suggestions for a specific string. This returns a list of possible
|
2011-08-16 04:58:37 +00:00
|
|
|
* corrections for the text passed as an argument. It may split or group words, and
|
2011-08-05 10:42:36 +00:00
|
|
|
* even perform grammatical analysis.
|
|
|
|
*/
|
|
|
|
@Override
|
|
|
|
public SuggestionsInfo onGetSuggestions(final TextInfo textInfo,
|
|
|
|
final int suggestionsLimit) {
|
|
|
|
final String text = textInfo.getText();
|
|
|
|
|
2011-08-17 06:10:56 +00:00
|
|
|
if (TextUtils.isEmpty(text)) return EMPTY_SUGGESTIONS_INFO;
|
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
final SuggestionsGatherer suggestionsGatherer =
|
|
|
|
new SuggestionsGatherer(suggestionsLimit);
|
|
|
|
final WordComposer composer = new WordComposer();
|
|
|
|
final int length = text.length();
|
|
|
|
for (int i = 0; i < length; ++i) {
|
2011-08-08 04:37:11 +00:00
|
|
|
final int character = text.codePointAt(i);
|
|
|
|
final int proximityIndex = SpellCheckerProximityInfo.getIndexOf(character);
|
|
|
|
final int[] proximities;
|
|
|
|
if (-1 == proximityIndex) {
|
|
|
|
proximities = new int[] { character };
|
|
|
|
} else {
|
|
|
|
proximities = Arrays.copyOfRange(SpellCheckerProximityInfo.PROXIMITY,
|
|
|
|
proximityIndex, proximityIndex + SpellCheckerProximityInfo.ROW_SIZE);
|
|
|
|
}
|
|
|
|
composer.add(character, proximities,
|
2011-08-05 10:42:36 +00:00
|
|
|
WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
|
|
|
|
}
|
2011-08-16 08:37:18 +00:00
|
|
|
|
|
|
|
boolean isInDict = true;
|
|
|
|
try {
|
|
|
|
final DictAndProximity dictInfo = mDictionaryPool.take();
|
|
|
|
dictInfo.mDictionary.getWords(composer, suggestionsGatherer,
|
|
|
|
dictInfo.mProximityInfo);
|
|
|
|
isInDict = dictInfo.mDictionary.isValidWord(text);
|
2011-08-17 06:10:56 +00:00
|
|
|
if (!isInDict && Character.isUpperCase(text.codePointAt(0))) {
|
|
|
|
// If the first char is not uppercase, then the word is either all lower case,
|
|
|
|
// in which case we already tested it, or mixed case, in which case we don't
|
|
|
|
// want to test a lower-case version of it. Hence the test above.
|
|
|
|
// Also note that by isEmpty() test at the top of the method codePointAt(0) is
|
|
|
|
// guaranteed to be there.
|
|
|
|
final int len = text.codePointCount(0, text.length());
|
|
|
|
int capsCount = 1;
|
|
|
|
for (int i = 1; i < len; ++i) {
|
|
|
|
if (1 != capsCount && i != capsCount) break;
|
|
|
|
if (Character.isUpperCase(text.codePointAt(i))) ++capsCount;
|
|
|
|
}
|
|
|
|
// We know the first char is upper case. So we want to test if either everything
|
|
|
|
// else is lower case, or if everything else is upper case. If the string is
|
|
|
|
// exactly one char long, then we will arrive here with capsCount 0, and this is
|
|
|
|
// correct, too.
|
|
|
|
if (1 == capsCount || len == capsCount) {
|
|
|
|
isInDict = dictInfo.mDictionary.isValidWord(text.toLowerCase(mLocale));
|
|
|
|
}
|
|
|
|
}
|
2011-08-16 10:43:16 +00:00
|
|
|
if (!mDictionaryPool.offer(dictInfo)) {
|
|
|
|
Log.e(TAG, "Can't re-insert a dictionary into its pool");
|
|
|
|
}
|
2011-08-16 08:37:18 +00:00
|
|
|
} catch (InterruptedException e) {
|
|
|
|
// I don't think this can happen.
|
2011-08-17 06:10:56 +00:00
|
|
|
return EMPTY_SUGGESTIONS_INFO;
|
2011-08-16 04:58:37 +00:00
|
|
|
}
|
2011-08-05 10:42:36 +00:00
|
|
|
|
2011-08-16 08:37:18 +00:00
|
|
|
final String[] suggestions = suggestionsGatherer.getGatheredSuggestions();
|
|
|
|
|
2011-08-05 10:42:36 +00:00
|
|
|
final int flags =
|
|
|
|
(isInDict ? SuggestionsInfo.RESULT_ATTR_IN_THE_DICTIONARY : 0)
|
|
|
|
| (null != suggestions
|
|
|
|
? SuggestionsInfo.RESULT_ATTR_LOOKS_LIKE_TYPO : 0);
|
|
|
|
return new SuggestionsInfo(flags, suggestions);
|
|
|
|
}
|
2011-07-25 01:35:51 +00:00
|
|
|
}
|
|
|
|
}
|