KeyboardThemeTests.java revision f9f409530ccdc975ef965b1d1fee44bbd341d718 
1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of 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,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.inputmethod.keyboard;
18
19import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_ICS;
20import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_KLP;
21import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_LXX_DARK;
22import static com.android.inputmethod.keyboard.KeyboardTheme.THEME_ID_LXX_LIGHT;
23
24import android.content.SharedPreferences;
25import android.os.Build.VERSION_CODES;
26import android.preference.PreferenceManager;
27import android.test.AndroidTestCase;
28import android.test.suitebuilder.annotation.SmallTest;
29
30@SmallTest
31public class KeyboardThemeTests extends AndroidTestCase {
32    private SharedPreferences mPrefs;
33
34    // TODO: Remove this constant once the *next* version becomes available.
35    private static final int VERSION_CODES_LXX = VERSION_CODES.CUR_DEVELOPMENT;
36
37    private static final int THEME_ID_NULL = -1;
38    private static final int THEME_ID_UNKNOWN = -2;
39    private static final int THEME_ID_ILLEGAL = -3;
40    private static final String ILLEGAL_THEME_ID_STRING = "ThisCausesNumberFormatExecption";
41
42    @Override
43    protected void setUp() throws Exception {
44        super.setUp();
45        mPrefs = PreferenceManager.getDefaultSharedPreferences(getContext());
46    }
47
48    /*
49     * Helper functions.
50     */
51
52    private static boolean isValidKeyboardThemeId(final int themeId) {
53        switch (themeId) {
54        case THEME_ID_ICS:
55        case THEME_ID_KLP:
56        case THEME_ID_LXX_LIGHT:
57        case THEME_ID_LXX_DARK:
58            return true;
59        default:
60            return false;
61        }
62    }
63
64    private void setKeyboardThemePreference(final String prefKey, final int themeId) {
65        final String themeIdString = Integer.toString(themeId);
66        if (isValidKeyboardThemeId(themeId) || themeId == THEME_ID_UNKNOWN) {
67            // Set valid theme id to preference.
68            mPrefs.edit().putString(prefKey, themeIdString).apply();
69            return;
70        }
71        if (themeId == THEME_ID_NULL) {
72            // Simulate undefined preference.
73            mPrefs.edit().remove(prefKey).apply();
74            return;
75        }
76        // themeId == THEME_ID_ILLEGAL
77        // Simulate illegal format theme id in preference.
78        mPrefs.edit().putString(prefKey, ILLEGAL_THEME_ID_STRING).apply();
79    }
80
81    private void assertKeyboardTheme(final int sdkVersion, final int expectedThemeId) {
82        assertEquals(expectedThemeId, KeyboardTheme.getKeyboardTheme(mPrefs, sdkVersion).mThemeId);
83    }
84
85    /*
86     * Test keyboard theme preference on the same platform version and the same keyboard version.
87     */
88
89    private void assertKeyboardThemePreference(final int sdkVersion, final int previousThemeId,
90            final int expectedThemeId) {
91        // Clear preferences before testing.
92        setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, THEME_ID_NULL);
93        setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL);
94        // Set the preference of the sdkVersion to previousThemeId.
95        final String prefKey = KeyboardTheme.getPreferenceKey(sdkVersion);
96        setKeyboardThemePreference(prefKey, previousThemeId);
97        assertKeyboardTheme(sdkVersion, expectedThemeId);
98    }
99
100    private void assertKeyboardThemePreferenceOnKlp(final int sdkVersion) {
101        final int defaultThemeId = THEME_ID_KLP;
102        assertKeyboardThemePreference(sdkVersion, THEME_ID_NULL, defaultThemeId);
103        assertKeyboardThemePreference(sdkVersion, THEME_ID_ICS, THEME_ID_ICS);
104        assertKeyboardThemePreference(sdkVersion, THEME_ID_KLP, THEME_ID_KLP);
105        assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT);
106        assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK);
107        assertKeyboardThemePreference(sdkVersion, THEME_ID_UNKNOWN, defaultThemeId);
108        assertKeyboardThemePreference(sdkVersion, THEME_ID_ILLEGAL, defaultThemeId);
109    }
110
111    public void testKeyboardThemePreferenceOnKlp() {
112        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH);
113        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
114        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN);
115        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN_MR1);
116        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.JELLY_BEAN_MR2);
117        assertKeyboardThemePreferenceOnKlp(VERSION_CODES.KITKAT);
118    }
119
120    private void assertKeyboardThemePreferenceOnLxx(final int sdkVersion) {
121        final int defaultThemeId = THEME_ID_LXX_LIGHT;
122        assertKeyboardThemePreference(sdkVersion, THEME_ID_NULL, defaultThemeId);
123        assertKeyboardThemePreference(sdkVersion, THEME_ID_ICS, THEME_ID_ICS);
124        assertKeyboardThemePreference(sdkVersion, THEME_ID_KLP, THEME_ID_KLP);
125        assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT);
126        assertKeyboardThemePreference(sdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK);
127        assertKeyboardThemePreference(sdkVersion, THEME_ID_UNKNOWN, defaultThemeId);
128        assertKeyboardThemePreference(sdkVersion, THEME_ID_ILLEGAL, defaultThemeId);
129    }
130
131    public void testKeyboardThemePreferenceOnLxx() {
132        assertKeyboardThemePreferenceOnLxx(VERSION_CODES_LXX);
133    }
134
135    /*
136     * Test default keyboard theme based on the platform version.
137     */
138
139    private void assertDefaultKeyboardTheme(final int sdkVersion, final int previousThemeId,
140            final int expectedThemeId) {
141        final String oldPrefKey = KeyboardTheme.KLP_KEYBOARD_THEME_KEY;
142        setKeyboardThemePreference(oldPrefKey, previousThemeId);
143
144        final KeyboardTheme defaultTheme =
145                KeyboardTheme.getDefaultKeyboardTheme(mPrefs, sdkVersion);
146
147        assertNotNull(defaultTheme);
148        assertEquals(expectedThemeId, defaultTheme.mThemeId);
149        if (sdkVersion <= VERSION_CODES.KITKAT) {
150            // Old preference must be retained if it is valid. Otherwise it must be pruned.
151            assertEquals(isValidKeyboardThemeId(previousThemeId), mPrefs.contains(oldPrefKey));
152            return;
153        }
154        // Old preference must be removed.
155        assertFalse(mPrefs.contains(oldPrefKey));
156    }
157
158    private void assertDefaultKeyboardThemeOnKlp(final int sdkVersion) {
159        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_NULL, THEME_ID_KLP);
160        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ICS, THEME_ID_ICS);
161        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_KLP, THEME_ID_KLP);
162        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP);
163        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP);
164    }
165
166    public void testDefaultKeyboardThemeOnKlp() {
167        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH);
168        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
169        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN);
170        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN_MR1);
171        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.JELLY_BEAN_MR2);
172        assertDefaultKeyboardThemeOnKlp(VERSION_CODES.KITKAT);
173    }
174
175    private void assertDefaultKeyboardThemeOnLxx(final int sdkVersion) {
176        // Forced to switch to LXX theme.
177        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT);
178        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT);
179        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT);
180        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT);
181        assertDefaultKeyboardTheme(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT);
182    }
183
184    public void testDefaultKeyboardThemeOnLxx() {
185        assertDefaultKeyboardThemeOnLxx(VERSION_CODES_LXX);
186    }
187
188    /*
189     * Test keyboard theme preference while upgrading the keyboard that doesn't support LXX theme
190     * to the keyboard that supports LXX theme.
191     */
192
193    private void assertUpgradeKeyboardToLxxOn(final int sdkVersion, final int previousThemeId,
194            final int expectedThemeId) {
195        setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, previousThemeId);
196        // Clean up new keyboard theme preference to simulate "upgrade to LXX keyboard".
197        setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL);
198
199        final KeyboardTheme theme = KeyboardTheme.getKeyboardTheme(mPrefs, sdkVersion);
200
201        assertNotNull(theme);
202        assertEquals(expectedThemeId, theme.mThemeId);
203        if (sdkVersion <= VERSION_CODES.KITKAT) {
204            // New preference must not exist.
205            assertFalse(mPrefs.contains(KeyboardTheme.LXX_KEYBOARD_THEME_KEY));
206            // Old preference must be retained if it is valid. Otherwise it must be pruned.
207            assertEquals(isValidKeyboardThemeId(previousThemeId),
208                    mPrefs.contains(KeyboardTheme.KLP_KEYBOARD_THEME_KEY));
209            if (isValidKeyboardThemeId(previousThemeId)) {
210                // Old preference must have an expected value.
211                assertEquals(mPrefs.getString(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, null),
212                        Integer.toString(expectedThemeId));
213            }
214            return;
215        }
216        // Old preference must be removed.
217        assertFalse(mPrefs.contains(KeyboardTheme.KLP_KEYBOARD_THEME_KEY));
218        // New preference must not exist.
219        assertFalse(mPrefs.contains(KeyboardTheme.LXX_KEYBOARD_THEME_KEY));
220    }
221
222    private void assertUpgradeKeyboardToLxxOnKlp(final int sdkVersion) {
223        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_NULL, THEME_ID_KLP);
224        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ICS, THEME_ID_ICS);
225        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_KLP, THEME_ID_KLP);
226        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP);
227        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP);
228    }
229
230    // Upgrading keyboard on I,J and K.
231    public void testUpgradeKeyboardToLxxOnKlp() {
232        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH);
233        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
234        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN);
235        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN_MR1);
236        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.JELLY_BEAN_MR2);
237        assertUpgradeKeyboardToLxxOnKlp(VERSION_CODES.KITKAT);
238    }
239
240    private void assertUpgradeKeyboardToLxxOnLxx(final int sdkVersion) {
241        // Forced to switch to LXX theme.
242        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT);
243        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT);
244        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT);
245        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT);
246        assertUpgradeKeyboardToLxxOn(sdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT);
247    }
248
249    // Upgrading keyboard on L.
250    public void testUpgradeKeyboardToLxxOnLxx() {
251        assertUpgradeKeyboardToLxxOnLxx(VERSION_CODES_LXX);
252    }
253
254    /*
255     * Test keyboard theme preference while upgrading platform version.
256     */
257
258    private void assertUpgradePlatformFromTo(final int oldSdkVersion, final int newSdkVersion,
259            final int previousThemeId, final int expectedThemeId) {
260        if (newSdkVersion < oldSdkVersion) {
261            // No need to test.
262            return;
263        }
264        // Clean up preferences.
265        setKeyboardThemePreference(KeyboardTheme.KLP_KEYBOARD_THEME_KEY, THEME_ID_NULL);
266        setKeyboardThemePreference(KeyboardTheme.LXX_KEYBOARD_THEME_KEY, THEME_ID_NULL);
267
268        final String oldPrefKey = KeyboardTheme.getPreferenceKey(oldSdkVersion);
269        setKeyboardThemePreference(oldPrefKey, previousThemeId);
270
271        assertKeyboardTheme(newSdkVersion, expectedThemeId);
272    }
273
274    private void assertUpgradePlatformFromKlpToKlp(final int oldSdkVersion,
275            final int newSdkVersion) {
276        assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_KLP);
277        assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_ICS);
278        assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_KLP);
279        assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_KLP);
280        assertUpgradePlatformFromTo(oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_KLP);
281    }
282
283    private void assertUpgradePlatformToKlpFrom(final int oldSdkVersion) {
284        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.ICE_CREAM_SANDWICH);
285        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
286        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN);
287        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN_MR1);
288        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.JELLY_BEAN_MR2);
289        assertUpgradePlatformFromKlpToKlp(oldSdkVersion, VERSION_CODES.KITKAT);
290    }
291
292    // Update platform from I,J, and K to I,J, and K
293    public void testUpgradePlatformToKlpFromKlp() {
294        assertUpgradePlatformToKlpFrom(VERSION_CODES.ICE_CREAM_SANDWICH);
295        assertUpgradePlatformToKlpFrom(VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
296        assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN);
297        assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN_MR1);
298        assertUpgradePlatformToKlpFrom(VERSION_CODES.JELLY_BEAN_MR2);
299        assertUpgradePlatformToKlpFrom(VERSION_CODES.KITKAT);
300    }
301
302    private void assertUpgradePlatformToLxxFrom(final int oldSdkVersion) {
303        // Forced to switch to LXX theme.
304        final int newSdkVersion = VERSION_CODES_LXX;
305        assertUpgradePlatformFromTo(
306                oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT);
307        assertUpgradePlatformFromTo(
308                oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_LXX_LIGHT);
309        assertUpgradePlatformFromTo(
310                oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_LXX_LIGHT);
311        assertUpgradePlatformFromTo(
312                oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT);
313        assertUpgradePlatformFromTo(
314                oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT);
315    }
316
317    // Update platform from I,J, and K to L
318    public void testUpgradePlatformToLxx() {
319        assertUpgradePlatformToLxxFrom(VERSION_CODES.ICE_CREAM_SANDWICH);
320        assertUpgradePlatformToLxxFrom(VERSION_CODES.ICE_CREAM_SANDWICH_MR1);
321        assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN);
322        assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN_MR1);
323        assertUpgradePlatformToLxxFrom(VERSION_CODES.JELLY_BEAN_MR2);
324        assertUpgradePlatformToLxxFrom(VERSION_CODES.KITKAT);
325    }
326
327    // Update platform from L to L.
328    public void testUpgradePlatformToLxxFromLxx() {
329        final int oldSdkVersion = VERSION_CODES_LXX;
330        final int newSdkVersion = VERSION_CODES_LXX;
331        assertUpgradePlatformFromTo(
332                oldSdkVersion, newSdkVersion, THEME_ID_NULL, THEME_ID_LXX_LIGHT);
333        assertUpgradePlatformFromTo(
334                oldSdkVersion, newSdkVersion, THEME_ID_ICS, THEME_ID_ICS);
335        assertUpgradePlatformFromTo(
336                oldSdkVersion, newSdkVersion, THEME_ID_KLP, THEME_ID_KLP);
337        assertUpgradePlatformFromTo(
338                oldSdkVersion, newSdkVersion, THEME_ID_LXX_LIGHT, THEME_ID_LXX_LIGHT);
339        assertUpgradePlatformFromTo(
340                oldSdkVersion, newSdkVersion, THEME_ID_LXX_DARK, THEME_ID_LXX_DARK);
341        assertUpgradePlatformFromTo(
342                oldSdkVersion, newSdkVersion, THEME_ID_UNKNOWN, THEME_ID_LXX_LIGHT);
343        assertUpgradePlatformFromTo(
344                oldSdkVersion, newSdkVersion, THEME_ID_ILLEGAL, THEME_ID_LXX_LIGHT);
345    }
346}
347