diff options
Diffstat (limited to 'core/java/android/view/KeyCharacterMap.java')
-rw-r--r-- | core/java/android/view/KeyCharacterMap.java | 545 |
1 files changed, 545 insertions, 0 deletions
diff --git a/core/java/android/view/KeyCharacterMap.java b/core/java/android/view/KeyCharacterMap.java new file mode 100644 index 0000000..25958aa --- /dev/null +++ b/core/java/android/view/KeyCharacterMap.java @@ -0,0 +1,545 @@ +/* + * Copyright (C) 2007 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 android.view; + +import android.text.method.MetaKeyKeyListener; +import android.util.SparseIntArray; +import android.os.RemoteException; +import android.os.ServiceManager; +import android.os.SystemClock; +import android.util.SparseArray; + +import java.lang.Character; +import java.lang.ref.WeakReference; + +public class KeyCharacterMap +{ + /** + * The id of the device's primary built in keyboard is always 0. + */ + public static final int BUILT_IN_KEYBOARD = 0; + + /** A numeric (12-key) keyboard. */ + public static final int NUMERIC = 1; + + /** A keyboard with all the letters, but with more than one letter + * per key. */ + public static final int PREDICTIVE = 2; + + /** A keyboard with all the letters, and maybe some numbers. */ + public static final int ALPHA = 3; + + /** + * This private-use character is used to trigger Unicode character + * input by hex digits. + */ + public static final char HEX_INPUT = '\uEF00'; + + /** + * This private-use character is used to bring up a character picker for + * miscellaneous symbols. + */ + public static final char PICKER_DIALOG_INPUT = '\uEF01'; + + private static Object sLock = new Object(); + private static SparseArray<WeakReference<KeyCharacterMap>> sInstances + = new SparseArray<WeakReference<KeyCharacterMap>>(); + + public static KeyCharacterMap load(int keyboard) + { + synchronized (sLock) { + KeyCharacterMap result; + WeakReference<KeyCharacterMap> ref = sInstances.get(keyboard); + if (ref != null) { + result = ref.get(); + if (result != null) { + return result; + } + } + result = new KeyCharacterMap(keyboard); + sInstances.put(keyboard, new WeakReference<KeyCharacterMap>(result)); + return result; + } + } + + private KeyCharacterMap(int keyboardDevice) + { + mKeyboardDevice = keyboardDevice; + mPointer = ctor_native(keyboardDevice); + } + + /** + * <p> + * Returns the Unicode character that the specified key would produce + * when the specified meta bits (see {@link MetaKeyKeyListener}) + * were active. + * </p><p> + * Returns 0 if the key is not one that is used to type Unicode + * characters. + * </p><p> + * If the return value has bit {@link #COMBINING_ACCENT} set, the + * key is a "dead key" that should be combined with another to + * actually produce a character -- see {@link #getDeadChar} -- + * after masking with {@link #COMBINING_ACCENT_MASK}. + * </p> + */ + public int get(int keyCode, int meta) + { + if ((meta & MetaKeyKeyListener.META_CAP_LOCKED) != 0) { + meta |= KeyEvent.META_SHIFT_ON; + } + if ((meta & MetaKeyKeyListener.META_ALT_LOCKED) != 0) { + meta |= KeyEvent.META_ALT_ON; + } + + // Ignore caps lock on keys where alt and shift have the same effect. + if ((meta & MetaKeyKeyListener.META_CAP_LOCKED) != 0) { + if (get_native(mPointer, keyCode, KeyEvent.META_SHIFT_ON) == + get_native(mPointer, keyCode, KeyEvent.META_ALT_ON)) { + meta &= ~KeyEvent.META_SHIFT_ON; + } + } + + int ret = get_native(mPointer, keyCode, meta); + int map = COMBINING.get(ret); + + if (map != 0) { + return map; + } else { + return ret; + } + } + + /** + * Gets the number or symbol associated with the key. The character value + * is returned, not the numeric value. If the key is not a number, but is + * a symbol, the symbol is retuned. + */ + public char getNumber(int keyCode) + { + return getNumber_native(mPointer, keyCode); + } + + /** + * The same as {@link #getMatch(int,char[],int) getMatch(keyCode, chars, 0)}. + */ + public char getMatch(int keyCode, char[] chars) + { + return getMatch(keyCode, chars, 0); + } + + /** + * If one of the chars in the array can be generated by keyCode, + * return the char; otherwise return '\0'. + * @param keyCode the key code to look at + * @param chars the characters to try to find + * @param modifiers the modifier bits to prefer. If any of these bits + * are set, if there are multiple choices, that could + * work, the one for this modifier will be set. + */ + public char getMatch(int keyCode, char[] chars, int modifiers) + { + if (chars == null) { + // catch it here instead of in native + throw new NullPointerException(); + } + return getMatch_native(mPointer, keyCode, chars, modifiers); + } + + /** + * Get the primary character for this key. In other words, the label + * that is physically printed on it. + */ + public char getDisplayLabel(int keyCode) + { + return getDisplayLabel_native(mPointer, keyCode); + } + + /** + * Get the character that is produced by putting accent on the character + * c. + * For example, getDeadChar('`', 'e') returns è. + */ + public static int getDeadChar(int accent, int c) + { + return DEAD.get((accent << 16) | c); + } + + public static class KeyData { + public static final int META_LENGTH = 4; + + /** + * The display label (see {@link #getDisplayLabel}). + */ + public char displayLabel; + /** + * The "number" value (see {@link #getNumber}). + */ + public char number; + /** + * The character that will be generated in various meta states + * (the same ones used for {@link #get} and defined as + * {@link KeyEvent#META_SHIFT_ON} and {@link KeyEvent#META_ALT_ON}). + * <table> + * <tr><th>Index</th><th align="left">Value</th></tr> + * <tr><td>0</td><td>no modifiers</td></tr> + * <tr><td>1</td><td>caps</td></tr> + * <tr><td>2</td><td>alt</td></tr> + * <tr><td>3</td><td>caps + alt</td></tr> + * </table> + */ + public char[] meta = new char[META_LENGTH]; + } + + /** + * Get the characters conversion data for a given keyCode. + * + * @param keyCode the keyCode to look for + * @param results a {@link KeyData} that will be filled with the results. + * + * @return whether the key was mapped or not. If the key was not mapped, + * results is not modified. + */ + public boolean getKeyData(int keyCode, KeyData results) + { + if (results.meta.length >= KeyData.META_LENGTH) { + return getKeyData_native(mPointer, keyCode, results); + } else { + throw new IndexOutOfBoundsException("results.meta.length must be >= " + + KeyData.META_LENGTH); + } + } + + /** + * Get an array of KeyEvent objects that if put into the input stream + * could plausibly generate the provided sequence of characters. It is + * not guaranteed that the sequence is the only way to generate these + * events or that it is optimal. + * + * @return an array of KeyEvent objects, or null if the given char array + * can not be generated using the current key character map. + */ + public KeyEvent[] getEvents(char[] chars) + { + if (chars == null) { + throw new NullPointerException(); + } + + long[] keys = getEvents_native(mPointer, chars); + if (keys == null) { + return null; + } + + // how big should the array be + int len = keys.length*2; + int N = keys.length; + for (int i=0; i<N; i++) { + int mods = (int)(keys[i] >> 32); + if ((mods & KeyEvent.META_ALT_ON) != 0) { + len += 2; + } + if ((mods & KeyEvent.META_SHIFT_ON) != 0) { + len += 2; + } + if ((mods & KeyEvent.META_SYM_ON) != 0) { + len += 2; + } + } + + // create the events + KeyEvent[] rv = new KeyEvent[len]; + int index = 0; + long now = SystemClock.uptimeMillis(); + int device = mKeyboardDevice; + for (int i=0; i<N; i++) { + int mods = (int)(keys[i] >> 32); + int meta = 0; + + if ((mods & KeyEvent.META_ALT_ON) != 0) { + meta |= KeyEvent.META_ALT_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, + KeyEvent.KEYCODE_ALT_LEFT, 0, meta, device, 0); + index++; + } + if ((mods & KeyEvent.META_SHIFT_ON) != 0) { + meta |= KeyEvent.META_SHIFT_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, + KeyEvent.KEYCODE_SHIFT_LEFT, 0, meta, device, 0); + index++; + } + if ((mods & KeyEvent.META_SYM_ON) != 0) { + meta |= KeyEvent.META_SYM_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, + KeyEvent.KEYCODE_SYM, 0, meta, device, 0); + index++; + } + + int key = (int)(keys[i]); + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_DOWN, + key, 0, meta, device, 0); + index++; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP, + key, 0, meta, device, 0); + index++; + + if ((mods & KeyEvent.META_ALT_ON) != 0) { + meta &= ~KeyEvent.META_ALT_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP, + KeyEvent.KEYCODE_ALT_LEFT, 0, meta, device, 0); + index++; + } + if ((mods & KeyEvent.META_SHIFT_ON) != 0) { + meta &= ~KeyEvent.META_SHIFT_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP, + KeyEvent.KEYCODE_SHIFT_LEFT, 0, meta, device, 0); + index++; + } + if ((mods & KeyEvent.META_SYM_ON) != 0) { + meta &= ~KeyEvent.META_SYM_ON; + rv[index] = new KeyEvent(now, now, KeyEvent.ACTION_UP, + KeyEvent.KEYCODE_SYM, 0, meta, device, 0); + index++; + } + } + + return rv; + } + + /** + * Does this character key produce a glyph? + */ + public boolean isPrintingKey(int keyCode) + { + int type = Character.getType(get(keyCode, 0)); + + switch (type) + { + case Character.SPACE_SEPARATOR: + case Character.LINE_SEPARATOR: + case Character.PARAGRAPH_SEPARATOR: + case Character.CONTROL: + case Character.FORMAT: + return false; + default: + return true; + } + } + + protected void finalize() throws Throwable + { + dtor_native(mPointer); + } + + /** + * Returns {@link #NUMERIC}, {@link #PREDICTIVE} or {@link #ALPHA}. + */ + public int getKeyboardType() + { + return getKeyboardType_native(mPointer); + } + + /** + * Queries the framework about whether any physical keys exist on the + * device that are capable of producing the given key codes. + */ + public static boolean deviceHasKey(int keyCode) { + int[] codeArray = new int[1]; + codeArray[0] = keyCode; + boolean[] ret = deviceHasKeys(codeArray); + return ret[0]; + } + + public static boolean[] deviceHasKeys(int[] keyCodes) { + boolean[] ret = new boolean[keyCodes.length]; + IWindowManager wm = IWindowManager.Stub.asInterface(ServiceManager.getService("window")); + try { + wm.hasKeys(keyCodes, ret); + } catch (RemoteException e) { + // no fallback; just return the empty array + } + return ret; + } + + private int mPointer; + private int mKeyboardDevice; + + private static native int ctor_native(int id); + private static native void dtor_native(int ptr); + private static native char get_native(int ptr, int keycode, + int meta); + private static native char getNumber_native(int ptr, int keycode); + private static native char getMatch_native(int ptr, int keycode, + char[] chars, int modifiers); + private static native char getDisplayLabel_native(int ptr, int keycode); + private static native boolean getKeyData_native(int ptr, int keycode, + KeyData results); + private static native int getKeyboardType_native(int ptr); + private static native long[] getEvents_native(int ptr, char[] str); + + /** + * Maps Unicode combining diacritical to display-form dead key + * (display character shifted left 16 bits). + */ + private static SparseIntArray COMBINING = new SparseIntArray(); + + /** + * Maps combinations of (display-form) dead key and second character + * to combined output character. + */ + private static SparseIntArray DEAD = new SparseIntArray(); + + /* + * TODO: Change the table format to support full 21-bit-wide + * accent characters and combined characters if ever necessary. + */ + private static final int ACUTE = '\u00B4' << 16; + private static final int GRAVE = '`' << 16; + private static final int CIRCUMFLEX = '^' << 16; + private static final int TILDE = '~' << 16; + private static final int UMLAUT = '\u00A8' << 16; + + /* + * This bit will be set in the return value of {@link #get(int, int)} if the + * key is a "dead key." + */ + public static final int COMBINING_ACCENT = 0x80000000; + /** + * Mask the return value from {@link #get(int, int)} with this value to get + * a printable representation of the accent character of a "dead key." + */ + public static final int COMBINING_ACCENT_MASK = 0x7FFFFFFF; + + static { + COMBINING.put('\u0300', (GRAVE >> 16) | COMBINING_ACCENT); + COMBINING.put('\u0301', (ACUTE >> 16) | COMBINING_ACCENT); + COMBINING.put('\u0302', (CIRCUMFLEX >> 16) | COMBINING_ACCENT); + COMBINING.put('\u0303', (TILDE >> 16) | COMBINING_ACCENT); + COMBINING.put('\u0308', (UMLAUT >> 16) | COMBINING_ACCENT); + + DEAD.put(ACUTE | 'A', '\u00C1'); + DEAD.put(ACUTE | 'C', '\u0106'); + DEAD.put(ACUTE | 'E', '\u00C9'); + DEAD.put(ACUTE | 'G', '\u01F4'); + DEAD.put(ACUTE | 'I', '\u00CD'); + DEAD.put(ACUTE | 'K', '\u1E30'); + DEAD.put(ACUTE | 'L', '\u0139'); + DEAD.put(ACUTE | 'M', '\u1E3E'); + DEAD.put(ACUTE | 'N', '\u0143'); + DEAD.put(ACUTE | 'O', '\u00D3'); + DEAD.put(ACUTE | 'P', '\u1E54'); + DEAD.put(ACUTE | 'R', '\u0154'); + DEAD.put(ACUTE | 'S', '\u015A'); + DEAD.put(ACUTE | 'U', '\u00DA'); + DEAD.put(ACUTE | 'W', '\u1E82'); + DEAD.put(ACUTE | 'Y', '\u00DD'); + DEAD.put(ACUTE | 'Z', '\u0179'); + DEAD.put(ACUTE | 'a', '\u00E1'); + DEAD.put(ACUTE | 'c', '\u0107'); + DEAD.put(ACUTE | 'e', '\u00E9'); + DEAD.put(ACUTE | 'g', '\u01F5'); + DEAD.put(ACUTE | 'i', '\u00ED'); + DEAD.put(ACUTE | 'k', '\u1E31'); + DEAD.put(ACUTE | 'l', '\u013A'); + DEAD.put(ACUTE | 'm', '\u1E3F'); + DEAD.put(ACUTE | 'n', '\u0144'); + DEAD.put(ACUTE | 'o', '\u00F3'); + DEAD.put(ACUTE | 'p', '\u1E55'); + DEAD.put(ACUTE | 'r', '\u0155'); + DEAD.put(ACUTE | 's', '\u015B'); + DEAD.put(ACUTE | 'u', '\u00FA'); + DEAD.put(ACUTE | 'w', '\u1E83'); + DEAD.put(ACUTE | 'y', '\u00FD'); + DEAD.put(ACUTE | 'z', '\u017A'); + DEAD.put(CIRCUMFLEX | 'A', '\u00C2'); + DEAD.put(CIRCUMFLEX | 'C', '\u0108'); + DEAD.put(CIRCUMFLEX | 'E', '\u00CA'); + DEAD.put(CIRCUMFLEX | 'G', '\u011C'); + DEAD.put(CIRCUMFLEX | 'H', '\u0124'); + DEAD.put(CIRCUMFLEX | 'I', '\u00CE'); + DEAD.put(CIRCUMFLEX | 'J', '\u0134'); + DEAD.put(CIRCUMFLEX | 'O', '\u00D4'); + DEAD.put(CIRCUMFLEX | 'S', '\u015C'); + DEAD.put(CIRCUMFLEX | 'U', '\u00DB'); + DEAD.put(CIRCUMFLEX | 'W', '\u0174'); + DEAD.put(CIRCUMFLEX | 'Y', '\u0176'); + DEAD.put(CIRCUMFLEX | 'Z', '\u1E90'); + DEAD.put(CIRCUMFLEX | 'a', '\u00E2'); + DEAD.put(CIRCUMFLEX | 'c', '\u0109'); + DEAD.put(CIRCUMFLEX | 'e', '\u00EA'); + DEAD.put(CIRCUMFLEX | 'g', '\u011D'); + DEAD.put(CIRCUMFLEX | 'h', '\u0125'); + DEAD.put(CIRCUMFLEX | 'i', '\u00EE'); + DEAD.put(CIRCUMFLEX | 'j', '\u0135'); + DEAD.put(CIRCUMFLEX | 'o', '\u00F4'); + DEAD.put(CIRCUMFLEX | 's', '\u015D'); + DEAD.put(CIRCUMFLEX | 'u', '\u00FB'); + DEAD.put(CIRCUMFLEX | 'w', '\u0175'); + DEAD.put(CIRCUMFLEX | 'y', '\u0177'); + DEAD.put(CIRCUMFLEX | 'z', '\u1E91'); + DEAD.put(GRAVE | 'A', '\u00C0'); + DEAD.put(GRAVE | 'E', '\u00C8'); + DEAD.put(GRAVE | 'I', '\u00CC'); + DEAD.put(GRAVE | 'N', '\u01F8'); + DEAD.put(GRAVE | 'O', '\u00D2'); + DEAD.put(GRAVE | 'U', '\u00D9'); + DEAD.put(GRAVE | 'W', '\u1E80'); + DEAD.put(GRAVE | 'Y', '\u1EF2'); + DEAD.put(GRAVE | 'a', '\u00E0'); + DEAD.put(GRAVE | 'e', '\u00E8'); + DEAD.put(GRAVE | 'i', '\u00EC'); + DEAD.put(GRAVE | 'n', '\u01F9'); + DEAD.put(GRAVE | 'o', '\u00F2'); + DEAD.put(GRAVE | 'u', '\u00F9'); + DEAD.put(GRAVE | 'w', '\u1E81'); + DEAD.put(GRAVE | 'y', '\u1EF3'); + DEAD.put(TILDE | 'A', '\u00C3'); + DEAD.put(TILDE | 'E', '\u1EBC'); + DEAD.put(TILDE | 'I', '\u0128'); + DEAD.put(TILDE | 'N', '\u00D1'); + DEAD.put(TILDE | 'O', '\u00D5'); + DEAD.put(TILDE | 'U', '\u0168'); + DEAD.put(TILDE | 'V', '\u1E7C'); + DEAD.put(TILDE | 'Y', '\u1EF8'); + DEAD.put(TILDE | 'a', '\u00E3'); + DEAD.put(TILDE | 'e', '\u1EBD'); + DEAD.put(TILDE | 'i', '\u0129'); + DEAD.put(TILDE | 'n', '\u00F1'); + DEAD.put(TILDE | 'o', '\u00F5'); + DEAD.put(TILDE | 'u', '\u0169'); + DEAD.put(TILDE | 'v', '\u1E7D'); + DEAD.put(TILDE | 'y', '\u1EF9'); + DEAD.put(UMLAUT | 'A', '\u00C4'); + DEAD.put(UMLAUT | 'E', '\u00CB'); + DEAD.put(UMLAUT | 'H', '\u1E26'); + DEAD.put(UMLAUT | 'I', '\u00CF'); + DEAD.put(UMLAUT | 'O', '\u00D6'); + DEAD.put(UMLAUT | 'U', '\u00DC'); + DEAD.put(UMLAUT | 'W', '\u1E84'); + DEAD.put(UMLAUT | 'X', '\u1E8C'); + DEAD.put(UMLAUT | 'Y', '\u0178'); + DEAD.put(UMLAUT | 'a', '\u00E4'); + DEAD.put(UMLAUT | 'e', '\u00EB'); + DEAD.put(UMLAUT | 'h', '\u1E27'); + DEAD.put(UMLAUT | 'i', '\u00EF'); + DEAD.put(UMLAUT | 'o', '\u00F6'); + DEAD.put(UMLAUT | 't', '\u1E97'); + DEAD.put(UMLAUT | 'u', '\u00FC'); + DEAD.put(UMLAUT | 'w', '\u1E85'); + DEAD.put(UMLAUT | 'x', '\u1E8D'); + DEAD.put(UMLAUT | 'y', '\u00FF'); + } +} |