ScriptUtils.java revision 7c5cd5ec89c0d90c3dbac032c61ee04468ecdc87
1/*
2 * Copyright (C) 2012 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.latin.utils;
18
19import java.util.Locale;
20import java.util.TreeMap;
21
22/**
23 * A class to help with handling different writing scripts.
24 */
25public class ScriptUtils {
26    // Used for hardware keyboards
27    public static final int SCRIPT_UNKNOWN = -1;
28    // TODO: should we use ISO 15924 identifiers instead?
29    public static final int SCRIPT_LATIN = 0;
30    public static final int SCRIPT_CYRILLIC = 1;
31    public static final int SCRIPT_GREEK = 2;
32    public static final int SCRIPT_ARABIC = 3;
33    public static final int SCRIPT_HEBREW = 4;
34    public static final int SCRIPT_ARMENIAN = 5;
35    public static final int SCRIPT_GEORGIAN = 6;
36    public static final int SCRIPT_KHMER = 7;
37    public static final int SCRIPT_LAO = 8;
38    public static final int SCRIPT_MYANMAR = 9;
39    public static final int SCRIPT_SINHALA = 10;
40    public static final int SCRIPT_THAI = 11;
41    public static final int SCRIPT_TELUGU = 12;
42    public static final TreeMap<String, Integer> mSpellCheckerLanguageToScript;
43    static {
44        // List of the supported languages and their associated script. We won't check
45        // words written in another script than the selected script, because we know we
46        // don't have those in our dictionary so we will underline everything and we
47        // will never have any suggestions, so it makes no sense checking them, and this
48        // is done in {@link #shouldFilterOut}. Also, the script is used to choose which
49        // proximity to pass to the dictionary descent algorithm.
50        // IMPORTANT: this only contains languages - do not write countries in there.
51        // Only the language is searched from the map.
52        mSpellCheckerLanguageToScript = new TreeMap<>();
53        mSpellCheckerLanguageToScript.put("cs", SCRIPT_LATIN);
54        mSpellCheckerLanguageToScript.put("da", SCRIPT_LATIN);
55        mSpellCheckerLanguageToScript.put("de", SCRIPT_LATIN);
56        mSpellCheckerLanguageToScript.put("el", SCRIPT_GREEK);
57        mSpellCheckerLanguageToScript.put("en", SCRIPT_LATIN);
58        mSpellCheckerLanguageToScript.put("es", SCRIPT_LATIN);
59        mSpellCheckerLanguageToScript.put("fi", SCRIPT_LATIN);
60        mSpellCheckerLanguageToScript.put("fr", SCRIPT_LATIN);
61        mSpellCheckerLanguageToScript.put("hr", SCRIPT_LATIN);
62        mSpellCheckerLanguageToScript.put("it", SCRIPT_LATIN);
63        mSpellCheckerLanguageToScript.put("lt", SCRIPT_LATIN);
64        mSpellCheckerLanguageToScript.put("lv", SCRIPT_LATIN);
65        mSpellCheckerLanguageToScript.put("nb", SCRIPT_LATIN);
66        mSpellCheckerLanguageToScript.put("nl", SCRIPT_LATIN);
67        mSpellCheckerLanguageToScript.put("pt", SCRIPT_LATIN);
68        mSpellCheckerLanguageToScript.put("sl", SCRIPT_LATIN);
69        mSpellCheckerLanguageToScript.put("ru", SCRIPT_CYRILLIC);
70    }
71    /*
72     * Returns whether the code point is a letter that makes sense for the specified
73     * locale for this spell checker.
74     * The dictionaries supported by Latin IME are described in res/xml/spellchecker.xml
75     * and is limited to EFIGS languages and Russian.
76     * Hence at the moment this explicitly tests for Cyrillic characters or Latin characters
77     * as appropriate, and explicitly excludes CJK, Arabic and Hebrew characters.
78     */
79    public static boolean isLetterPartOfScript(final int codePoint, final int scriptId) {
80        switch (scriptId) {
81        case SCRIPT_LATIN:
82            // Our supported latin script dictionaries (EFIGS) at the moment only include
83            // characters in the C0, C1, Latin Extended A and B, IPA extensions unicode
84            // blocks. As it happens, those are back-to-back in the code range 0x40 to 0x2AF,
85            // so the below is a very efficient way to test for it. As for the 0-0x3F, it's
86            // excluded from isLetter anyway.
87            return codePoint <= 0x2AF && Character.isLetter(codePoint);
88        case SCRIPT_CYRILLIC:
89            // All Cyrillic characters are in the 400~52F block. There are some in the upper
90            // Unicode range, but they are archaic characters that are not used in modern
91            // Russian and are not used by our dictionary.
92            return codePoint >= 0x400 && codePoint <= 0x52F && Character.isLetter(codePoint);
93        case SCRIPT_GREEK:
94            // Greek letters are either in the 370~3FF range (Greek & Coptic), or in the
95            // 1F00~1FFF range (Greek extended). Our dictionary contains both sort of characters.
96            // Our dictionary also contains a few words with 0xF2; it would be best to check
97            // if that's correct, but a web search does return results for these words so
98            // they are probably okay.
99            return (codePoint >= 0x370 && codePoint <= 0x3FF)
100                    || (codePoint >= 0x1F00 && codePoint <= 0x1FFF)
101                    || codePoint == 0xF2;
102        case SCRIPT_ARABIC:
103            // Arabic letters can be in any of the following blocks:
104            // Arabic U+0600..U+06FF
105            // Arabic Supplement U+0750..U+077F
106            // Arabic Extended-A U+08A0..U+08FF
107            // Arabic Presentation Forms-A U+FB50..U+FDFF
108            // Arabic Presentation Forms-B U+FE70..U+FEFF
109            return (codePoint >= 0x600 && codePoint <= 0x6FF)
110                    || (codePoint >= 0x750 && codePoint <= 0x77F)
111                    || (codePoint >= 0x8A0 && codePoint <= 0x8FF)
112                    || (codePoint >= 0xFB50 && codePoint <= 0xFDFF)
113                    || (codePoint >= 0xFE70 && codePoint <= 0xFEFF);
114        case SCRIPT_HEBREW:
115            // Hebrew letters are in the Hebrew unicode block, which spans from U+0590 to U+05FF,
116            // or in the Alphabetic Presentation Forms block, U+FB00..U+FB4F, but only in the
117            // Hebrew part of that block, which is U+FB1D..U+FB4F.
118            return (codePoint >= 0x590 && codePoint <= 0x5FF
119                    || codePoint >= 0xFB1D && codePoint <= 0xFB4F);
120        case SCRIPT_ARMENIAN:
121            // Armenian letters are in the Armenian unicode block, U+0530..U+058F and
122            // Alphabetic Presentation Forms block, U+FB00..U+FB4F, but only in the Armenian part
123            // of that block, which is U+FB13..U+FB17.
124            return (codePoint >= 0x530 && codePoint <= 0x58F
125                    || codePoint >= 0xFB13 && codePoint <= 0xFB17);
126        case SCRIPT_GEORGIAN:
127            // Georgian letters are in the Georgian unicode block, U+10A0..U+10FF,
128            // or Georgian supplement block, U+2D00..U+2D2F
129            return (codePoint >= 0x10A0 && codePoint <= 0x10FF
130                    || codePoint >= 0x2D00 && codePoint <= 0x2D2F);
131        case SCRIPT_KHMER:
132            // Khmer letters are in unicode block U+1780..U+17FF, and the Khmer symbols block
133            // is U+19E0..U+19FF
134            return (codePoint >= 0x1780 && codePoint <= 0x17FF
135                    || codePoint >= 0x19E0 && codePoint <= 0x19FF);
136        case SCRIPT_LAO:
137            // The Lao block is U+0E80..U+0EFF
138            return (codePoint >= 0xE80 && codePoint <= 0xEFF);
139        case SCRIPT_MYANMAR:
140            // Myanmar has three unicode blocks :
141            // Myanmar U+1000..U+109F
142            // Myanmar extended-A U+AA60..U+AA7F
143            // Myanmar extended-B U+A9E0..U+A9FF
144            return (codePoint >= 0x1000 && codePoint <= 0x109F
145                    || codePoint >= 0xAA60 && codePoint <= 0xAA7F
146                    || codePoint >= 0xA9E0 && codePoint <= 0xA9FF);
147        case SCRIPT_SINHALA:
148            // Sinhala unicode block is U+0D80..U+0DFF
149            return (codePoint >= 0xD80 && codePoint <= 0xDFF);
150        case SCRIPT_THAI:
151            // Thai unicode block is U+0E00..U+0E7F
152            return (codePoint >= 0xE00 && codePoint <= 0xE7F);
153        case SCRIPT_TELUGU:
154            // Telugu unicode block is U+0C00..U+0C7F
155            return (codePoint >= 0xC00 && codePoint <= 0xC7F);
156        case SCRIPT_UNKNOWN:
157            return true;
158        default:
159            // Should never come here
160            throw new RuntimeException("Impossible value of script: " + scriptId);
161        }
162    }
163
164    public static int getScriptFromSpellCheckerLocale(final Locale locale) {
165        final Integer script = mSpellCheckerLanguageToScript.get(locale.getLanguage());
166        if (null == script) {
167            throw new RuntimeException("We have been called with an unsupported language: \""
168                    + locale.getLanguage() + "\". Framework bug?");
169        }
170        return script;
171    }
172}
173