1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/*
* Copyright (C) 2010 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;
import android.view.inputmethod.CompletionInfo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
public class SuggestedWords {
public static final SuggestedWords EMPTY = new SuggestedWords(false, false, false, false,
Collections.<SuggestedWordInfo>emptyList());
public final boolean mTypedWordValid;
public final boolean mHasAutoCorrectionCandidate;
public final boolean mIsPunctuationSuggestions;
private final List<SuggestedWordInfo> mSuggestedWordInfoList;
SuggestedWords(boolean typedWordValid,
boolean hasAutoCorrectionCandidate, boolean isPunctuationSuggestions,
boolean shouldBlockAutoCorrectionBySafetyNet,
List<SuggestedWordInfo> suggestedWordInfoList) {
mTypedWordValid = typedWordValid;
mHasAutoCorrectionCandidate = hasAutoCorrectionCandidate
&& !shouldBlockAutoCorrectionBySafetyNet;
mIsPunctuationSuggestions = isPunctuationSuggestions;
mSuggestedWordInfoList = suggestedWordInfoList;
}
public int size() {
return mSuggestedWordInfoList.size();
}
public CharSequence getWord(int pos) {
return mSuggestedWordInfoList.get(pos).mWord;
}
public SuggestedWordInfo getInfo(int pos) {
return mSuggestedWordInfoList != null ? mSuggestedWordInfoList.get(pos) : null;
}
public boolean hasAutoCorrectionWord() {
return mHasAutoCorrectionCandidate && size() > 1 && !mTypedWordValid;
}
public boolean willAutoCorrect() {
return !mTypedWordValid && mHasAutoCorrectionCandidate;
}
@Override
public String toString() {
// Pretty-print method to help debug
return "SuggestedWords:"
+ " mTypedWordValid=" + mTypedWordValid
+ " mHasAutoCorrectionCandidate=" + mHasAutoCorrectionCandidate
+ " mIsPunctuationSuggestions=" + mIsPunctuationSuggestions;
}
public static class Builder {
private boolean mTypedWordValid;
private boolean mHasMinimalSuggestion;
private final boolean mIsPunctuationSuggestions;
private boolean mShouldBlockAutoCorrectionBySafetyNet;
private final boolean mAllowsToBeAutoCorrected;
private final List<SuggestedWordInfo> mSuggestedWordInfoList;
public Builder(final List<SuggestedWordInfo> suggestedWordInfoList,
final boolean allowsToBeAutoCorrected,
final boolean isPunctuationSuggestions) {
mSuggestedWordInfoList = suggestedWordInfoList;
mAllowsToBeAutoCorrected = allowsToBeAutoCorrected;
mIsPunctuationSuggestions = isPunctuationSuggestions;
}
public static List<SuggestedWordInfo> getFromCharSequenceList(
final List<CharSequence> wordList) {
final ArrayList<SuggestedWordInfo> result = new ArrayList<SuggestedWordInfo>();
for (CharSequence word : wordList) {
if (null != word) result.add(new SuggestedWordInfo(word, null, false));
}
return result;
}
public static List<SuggestedWordInfo> getFromApplicationSpecifiedCompletions(
final CompletionInfo[] infos) {
final ArrayList<SuggestedWordInfo> result = new ArrayList<SuggestedWordInfo>();
for (CompletionInfo info : infos) {
if (null != info) result.add(new SuggestedWordInfo(info.getText(), null, false));
}
return result;
}
public Builder setTypedWordValid(boolean typedWordValid) {
mTypedWordValid = typedWordValid;
return this;
}
public Builder setHasMinimalSuggestion(boolean hasMinimalSuggestion) {
mHasMinimalSuggestion = hasMinimalSuggestion;
return this;
}
public Builder setShouldBlockAutoCorrectionBySafetyNet() {
mShouldBlockAutoCorrectionBySafetyNet = true;
return this;
}
// Should get rid of the first one (what the user typed previously) from suggestions
// and replace it with what the user currently typed.
public static ArrayList<SuggestedWordInfo> getTypedWordAndPreviousSuggestions(
final CharSequence typedWord, final SuggestedWords previousSuggestions) {
final ArrayList<SuggestedWordInfo> suggestionsList = new ArrayList<SuggestedWordInfo>();
final HashSet<String> alreadySeen = new HashSet<String>();
suggestionsList.add(new SuggestedWordInfo(typedWord, null, false));
alreadySeen.add(typedWord.toString());
final int previousSize = previousSuggestions.size();
for (int pos = 1; pos < previousSize; pos++) {
final String prevWord = previousSuggestions.getWord(pos).toString();
// Filter out duplicate suggestion.
if (!alreadySeen.contains(prevWord)) {
suggestionsList.add(new SuggestedWordInfo(prevWord, null, true));
alreadySeen.add(prevWord);
}
}
return suggestionsList;
}
public SuggestedWords build() {
return new SuggestedWords(mTypedWordValid, mHasMinimalSuggestion,
mIsPunctuationSuggestions, mShouldBlockAutoCorrectionBySafetyNet,
mSuggestedWordInfoList);
}
public int size() {
return mSuggestedWordInfoList.size();
}
public CharSequence getWord(int pos) {
return mSuggestedWordInfoList.get(pos).mWord;
}
public boolean allowsToBeAutoCorrected() {
return mAllowsToBeAutoCorrected;
}
@Override
public String toString() {
// Pretty-print method to help debug
return "SuggestedWords.Builder:"
+ " mTypedWordValid=" + mTypedWordValid
+ " mHasMinimalSuggestion=" + mHasMinimalSuggestion
+ " mIsPunctuationSuggestions=" + mIsPunctuationSuggestions
+ " mShouldBlockAutoCorrectionBySafetyNet="
+ mShouldBlockAutoCorrectionBySafetyNet;
}
}
public static class SuggestedWordInfo {
private final CharSequence mWord;
private final CharSequence mDebugString;
private final boolean mPreviousSuggestedWord;
public SuggestedWordInfo(final CharSequence word) {
mWord = word;
mDebugString = "";
mPreviousSuggestedWord = false;
}
public SuggestedWordInfo(final CharSequence word, final CharSequence debugString,
final boolean previousSuggestedWord) {
mWord = word;
mDebugString = debugString;
mPreviousSuggestedWord = previousSuggestedWord;
}
public String getDebugString() {
if (mDebugString == null) {
return "";
} else {
return mDebugString.toString();
}
}
public boolean isObsoleteSuggestedWord () {
return mPreviousSuggestedWord;
}
}
}
|
