• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2010 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5  * use this file except in compliance with the License. You may obtain a copy of
6  * the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
12  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13  * License for the specific language governing permissions and limitations under
14  * the License.
15  */
16 
17 package com.android.inputmethod.latin;
18 
19 import android.text.TextUtils;
20 import android.view.inputmethod.CompletionInfo;
21 
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.HashSet;
25 
26 public class SuggestedWords {
27     public static final SuggestedWords EMPTY = new SuggestedWords(
28             new ArrayList<SuggestedWordInfo>(0), false, false, false, false, false, false);
29 
30     public final boolean mTypedWordValid;
31     public final boolean mHasAutoCorrectionCandidate;
32     public final boolean mIsPunctuationSuggestions;
33     public final boolean mAllowsToBeAutoCorrected;
34     public final boolean mIsObsoleteSuggestions;
35     public final boolean mIsPrediction;
36     private final ArrayList<SuggestedWordInfo> mSuggestedWordInfoList;
37 
SuggestedWords(final ArrayList<SuggestedWordInfo> suggestedWordInfoList, final boolean typedWordValid, final boolean hasAutoCorrectionCandidate, final boolean allowsToBeAutoCorrected, final boolean isPunctuationSuggestions, final boolean isObsoleteSuggestions, final boolean isPrediction)38     public SuggestedWords(final ArrayList<SuggestedWordInfo> suggestedWordInfoList,
39             final boolean typedWordValid,
40             final boolean hasAutoCorrectionCandidate,
41             final boolean allowsToBeAutoCorrected,
42             final boolean isPunctuationSuggestions,
43             final boolean isObsoleteSuggestions,
44             final boolean isPrediction) {
45         mSuggestedWordInfoList = suggestedWordInfoList;
46         mTypedWordValid = typedWordValid;
47         mHasAutoCorrectionCandidate = hasAutoCorrectionCandidate;
48         mAllowsToBeAutoCorrected = allowsToBeAutoCorrected;
49         mIsPunctuationSuggestions = isPunctuationSuggestions;
50         mIsObsoleteSuggestions = isObsoleteSuggestions;
51         mIsPrediction = isPrediction;
52     }
53 
size()54     public int size() {
55         return mSuggestedWordInfoList.size();
56     }
57 
getWord(int pos)58     public CharSequence getWord(int pos) {
59         return mSuggestedWordInfoList.get(pos).mWord;
60     }
61 
getWordInfo(int pos)62     public SuggestedWordInfo getWordInfo(int pos) {
63         return mSuggestedWordInfoList.get(pos);
64     }
65 
getInfo(int pos)66     public SuggestedWordInfo getInfo(int pos) {
67         return mSuggestedWordInfoList.get(pos);
68     }
69 
hasAutoCorrectionWord()70     public boolean hasAutoCorrectionWord() {
71         return mHasAutoCorrectionCandidate && size() > 1 && !mTypedWordValid;
72     }
73 
willAutoCorrect()74     public boolean willAutoCorrect() {
75         return !mTypedWordValid && mHasAutoCorrectionCandidate;
76     }
77 
78     @Override
toString()79     public String toString() {
80         // Pretty-print method to help debug
81         return "SuggestedWords:"
82                 + " mTypedWordValid=" + mTypedWordValid
83                 + " mHasAutoCorrectionCandidate=" + mHasAutoCorrectionCandidate
84                 + " mAllowsToBeAutoCorrected=" + mAllowsToBeAutoCorrected
85                 + " mIsPunctuationSuggestions=" + mIsPunctuationSuggestions
86                 + " words=" + Arrays.toString(mSuggestedWordInfoList.toArray());
87     }
88 
getFromApplicationSpecifiedCompletions( final CompletionInfo[] infos)89     public static ArrayList<SuggestedWordInfo> getFromApplicationSpecifiedCompletions(
90             final CompletionInfo[] infos) {
91         final ArrayList<SuggestedWordInfo> result = new ArrayList<SuggestedWordInfo>();
92         for (CompletionInfo info : infos) {
93             if (null != info && info.getText() != null) {
94                 result.add(new SuggestedWordInfo(info.getText(), SuggestedWordInfo.MAX_SCORE));
95             }
96         }
97         return result;
98     }
99 
100     // Should get rid of the first one (what the user typed previously) from suggestions
101     // and replace it with what the user currently typed.
getTypedWordAndPreviousSuggestions( final CharSequence typedWord, final SuggestedWords previousSuggestions)102     public static ArrayList<SuggestedWordInfo> getTypedWordAndPreviousSuggestions(
103             final CharSequence typedWord, final SuggestedWords previousSuggestions) {
104         final ArrayList<SuggestedWordInfo> suggestionsList = new ArrayList<SuggestedWordInfo>();
105         final HashSet<String> alreadySeen = new HashSet<String>();
106         suggestionsList.add(new SuggestedWordInfo(typedWord, SuggestedWordInfo.MAX_SCORE));
107         alreadySeen.add(typedWord.toString());
108         final int previousSize = previousSuggestions.size();
109         for (int pos = 1; pos < previousSize; pos++) {
110             final SuggestedWordInfo prevWordInfo = previousSuggestions.getWordInfo(pos);
111             final String prevWord = prevWordInfo.mWord.toString();
112             // Filter out duplicate suggestion.
113             if (!alreadySeen.contains(prevWord)) {
114                 suggestionsList.add(prevWordInfo);
115                 alreadySeen.add(prevWord);
116             }
117         }
118         return suggestionsList;
119     }
120 
121     public static class SuggestedWordInfo {
122         public static final int MAX_SCORE = Integer.MAX_VALUE;
123         private final String mWordStr;
124         public final CharSequence mWord;
125         public final int mScore;
126         public final int mCodePointCount;
127         private String mDebugString = "";
128 
SuggestedWordInfo(final CharSequence word, final int score)129         public SuggestedWordInfo(final CharSequence word, final int score) {
130             mWordStr = word.toString();
131             mWord = word;
132             mScore = score;
133             mCodePointCount = mWordStr.codePointCount(0, mWordStr.length());
134         }
135 
136 
setDebugString(String str)137         public void setDebugString(String str) {
138             if (null == str) throw new NullPointerException("Debug info is null");
139             mDebugString = str;
140         }
141 
getDebugString()142         public String getDebugString() {
143             return mDebugString;
144         }
145 
codePointCount()146         public int codePointCount() {
147             return mCodePointCount;
148         }
149 
codePointAt(int i)150         public int codePointAt(int i) {
151             return mWordStr.codePointAt(i);
152         }
153 
154         @Override
toString()155         public String toString() {
156             if (TextUtils.isEmpty(mDebugString)) {
157                 return mWordStr;
158             } else {
159                 return mWordStr + " (" + mDebugString.toString() + ")";
160             }
161         }
162 
163         // TODO: Consolidate this method and StringUtils.removeDupes() in the future.
removeDups(ArrayList<SuggestedWordInfo> candidates)164         public static void removeDups(ArrayList<SuggestedWordInfo> candidates) {
165             if (candidates.size() <= 1) {
166                 return;
167             }
168             int i = 1;
169             while(i < candidates.size()) {
170                 final SuggestedWordInfo cur = candidates.get(i);
171                 for (int j = 0; j < i; ++j) {
172                     final SuggestedWordInfo previous = candidates.get(j);
173                     if (TextUtils.equals(cur.mWord, previous.mWord)) {
174                         candidates.remove(cur.mScore < previous.mScore ? i : j);
175                         --i;
176                         break;
177                     }
178                 }
179                 ++i;
180             }
181         }
182     }
183 }
184