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
|
/*
* Copyright (C) 2014 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.keyboard.layout.expected;
import com.android.inputmethod.keyboard.Key;
import com.android.inputmethod.keyboard.internal.KeyboardIconsSet;
import com.android.inputmethod.keyboard.internal.MoreKeySpec;
import com.android.inputmethod.latin.common.Constants;
import com.android.inputmethod.latin.common.StringUtils;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
/**
* This class builds an actual keyboard for unit test.
*
* An actual keyboard is an array of rows, and a row consists of an array of {@link Key}s.
* Each row may have different number of {@link Key}s.
*/
public final class ActualKeyboardBuilder extends AbstractKeyboardBuilder<Key> {
private static ArrayList<Key> filterOutSpacer(final List<Key> keys) {
final ArrayList<Key> filteredKeys = new ArrayList<>();
for (final Key key : keys) {
if (key.isSpacer()) {
continue;
}
filteredKeys.add(key);
}
return filteredKeys;
}
/**
* Create the keyboard that consists of the array of rows of the actual keyboard's keys.
* @param sortedKeys keys list of the actual keyboard that is sorted from top-left to
* bottom-right.
* @return the actual keyboard grouped with rows.
*/
public static Key[][] buildKeyboard(final List<Key> sortedKeys) {
// Filter out spacer to prepare to create rows.
final ArrayList<Key> filteredSortedKeys = filterOutSpacer(sortedKeys);
// Grouping keys into rows.
final ArrayList<ArrayList<Key>> rows = new ArrayList<>();
ArrayList<Key> elements = new ArrayList<>();
int lastY = filteredSortedKeys.get(0).getY();
for (final Key key : filteredSortedKeys) {
if (lastY != key.getY()) {
// A new row is starting.
lastY = key.getY();
rows.add(elements);
elements = new ArrayList<>();
}
elements.add(key);
}
rows.add(elements); // Add the last row.
// Calculate each dimension of rows and create a builder.
final int[] dimensions = new int[rows.size()];
for (int rowIndex = 0; rowIndex < dimensions.length; rowIndex++) {
dimensions[rowIndex] = rows.get(rowIndex).size();
}
final ActualKeyboardBuilder builder = new ActualKeyboardBuilder();
for (int rowIndex = 0; rowIndex < rows.size(); rowIndex++) {
final int row = rowIndex + 1;
final ArrayList<Key> rowKeys = rows.get(rowIndex);
builder.setRowAt(row, rowKeys.toArray(new Key[rowKeys.size()]));
}
return builder.build();
}
@Override
Key defaultElement() { return null; }
@Override
Key[] newArray(final int size) { return new Key[size]; }
@Override
Key[][] newArrayOfArray(final int size) { return new Key[size][]; }
// Helper class to create concise representation from the key specification.
static class MoreKeySpecStringizer extends StringUtils.Stringizer<MoreKeySpec> {
static final MoreKeySpecStringizer STRINGIZER = new MoreKeySpecStringizer();
@Override
public String stringize(final MoreKeySpec spec) {
if (spec == null) {
return "null";
}
return toString(spec.mLabel, spec.mIconId, spec.mOutputText, spec.mCode);
}
@Nonnull
static String toString(final String label, final int iconId, final String outputText,
final int code) {
final String visual = (iconId != KeyboardIconsSet.ICON_UNDEFINED)
? KeyboardIconsSet.getIconName(iconId) : label;
final String output;
if (code == Constants.CODE_OUTPUT_TEXT) {
output = outputText;
} else if (code < Constants.CODE_SPACE) {
output = Constants.printableCode(code);
} else {
output = StringUtils.newSingleCodePointString(code);
}
if (visual.equals(output)) {
return visual;
}
return visual + "|" + output;
}
}
// Helper class to create concise representation from the key.
static class KeyStringizer extends StringUtils.Stringizer<Key> {
static final KeyStringizer STRINGIZER = new KeyStringizer();
@Override
public String stringize(@Nullable final Key key) {
if (key == null) {
return "NULL";
}
if (key.isSpacer()) {
return "SPACER";
}
final StringBuilder sb = new StringBuilder();
sb.append(MoreKeySpecStringizer.toString(
key.getLabel(), key.getIconId(), key.getOutputText(), key.getCode()));
final MoreKeySpec[] moreKeys = key.getMoreKeys();
if (moreKeys == null) {
return sb.toString();
}
sb.append("^");
sb.append(MoreKeySpecStringizer.STRINGIZER.join(moreKeys));
return sb.toString();
}
}
/**
* Convert the key to human readable string.
* @param key the key to be converted to string.
* @return the human readable representation of <code>key</code>.
*/
@Nonnull
public static String toString(@Nullable final Key key) {
return KeyStringizer.STRINGIZER.stringize(key);
}
/**
* Convert the keyboard row to human readable string.
* @param keys the keyboard row to be converted to string.
* @return the human readable representation of <code>keys</code>.
*/
@Nonnull
public static String toString(@Nullable final Key[] keys) {
return KeyStringizer.STRINGIZER.join(keys);
}
// Helper class to create concise representation from the array of the key.
static class KeyArrayStringizer extends StringUtils.Stringizer<Key[]> {
static final KeyArrayStringizer STRINGIZER = new KeyArrayStringizer();
@Override
public String stringize(@Nullable final Key[] keyArray) {
return KeyStringizer.STRINGIZER.join(keyArray);
}
}
/**
* Convert the keyboard to human readable string.
* @param rows the keyboard to be converted to string.
* @return the human readable representation of <code>rows</code>.
*/
@Nonnull
public static String toString(@Nullable final Key[][] rows) {
return KeyArrayStringizer.STRINGIZER.join(rows, "\n" /* delimiter */);
}
}
|
