| /* |
| * Copyright (C) 2009 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.pinyin; |
| |
| import com.android.inputmethod.pinyin.SoftKeyboard.KeyRow; |
| |
| import android.content.Context; |
| import android.content.res.Resources; |
| import android.content.res.XmlResourceParser; |
| import android.graphics.drawable.Drawable; |
| |
| import java.io.IOException; |
| import java.util.regex.Pattern; |
| |
| import org.xmlpull.v1.XmlPullParserException; |
| |
| /** |
| * Class used to load a soft keyboard or a soft keyboard template from xml |
| * files. |
| */ |
| public class XmlKeyboardLoader { |
| /** |
| * The tag used to define an xml-based soft keyboard template. |
| */ |
| private static final String XMLTAG_SKB_TEMPLATE = "skb_template"; |
| |
| /** |
| * The tag used to indicate the soft key type which is defined inside the |
| * {@link #XMLTAG_SKB_TEMPLATE} element in the xml file. file. |
| */ |
| private static final String XMLTAG_KEYTYPE = "key_type"; |
| |
| /** |
| * The tag used to define a default key icon for enter/delete/space keys. It |
| * is defined inside the {@link #XMLTAG_SKB_TEMPLATE} element in the xml |
| * file. |
| */ |
| private static final String XMLTAG_KEYICON = "key_icon"; |
| |
| /** |
| * Attribute tag of the left and right margin for a key. A key's width |
| * should be larger than double of this value. Defined inside |
| * {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYBOARD}. |
| */ |
| private static final String XMLATTR_KEY_XMARGIN = "key_xmargin"; |
| |
| /** |
| * Attribute tag of the top and bottom margin for a key. A key's height |
| * should be larger than double of this value. Defined inside |
| * {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYBOARD}. |
| */ |
| private static final String XMLATTR_KEY_YMARGIN = "key_ymargin"; |
| |
| /** |
| * Attribute tag of the keyboard background image. Defined inside |
| * {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYBOARD}. |
| */ |
| private static final String XMLATTR_SKB_BG = "skb_bg"; |
| |
| /** |
| * Attribute tag of the balloon background image for key press. Defined |
| * inside {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYBOARD}. |
| */ |
| private static final String XMLATTR_BALLOON_BG = "balloon_bg"; |
| |
| /** |
| * Attribute tag of the popup balloon background image for key press or |
| * popup mini keyboard. Defined inside {@link #XMLTAG_SKB_TEMPLATE} and |
| * {@link #XMLTAG_KEYBOARD}. |
| */ |
| private static final String XMLATTR_POPUP_BG = "popup_bg"; |
| |
| /** |
| * Attribute tag of the color to draw key label. Defined inside |
| * {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYTYPE}. |
| */ |
| private static final String XMLATTR_COLOR = "color"; |
| |
| /** |
| * Attribute tag of the color to draw key's highlighted label. Defined |
| * inside {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYTYPE}. |
| */ |
| private static final String XMLATTR_COLOR_HIGHLIGHT = "color_highlight"; |
| |
| /** |
| * Attribute tag of the color to draw key's label in the popup balloon. |
| * Defined inside {@link #XMLTAG_SKB_TEMPLATE} and {@link #XMLTAG_KEYTYPE}. |
| */ |
| private static final String XMLATTR_COLOR_BALLOON = "color_balloon"; |
| |
| /** |
| * Attribute tag of the id of {@link #XMLTAG_KEYTYPE} and |
| * {@link #XMLTAG_KEY}. Key types and keys defined in a soft keyboard |
| * template should have id, because a soft keyboard needs the id to refer to |
| * these default definitions. If a key defined in {@link #XMLTAG_KEYBOARD} |
| * does not id, that means the key is newly defined; if it has id (and only |
| * has id), the id is used to find the default definition from the soft |
| * keyboard template. |
| */ |
| private static final String XMLATTR_ID = "id"; |
| |
| /** |
| * Attribute tag of the key background for a specified key type. Defined |
| * inside {@link #XMLTAG_KEYTYPE}. |
| */ |
| private static final String XMLATTR_KEYTYPE_BG = "bg"; |
| |
| /** |
| * Attribute tag of the key high-light background for a specified key type. |
| * Defined inside {@link #XMLTAG_KEYTYPE}. |
| */ |
| private static final String XMLATTR_KEYTYPE_HLBG = "hlbg"; |
| |
| /** |
| * Attribute tag of the starting x-position of an element. It can be defined |
| * in {@link #XMLTAG_ROW} and {@link #XMLTAG_KEY} in {XMLTAG_SKB_TEMPLATE}. |
| * If not defined, 0 will be used. For a key defined in |
| * {@link #XMLTAG_KEYBOARD}, it always use its previous keys information to |
| * calculate its own position. |
| */ |
| private static final String XMLATTR_START_POS_X = "start_pos_x"; |
| |
| /** |
| * Attribute tag of the starting y-position of an element. It can be defined |
| * in {@link #XMLTAG_ROW} and {@link #XMLTAG_KEY} in {XMLTAG_SKB_TEMPLATE}. |
| * If not defined, 0 will be used. For a key defined in |
| * {@link #XMLTAG_KEYBOARD}, it always use its previous keys information to |
| * calculate its own position. |
| */ |
| private static final String XMLATTR_START_POS_Y = "start_pos_y"; |
| |
| /** |
| * Attribute tag of a row's id. Defined {@link #XMLTAG_ROW}. If not defined, |
| * -1 will be used. Rows with id -1 will be enabled always, rows with same |
| * row id will be enabled when the id is the same to the activated id of the |
| * soft keyboard. |
| */ |
| private static final String XMLATTR_ROW_ID = "row_id"; |
| |
| /** The tag used to indicate the keyboard element in the xml file. */ |
| private static final String XMLTAG_KEYBOARD = "keyboard"; |
| |
| /** The tag used to indicate the row element in the xml file. */ |
| private static final String XMLTAG_ROW = "row"; |
| |
| /** The tag used to indicate key-array element in the xml file. */ |
| private static final String XMLTAG_KEYS = "keys"; |
| |
| /** |
| * The tag used to indicate a key element in the xml file. If the element is |
| * defined in a soft keyboard template, it should have an id. If it is |
| * defined in a soft keyboard, id is not required. |
| */ |
| private static final String XMLTAG_KEY = "key"; |
| |
| /** The tag used to indicate a key's toggle element in the xml file. */ |
| private static final String XMLTAG_TOGGLE_STATE = "toggle_state"; |
| |
| /** |
| * Attribute tag of the toggle state id for toggle key. Defined inside |
| * {@link #XMLTAG_TOGGLE_STATE} |
| */ |
| private static final String XMLATTR_TOGGLE_STATE_ID = "state_id"; |
| |
| /** Attribute tag of key template for the soft keyboard. */ |
| private static final String XMLATTR_SKB_TEMPLATE = "skb_template"; |
| |
| /** |
| * Attribute tag used to indicate whether this soft keyboard needs to be |
| * cached in memory for future use. {@link #DEFAULT_SKB_CACHE_FLAG} |
| * specifies the default value. |
| */ |
| private static final String XMLATTR_SKB_CACHE_FLAG = "skb_cache_flag"; |
| |
| /** |
| * Attribute tag used to indicate whether this soft keyboard is sticky. A |
| * sticky soft keyboard will keep the current layout unless user makes a |
| * switch explicitly. A none sticky soft keyboard will automatically goes |
| * back to the previous keyboard after click a none-function key. |
| * {@link #DEFAULT_SKB_STICKY_FLAG} specifies the default value. |
| */ |
| private static final String XMLATTR_SKB_STICKY_FLAG = "skb_sticky_flag"; |
| |
| /** Attribute tag to indicate whether it is a QWERTY soft keyboard. */ |
| private static final String XMLATTR_QWERTY = "qwerty"; |
| |
| /** |
| * When the soft keyboard is a QWERTY one, this attribute tag to get the |
| * information that whether it is defined in upper case. |
| */ |
| private static final String XMLATTR_QWERTY_UPPERCASE = "qwerty_uppercase"; |
| |
| /** Attribute tag of key type. */ |
| private static final String XMLATTR_KEY_TYPE = "key_type"; |
| |
| /** Attribute tag of key width. */ |
| private static final String XMLATTR_KEY_WIDTH = "width"; |
| |
| /** Attribute tag of key height. */ |
| private static final String XMLATTR_KEY_HEIGHT = "height"; |
| |
| /** Attribute tag of the key's repeating ability. */ |
| private static final String XMLATTR_KEY_REPEAT = "repeat"; |
| |
| /** Attribute tag of the key's behavior for balloon. */ |
| private static final String XMLATTR_KEY_BALLOON = "balloon"; |
| |
| /** Attribute tag of the key splitter in a key array. */ |
| private static final String XMLATTR_KEY_SPLITTER = "splitter"; |
| |
| /** Attribute tag of the key labels in a key array. */ |
| private static final String XMLATTR_KEY_LABELS = "labels"; |
| |
| /** Attribute tag of the key codes in a key array. */ |
| private static final String XMLATTR_KEY_CODES = "codes"; |
| |
| /** Attribute tag of the key label in a key. */ |
| private static final String XMLATTR_KEY_LABEL = "label"; |
| |
| /** Attribute tag of the key code in a key. */ |
| private static final String XMLATTR_KEY_CODE = "code"; |
| |
| /** Attribute tag of the key icon in a key. */ |
| private static final String XMLATTR_KEY_ICON = "icon"; |
| |
| /** Attribute tag of the key's popup icon in a key. */ |
| private static final String XMLATTR_KEY_ICON_POPUP = "icon_popup"; |
| |
| /** The id for a mini popup soft keyboard. */ |
| private static final String XMLATTR_KEY_POPUP_SKBID = "popup_skb"; |
| |
| private static boolean DEFAULT_SKB_CACHE_FLAG = true; |
| |
| private static boolean DEFAULT_SKB_STICKY_FLAG = true; |
| |
| /** |
| * The key type id for invalid key type. It is also used to generate next |
| * valid key type id by adding 1. |
| */ |
| private static final int KEYTYPE_ID_LAST = -1; |
| |
| private Context mContext; |
| |
| private Resources mResources; |
| |
| /** The event type in parsing the xml file. */ |
| private int mXmlEventType; |
| |
| /** |
| * The current soft keyboard template used by the current soft keyboard |
| * under loading. |
| **/ |
| private SkbTemplate mSkbTemplate; |
| |
| /** The x position for the next key. */ |
| float mKeyXPos; |
| |
| /** The y position for the next key. */ |
| float mKeyYPos; |
| |
| /** The width of the keyboard to load. */ |
| int mSkbWidth; |
| |
| /** The height of the keyboard to load. */ |
| int mSkbHeight; |
| |
| /** Key margin in x-way. */ |
| float mKeyXMargin = 0; |
| |
| /** Key margin in y-way. */ |
| float mKeyYMargin = 0; |
| |
| /** |
| * Used to indicate whether next event has been fetched during processing |
| * the the current event. |
| */ |
| boolean mNextEventFetched = false; |
| |
| String mAttrTmp; |
| |
| class KeyCommonAttributes { |
| XmlResourceParser mXrp; |
| int keyType; |
| float keyWidth; |
| float keyHeight; |
| boolean repeat; |
| boolean balloon; |
| |
| KeyCommonAttributes(XmlResourceParser xrp) { |
| mXrp = xrp; |
| balloon = true; |
| } |
| |
| // Make sure the default object is not null. |
| boolean getAttributes(KeyCommonAttributes defAttr) { |
| keyType = getInteger(mXrp, XMLATTR_KEY_TYPE, defAttr.keyType); |
| keyWidth = getFloat(mXrp, XMLATTR_KEY_WIDTH, defAttr.keyWidth); |
| keyHeight = getFloat(mXrp, XMLATTR_KEY_HEIGHT, defAttr.keyHeight); |
| repeat = getBoolean(mXrp, XMLATTR_KEY_REPEAT, defAttr.repeat); |
| balloon = getBoolean(mXrp, XMLATTR_KEY_BALLOON, defAttr.balloon); |
| if (keyType < 0 || keyWidth <= 0 || keyHeight <= 0) { |
| return false; |
| } |
| return true; |
| } |
| } |
| |
| public XmlKeyboardLoader(Context context) { |
| mContext = context; |
| mResources = mContext.getResources(); |
| } |
| |
| public SkbTemplate loadSkbTemplate(int resourceId) { |
| if (null == mContext || 0 == resourceId) { |
| return null; |
| } |
| Resources r = mResources; |
| XmlResourceParser xrp = r.getXml(resourceId); |
| |
| KeyCommonAttributes attrDef = new KeyCommonAttributes(xrp); |
| KeyCommonAttributes attrKey = new KeyCommonAttributes(xrp); |
| |
| mSkbTemplate = new SkbTemplate(resourceId); |
| int lastKeyTypeId = KEYTYPE_ID_LAST; |
| int globalColor = 0; |
| int globalColorHl = 0; |
| int globalColorBalloon = 0; |
| try { |
| mXmlEventType = xrp.next(); |
| while (mXmlEventType != XmlResourceParser.END_DOCUMENT) { |
| mNextEventFetched = false; |
| if (mXmlEventType == XmlResourceParser.START_TAG) { |
| String attribute = xrp.getName(); |
| if (XMLTAG_SKB_TEMPLATE.compareTo(attribute) == 0) { |
| Drawable skbBg = getDrawable(xrp, XMLATTR_SKB_BG, null); |
| Drawable balloonBg = getDrawable(xrp, |
| XMLATTR_BALLOON_BG, null); |
| Drawable popupBg = getDrawable(xrp, XMLATTR_POPUP_BG, |
| null); |
| if (null == skbBg || null == balloonBg |
| || null == popupBg) { |
| return null; |
| } |
| mSkbTemplate.setBackgrounds(skbBg, balloonBg, popupBg); |
| |
| float xMargin = getFloat(xrp, XMLATTR_KEY_XMARGIN, 0); |
| float yMargin = getFloat(xrp, XMLATTR_KEY_YMARGIN, 0); |
| mSkbTemplate.setMargins(xMargin, yMargin); |
| |
| // Get default global colors. |
| globalColor = getColor(xrp, XMLATTR_COLOR, 0); |
| globalColorHl = getColor(xrp, XMLATTR_COLOR_HIGHLIGHT, |
| 0xffffffff); |
| globalColorBalloon = getColor(xrp, |
| XMLATTR_COLOR_BALLOON, 0xffffffff); |
| } else if (XMLTAG_KEYTYPE.compareTo(attribute) == 0) { |
| int id = getInteger(xrp, XMLATTR_ID, KEYTYPE_ID_LAST); |
| Drawable bg = getDrawable(xrp, XMLATTR_KEYTYPE_BG, null); |
| Drawable hlBg = getDrawable(xrp, XMLATTR_KEYTYPE_HLBG, |
| null); |
| int color = getColor(xrp, XMLATTR_COLOR, globalColor); |
| int colorHl = getColor(xrp, XMLATTR_COLOR_HIGHLIGHT, |
| globalColorHl); |
| int colorBalloon = getColor(xrp, XMLATTR_COLOR_BALLOON, |
| globalColorBalloon); |
| if (id != lastKeyTypeId + 1) { |
| return null; |
| } |
| SoftKeyType keyType = mSkbTemplate.createKeyType(id, |
| bg, hlBg); |
| keyType.setColors(color, colorHl, colorBalloon); |
| if (!mSkbTemplate.addKeyType(keyType)) { |
| return null; |
| } |
| lastKeyTypeId = id; |
| } else if (XMLTAG_KEYICON.compareTo(attribute) == 0) { |
| int keyCode = getInteger(xrp, XMLATTR_KEY_CODE, 0); |
| Drawable icon = getDrawable(xrp, XMLATTR_KEY_ICON, null); |
| Drawable iconPopup = getDrawable(xrp, |
| XMLATTR_KEY_ICON_POPUP, null); |
| if (null != icon && null != iconPopup) { |
| mSkbTemplate.addDefaultKeyIcons(keyCode, icon, |
| iconPopup); |
| } |
| } else if (XMLTAG_KEY.compareTo(attribute) == 0) { |
| int keyId = this.getInteger(xrp, XMLATTR_ID, -1); |
| if (-1 == keyId) return null; |
| |
| if (!attrKey.getAttributes(attrDef)) { |
| return null; |
| } |
| |
| // Update the key position for the key. |
| mKeyXPos = getFloat(xrp, XMLATTR_START_POS_X, 0); |
| mKeyYPos = getFloat(xrp, XMLATTR_START_POS_Y, 0); |
| |
| SoftKey softKey = getSoftKey(xrp, attrKey); |
| if (null == softKey) return null; |
| mSkbTemplate.addDefaultKey(keyId, softKey); |
| } |
| } |
| // Get the next tag. |
| if (!mNextEventFetched) mXmlEventType = xrp.next(); |
| } |
| xrp.close(); |
| return mSkbTemplate; |
| } catch (XmlPullParserException e) { |
| // Log.e(TAG, "Ill-formatted keyboard template resource file"); |
| } catch (IOException e) { |
| // Log.e(TAG, "Unable to keyboard template resource file"); |
| } |
| return null; |
| } |
| |
| public SoftKeyboard loadKeyboard(int resourceId, int skbWidth, int skbHeight) { |
| if (null == mContext) return null; |
| Resources r = mResources; |
| SkbPool skbPool = SkbPool.getInstance(); |
| XmlResourceParser xrp = mContext.getResources().getXml(resourceId); |
| mSkbTemplate = null; |
| SoftKeyboard softKeyboard = null; |
| Drawable skbBg; |
| Drawable popupBg; |
| Drawable balloonBg; |
| SoftKey softKey = null; |
| |
| KeyCommonAttributes attrDef = new KeyCommonAttributes(xrp); |
| KeyCommonAttributes attrSkb = new KeyCommonAttributes(xrp); |
| KeyCommonAttributes attrRow = new KeyCommonAttributes(xrp); |
| KeyCommonAttributes attrKeys = new KeyCommonAttributes(xrp); |
| KeyCommonAttributes attrKey = new KeyCommonAttributes(xrp); |
| |
| mKeyXPos = 0; |
| mKeyYPos = 0; |
| mSkbWidth = skbWidth; |
| mSkbHeight = skbHeight; |
| |
| try { |
| mKeyXMargin = 0; |
| mKeyYMargin = 0; |
| mXmlEventType = xrp.next(); |
| while (mXmlEventType != XmlResourceParser.END_DOCUMENT) { |
| mNextEventFetched = false; |
| if (mXmlEventType == XmlResourceParser.START_TAG) { |
| String attr = xrp.getName(); |
| // 1. Is it the root element, "keyboard"? |
| if (XMLTAG_KEYBOARD.compareTo(attr) == 0) { |
| // 1.1 Get the keyboard template id. |
| int skbTemplateId = xrp.getAttributeResourceValue(null, |
| XMLATTR_SKB_TEMPLATE, 0); |
| |
| // 1.2 Try to get the template from pool. If it is not |
| // in, the pool will try to load it. |
| mSkbTemplate = skbPool.getSkbTemplate(skbTemplateId, |
| mContext); |
| |
| if (null == mSkbTemplate |
| || !attrSkb.getAttributes(attrDef)) { |
| return null; |
| } |
| |
| boolean cacheFlag = getBoolean(xrp, |
| XMLATTR_SKB_CACHE_FLAG, DEFAULT_SKB_CACHE_FLAG); |
| boolean stickyFlag = getBoolean(xrp, |
| XMLATTR_SKB_STICKY_FLAG, |
| DEFAULT_SKB_STICKY_FLAG); |
| boolean isQwerty = getBoolean(xrp, XMLATTR_QWERTY, |
| false); |
| boolean isQwertyUpperCase = getBoolean(xrp, |
| XMLATTR_QWERTY_UPPERCASE, false); |
| |
| softKeyboard = new SoftKeyboard(resourceId, |
| mSkbTemplate, mSkbWidth, mSkbHeight); |
| softKeyboard.setFlags(cacheFlag, stickyFlag, isQwerty, |
| isQwertyUpperCase); |
| |
| mKeyXMargin = getFloat(xrp, XMLATTR_KEY_XMARGIN, |
| mSkbTemplate.getXMargin()); |
| mKeyYMargin = getFloat(xrp, XMLATTR_KEY_YMARGIN, |
| mSkbTemplate.getYMargin()); |
| skbBg = getDrawable(xrp, XMLATTR_SKB_BG, null); |
| popupBg = getDrawable(xrp, XMLATTR_POPUP_BG, null); |
| balloonBg = getDrawable(xrp, XMLATTR_BALLOON_BG, null); |
| if (null != skbBg) { |
| softKeyboard.setSkbBackground(skbBg); |
| } |
| if (null != popupBg) { |
| softKeyboard.setPopupBackground(popupBg); |
| } |
| if (null != balloonBg) { |
| softKeyboard.setKeyBalloonBackground(balloonBg); |
| } |
| softKeyboard.setKeyMargins(mKeyXMargin, mKeyYMargin); |
| } else if (XMLTAG_ROW.compareTo(attr) == 0) { |
| if (!attrRow.getAttributes(attrSkb)) { |
| return null; |
| } |
| // Get the starting positions for the row. |
| mKeyXPos = getFloat(xrp, XMLATTR_START_POS_X, 0); |
| mKeyYPos = getFloat(xrp, XMLATTR_START_POS_Y, mKeyYPos); |
| int rowId = getInteger(xrp, XMLATTR_ROW_ID, |
| KeyRow.ALWAYS_SHOW_ROW_ID); |
| softKeyboard.beginNewRow(rowId, mKeyYPos); |
| } else if (XMLTAG_KEYS.compareTo(attr) == 0) { |
| if (null == softKeyboard) return null; |
| if (!attrKeys.getAttributes(attrRow)) { |
| return null; |
| } |
| |
| String splitter = xrp.getAttributeValue(null, |
| XMLATTR_KEY_SPLITTER); |
| splitter = Pattern.quote(splitter); |
| String labels = xrp.getAttributeValue(null, |
| XMLATTR_KEY_LABELS); |
| String codes = xrp.getAttributeValue(null, |
| XMLATTR_KEY_CODES); |
| if (null == splitter || null == labels) { |
| return null; |
| } |
| String labelArr[] = labels.split(splitter); |
| String codeArr[] = null; |
| if (null != codes) { |
| codeArr = codes.split(splitter); |
| if (labelArr.length != codeArr.length) { |
| return null; |
| } |
| } |
| |
| for (int i = 0; i < labelArr.length; i++) { |
| softKey = new SoftKey(); |
| int keyCode = 0; |
| if (null != codeArr) { |
| keyCode = Integer.valueOf(codeArr[i]); |
| } |
| softKey.setKeyAttribute(keyCode, labelArr[i], |
| attrKeys.repeat, attrKeys.balloon); |
| |
| softKey.setKeyType(mSkbTemplate |
| .getKeyType(attrKeys.keyType), null, null); |
| |
| float left, right, top, bottom; |
| left = mKeyXPos; |
| |
| right = left + attrKeys.keyWidth; |
| top = mKeyYPos; |
| bottom = top + attrKeys.keyHeight; |
| |
| if (right - left < 2 * mKeyXMargin) return null; |
| if (bottom - top < 2 * mKeyYMargin) return null; |
| |
| softKey.setKeyDimensions(left, top, right, bottom); |
| softKeyboard.addSoftKey(softKey); |
| mKeyXPos = right; |
| if ((int) mKeyXPos * mSkbWidth > mSkbWidth) { |
| return null; |
| } |
| } |
| } else if (XMLTAG_KEY.compareTo(attr) == 0) { |
| if (null == softKeyboard) { |
| return null; |
| } |
| if (!attrKey.getAttributes(attrRow)) { |
| return null; |
| } |
| |
| int keyId = this.getInteger(xrp, XMLATTR_ID, -1); |
| if (keyId >= 0) { |
| softKey = mSkbTemplate.getDefaultKey(keyId); |
| } else { |
| softKey = getSoftKey(xrp, attrKey); |
| } |
| if (null == softKey) return null; |
| |
| // Update the position for next key. |
| mKeyXPos = softKey.mRightF; |
| if ((int) mKeyXPos * mSkbWidth > mSkbWidth) { |
| return null; |
| } |
| // If the current xml event type becomes a starting tag, |
| // it indicates that we have parsed too much to get |
| // toggling states, and we started a new row. In this |
| // case, the row starting position information should |
| // be updated. |
| if (mXmlEventType == XmlResourceParser.START_TAG) { |
| attr = xrp.getName(); |
| if (XMLTAG_ROW.compareTo(attr) == 0) { |
| mKeyYPos += attrRow.keyHeight; |
| if ((int) mKeyYPos * mSkbHeight > mSkbHeight) { |
| return null; |
| } |
| } |
| } |
| softKeyboard.addSoftKey(softKey); |
| } |
| } else if (mXmlEventType == XmlResourceParser.END_TAG) { |
| String attr = xrp.getName(); |
| if (XMLTAG_ROW.compareTo(attr) == 0) { |
| mKeyYPos += attrRow.keyHeight; |
| if ((int) mKeyYPos * mSkbHeight > mSkbHeight) { |
| return null; |
| } |
| } |
| } |
| |
| // Get the next tag. |
| if (!mNextEventFetched) mXmlEventType = xrp.next(); |
| } |
| xrp.close(); |
| softKeyboard.setSkbCoreSize(mSkbWidth, mSkbHeight); |
| return softKeyboard; |
| } catch (XmlPullParserException e) { |
| // Log.e(TAG, "Ill-formatted keybaord resource file"); |
| } catch (IOException e) { |
| // Log.e(TAG, "Unable to read keyboard resource file"); |
| } |
| return null; |
| } |
| |
| // Caller makes sure xrp and r are valid. |
| private SoftKey getSoftKey(XmlResourceParser xrp, |
| KeyCommonAttributes attrKey) throws XmlPullParserException, |
| IOException { |
| int keyCode = getInteger(xrp, XMLATTR_KEY_CODE, 0); |
| String keyLabel = getString(xrp, XMLATTR_KEY_LABEL, null); |
| Drawable keyIcon = getDrawable(xrp, XMLATTR_KEY_ICON, null); |
| Drawable keyIconPopup = getDrawable(xrp, XMLATTR_KEY_ICON_POPUP, null); |
| int popupSkbId = xrp.getAttributeResourceValue(null, |
| XMLATTR_KEY_POPUP_SKBID, 0); |
| |
| if (null == keyLabel && null == keyIcon) { |
| keyIcon = mSkbTemplate.getDefaultKeyIcon(keyCode); |
| keyIconPopup = mSkbTemplate.getDefaultKeyIconPopup(keyCode); |
| if (null == keyIcon || null == keyIconPopup) return null; |
| } |
| |
| // Dimension information must been initialized before |
| // getting toggle state, because mKeyYPos may be changed |
| // to next row when trying to get toggle state. |
| float left, right, top, bottom; |
| left = mKeyXPos; |
| right = left + attrKey.keyWidth; |
| top = mKeyYPos; |
| bottom = top + attrKey.keyHeight; |
| |
| if (right - left < 2 * mKeyXMargin) return null; |
| if (bottom - top < 2 * mKeyYMargin) return null; |
| |
| // Try to find if the next tag is |
| // {@link #XMLTAG_TOGGLE_STATE_OF_KEY}, if yes, try to |
| // create a toggle key. |
| boolean toggleKey = false; |
| mXmlEventType = xrp.next(); |
| mNextEventFetched = true; |
| |
| SoftKey softKey; |
| if (mXmlEventType == XmlResourceParser.START_TAG) { |
| mAttrTmp = xrp.getName(); |
| if (mAttrTmp.compareTo(XMLTAG_TOGGLE_STATE) == 0) { |
| toggleKey = true; |
| } |
| } |
| if (toggleKey) { |
| softKey = new SoftKeyToggle(); |
| if (!((SoftKeyToggle) softKey).setToggleStates(getToggleStates( |
| attrKey, (SoftKeyToggle) softKey, keyCode))) { |
| return null; |
| } |
| } else { |
| softKey = new SoftKey(); |
| } |
| |
| // Set the normal state |
| softKey.setKeyAttribute(keyCode, keyLabel, attrKey.repeat, |
| attrKey.balloon); |
| softKey.setPopupSkbId(popupSkbId); |
| softKey.setKeyType(mSkbTemplate.getKeyType(attrKey.keyType), keyIcon, |
| keyIconPopup); |
| |
| softKey.setKeyDimensions(left, top, right, bottom); |
| return softKey; |
| } |
| |
| private SoftKeyToggle.ToggleState getToggleStates( |
| KeyCommonAttributes attrKey, SoftKeyToggle softKey, int defKeyCode) |
| throws XmlPullParserException, IOException { |
| XmlResourceParser xrp = attrKey.mXrp; |
| int stateId = getInteger(xrp, XMLATTR_TOGGLE_STATE_ID, 0); |
| if (0 == stateId) return null; |
| |
| String keyLabel = getString(xrp, XMLATTR_KEY_LABEL, null); |
| int keyTypeId = getInteger(xrp, XMLATTR_KEY_TYPE, KEYTYPE_ID_LAST); |
| int keyCode; |
| if (null == keyLabel) { |
| keyCode = getInteger(xrp, XMLATTR_KEY_CODE, defKeyCode); |
| } else { |
| keyCode = getInteger(xrp, XMLATTR_KEY_CODE, 0); |
| } |
| Drawable icon = getDrawable(xrp, XMLATTR_KEY_ICON, null); |
| Drawable iconPopup = getDrawable(xrp, XMLATTR_KEY_ICON_POPUP, null); |
| if (null == icon && null == keyLabel) { |
| return null; |
| } |
| SoftKeyToggle.ToggleState rootState = softKey.createToggleState(); |
| rootState.setStateId(stateId); |
| rootState.mKeyType = null; |
| if (KEYTYPE_ID_LAST != keyTypeId) { |
| rootState.mKeyType = mSkbTemplate.getKeyType(keyTypeId); |
| } |
| rootState.mKeyCode = keyCode; |
| rootState.mKeyIcon = icon; |
| rootState.mKeyIconPopup = iconPopup; |
| rootState.mKeyLabel = keyLabel; |
| |
| boolean repeat = getBoolean(xrp, XMLATTR_KEY_REPEAT, attrKey.repeat); |
| boolean balloon = getBoolean(xrp, XMLATTR_KEY_BALLOON, attrKey.balloon); |
| rootState.setStateFlags(repeat, balloon); |
| |
| rootState.mNextState = null; |
| |
| // If there is another toggle state. |
| mXmlEventType = xrp.next(); |
| while (mXmlEventType != XmlResourceParser.START_TAG |
| && mXmlEventType != XmlResourceParser.END_DOCUMENT) { |
| mXmlEventType = xrp.next(); |
| } |
| if (mXmlEventType == XmlResourceParser.START_TAG) { |
| String attr = xrp.getName(); |
| if (attr.compareTo(XMLTAG_TOGGLE_STATE) == 0) { |
| SoftKeyToggle.ToggleState nextState = getToggleStates(attrKey, |
| softKey, defKeyCode); |
| if (null == nextState) return null; |
| rootState.mNextState = nextState; |
| } |
| } |
| |
| return rootState; |
| } |
| |
| private int getInteger(XmlResourceParser xrp, String name, int defValue) { |
| int resId = xrp.getAttributeResourceValue(null, name, 0); |
| String s; |
| if (resId == 0) { |
| s = xrp.getAttributeValue(null, name); |
| if (null == s) return defValue; |
| try { |
| int ret = Integer.valueOf(s); |
| return ret; |
| } catch (NumberFormatException e) { |
| return defValue; |
| } |
| } else { |
| return Integer.parseInt(mContext.getResources().getString(resId)); |
| } |
| } |
| |
| private int getColor(XmlResourceParser xrp, String name, int defValue) { |
| int resId = xrp.getAttributeResourceValue(null, name, 0); |
| String s; |
| if (resId == 0) { |
| s = xrp.getAttributeValue(null, name); |
| if (null == s) return defValue; |
| try { |
| int ret = Integer.valueOf(s); |
| return ret; |
| } catch (NumberFormatException e) { |
| return defValue; |
| } |
| } else { |
| return mContext.getResources().getColor(resId); |
| } |
| } |
| |
| private String getString(XmlResourceParser xrp, String name, String defValue) { |
| int resId = xrp.getAttributeResourceValue(null, name, 0); |
| if (resId == 0) { |
| return xrp.getAttributeValue(null, name); |
| } else { |
| return mContext.getResources().getString(resId); |
| } |
| } |
| |
| private float getFloat(XmlResourceParser xrp, String name, float defValue) { |
| int resId = xrp.getAttributeResourceValue(null, name, 0); |
| if (resId == 0) { |
| String s = xrp.getAttributeValue(null, name); |
| if (null == s) return defValue; |
| try { |
| float ret; |
| if (s.endsWith("%p")) { |
| ret = Float.parseFloat(s.substring(0, s.length() - 2)) / 100; |
| } else { |
| ret = Float.parseFloat(s); |
| } |
| return ret; |
| } catch (NumberFormatException e) { |
| return defValue; |
| } |
| } else { |
| return mContext.getResources().getDimension(resId); |
| } |
| } |
| |
| private boolean getBoolean(XmlResourceParser xrp, String name, |
| boolean defValue) { |
| String s = xrp.getAttributeValue(null, name); |
| if (null == s) return defValue; |
| try { |
| boolean ret = Boolean.parseBoolean(s); |
| return ret; |
| } catch (NumberFormatException e) { |
| return defValue; |
| } |
| } |
| |
| private Drawable getDrawable(XmlResourceParser xrp, String name, |
| Drawable defValue) { |
| int resId = xrp.getAttributeResourceValue(null, name, 0); |
| if (0 == resId) return defValue; |
| return mResources.getDrawable(resId); |
| } |
| } |
