PageRenderTime 59ms CodeModel.GetById 29ms RepoModel.GetById 1ms app.codeStats 0ms

/tags/20100328/src/com/menny/android/anysoftkeyboard/keyboards/ExternalAnyKeyboard.java

http://softkeyboard.googlecode.com/
Java | 322 lines | 286 code | 25 blank | 11 comment | 57 complexity | 4b17df227860deeda2412ed017dfd087 MD5 | raw file
Possible License(s): CC-BY-SA-4.0, CC-BY-SA-3.0 
    

  1. package com.menny.android.anysoftkeyboard.keyboards;

    2. 

  2. 

    3. 

  3. import org.xmlpull.v1.XmlPullParser;

    4. 

  4. 

    5. 

  5. import android.content.Context;

    6. 

  6. import android.content.res.Configuration;

    7. 

  7. import android.content.res.Resources;

    8. 

  8. import android.util.AttributeSet;

    9. 

  9. import android.util.Log;

    10. 

  10. import android.util.Xml;

    11. 

  11. 

    12. 

  12. import com.menny.android.anysoftkeyboard.AnyKeyboardContextProvider;

    13. 

  13. import com.menny.android.anysoftkeyboard.AnySoftKeyboardConfiguration;

    14. 

  14. import com.menny.android.anysoftkeyboard.R;

    15. 

  15. import com.menny.android.anysoftkeyboard.keyboards.AnyKeyboard.HardKeyboardTranslator;

    16. 

  16. 

    17. 

  17. public class ExternalAnyKeyboard extends AnyKeyboard implements HardKeyboardTranslator {

    18. 

  18. 

    19. 

  19. 	private static final String XML_TRANSLATION_TAG = "PhysicalTranslation";

    20. 

  20. 	private static final String XML_QWERTY_ATTRIBUTE = "QwertyTranslation";

    21. 

  21. 	private static final String XML_SEQUENCE_TAG = "SequenceMapping";

    22. 

  22. 	private static final String XML_KEYS_ATTRIBUTE = "keySequence";

    23. 

  23. 	private static final String XML_ALT_ATTRIBUTE = "altModifier";

    24. 

  24. 	private static final String XML_SHIFT_ATTRIBUTE = "shiftModifier";

    25. 

  25. 	private static final String XML_TARGET_ATTRIBUTE = "targetChar";

    26. 

  26. 	private static final String XML_TARGET_CHAR_CODE_ATTRIBUTE = "targetCharCode";

    27. 

  27. 	private final String mPrefId;

    28. 

  28. 	private final int mNameResId;

    29. 

  29. 	private final int mIconId;

    30. 

  30. 	private final String mDefaultDictionary;

    31. 

  31. 	private final HardKeyboardSequenceHandler mHardKeyboardTranslator;

    32. 

  32. 	private final String mAdditionalIsLetterExceptions;

    33. 

  33. 	

    34. 

  34. 	protected ExternalAnyKeyboard(AnyKeyboardContextProvider askContext, Context context,

    35. 

  35. 			int xmlLayoutResId,

    36. 

  36. 			int xmlLandscapeResId,

    37. 

  37. 			String prefId,

    38. 

  38. 			int nameResId,

    39. 

  39. 			int iconResId,

    40. 

  40. 			int qwertyTranslationId,

    41. 

  41. 			String defaultDictionary,

    42. 

  42. 			String additionalIsLetterExceptions) {

    43. 

  43. 		super(askContext, context, getKeyboardId(context, xmlLayoutResId, xmlLandscapeResId));

    44. 

  44. 		mPrefId = prefId;

    45. 

  45. 		mNameResId = nameResId;

    46. 

  46. 		mIconId = iconResId;

    47. 

  47. 		mDefaultDictionary = defaultDictionary;

    48. 

  48. 		if (qwertyTranslationId != -1)

    49. 

  49. 		{

    50. 

  50. 			mHardKeyboardTranslator = createPhysicalTranslatorFromResourceId(context.getApplicationContext(), qwertyTranslationId);

    51. 

  51. 		}

    52. 

  52. 		else

    53. 

  53. 		{

    54. 

  54. 			mHardKeyboardTranslator = null;

    55. 

  55. 		}

    56. 

  56. 		

    57. 

  57. 		mAdditionalIsLetterExceptions = additionalIsLetterExceptions;

    58. 

  58. 		

    59. 

  59. 		for(final Key key : getKeys())

    60. 

  60. 		{

    61. 

  61. 		    final Resources localResources = getASKContext().getApplicationContext().getResources();

    62. 

  62. 	        //adding icons

    63. 

  63. 	        switch(key.codes[0])

    64. 

  64. 	        {

    65. 

  65. 	        case AnyKeyboard.KEYCODE_DELETE:

    66. 

  66. 	            key.icon = localResources.getDrawable(R.drawable.sym_keyboard_delete_small);

    67. 

  67. 	            break;

    68. 

  68. 	        case AnyKeyboard.KEYCODE_SHIFT:

    69. 

  69. 	            key.icon = localResources.getDrawable(R.drawable.sym_keyboard_shift);

    70. 

  70. 	            break;

    71. 

  71. 	        case AnyKeyboard.KEYCODE_CTRL:

    72. 

  72. 	            key.icon = localResources.getDrawable(R.drawable.sym_keyboard_ctrl);

    73. 

  73. 	            break;

    74. 

  74. 	        case 32://SPACE

    75. 

  75. 	            key.icon = localResources.getDrawable(R.drawable.sym_keyboard_space);

    76. 

  76. 	            break;

    77. 

  77. 	        case 9://TAB

    78. 

  78. 	            key.icon = localResources.getDrawable(R.drawable.tab_key);

    79. 

  79. 	            break;

    80. 

  80. 	//these two will be set upon calling setTextVariation           

    81. 

  81. //	      case AnyKeyboard.KEYCODE_SMILEY:

    82. 

  82. //	          key.icon = res.getDrawable(R.drawable.sym_keyboard_smiley);

    83. 

  83. //	          key.popupResId = R.xml.popup_smileys;

    84. 

  84. //	          break;

    85. 

  85. //	      case 10://ENTER

    86. 

  86. //	          key.icon = res.getDrawable(R.drawable.sym_keyboard_return);

    87. 

  87. //	          break;

    88. 

  88. 	        }

    89. 

  89. 		}

    90. 

  90. 	}

    91. 

  91. 

    92. 

  92. 	private HardKeyboardSequenceHandler createPhysicalTranslatorFromResourceId(Context context, int qwertyTranslationId) {

    93. 

  93. 		HardKeyboardSequenceHandler translator = new HardKeyboardSequenceHandler();

    94. 

  94. 		XmlPullParser parser = context.getResources().getXml(qwertyTranslationId);

    95. 

  95. 		final String TAG = "ASK Hard Translation Parser";

    96. 

  96. 		try {

    97. 

  97.             int event;

    98. 

  98.             boolean inTranslations = false;

    99. 

  99.             while ((event = parser.next()) != XmlPullParser.END_DOCUMENT) 

    100. 

  100.             {

    101. 

  101.             	String tag = parser.getName();

    102. 

  102.                 if (event == XmlPullParser.START_TAG) {

    103. 

  103.                     if (XML_TRANSLATION_TAG.equals(tag)) {

    104. 

  104.                     	inTranslations = true;

    105. 

  105.                     	AttributeSet attrs = Xml.asAttributeSet(parser);

    106. 

  106.                     	final String qwerty = attrs.getAttributeValue(null, XML_QWERTY_ATTRIBUTE);

    107. 

  107.                     	translator.addQwertyTranslation(qwerty);

    108. 

  108.                     	if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Starting parsing "+XML_TRANSLATION_TAG+". Qwerty:"+qwerty);

    109. 

  109.                     }

    110. 

  110.                     else if (inTranslations && XML_SEQUENCE_TAG.equals(tag))

    111. 

  111.                     {

    112. 

  112.                     	if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Starting parsing "+XML_SEQUENCE_TAG);

    113. 

  113.                     	AttributeSet attrs = Xml.asAttributeSet(parser);

    114. 

  114.                     	

    115. 

  115.                     	final int[] keyCodes = getKeyCodesFromPhysicalSequence(attrs.getAttributeValue(null, XML_KEYS_ATTRIBUTE));

    116. 

  116.                     	final boolean isAlt = attrs.getAttributeBooleanValue(null, XML_ALT_ATTRIBUTE, false);

    117. 

  117.                     	final boolean isShift = attrs.getAttributeBooleanValue(null, XML_SHIFT_ATTRIBUTE, false);

    118. 

  118.                     	final String targetChar = attrs.getAttributeValue(null, XML_TARGET_ATTRIBUTE);

    119. 

  119.                     	final String targetCharCode = attrs.getAttributeValue(null, XML_TARGET_CHAR_CODE_ATTRIBUTE);

    120. 

  120.                         final String target;

    121. 

  121.                         if (targetChar == null)

    122. 

  122.                         	target = Character.toString((char)Integer.parseInt(targetCharCode));

    123. 

  123.                         else

    124. 

  124.                         	target = targetChar;

    125. 

  125.                     	//asserting

    126. 

  126.                         if ((keyCodes == null) || (keyCodes.length == 0) || (target == null))

    127. 

  127.                         {

    128. 

  128.                             Log.e(TAG, "Physical translator sequence does not include mandatory fields "+XML_KEYS_ATTRIBUTE+" or "+XML_TARGET_ATTRIBUTE);

    129. 

  129.                         }

    130. 

  130.                         else

    131. 

  131.                         {

    132. 

  132.                         	if (!isAlt && !isShift)

    133. 

  133.                         	{

    134. 

  134. 	                        	if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Physical translation details: keys:"+printInts(keyCodes)+" target:"+target);

    135. 

  135. 	                        	translator.addSequence(keyCodes, target.charAt(0));

    136. 

  136.                         	}

    137. 

  137.                         	else if (isAlt)

    138. 

  138.                         	{

    139. 

  139.                         		final int keyCode = keyCodes[0];

    140. 

  140.                         		if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Physical translation details: ALT+key:"+keyCode+" target:"+target);

    141. 

  141. 	                        	translator.addAltMapping(keyCode, target.charAt(0));

    142. 

  142.                         	}

    143. 

  143.                         	else if (isShift)

    144. 

  144.                         	{

    145. 

  145.                         		final int keyCode = keyCodes[0];

    146. 

  146.                         		if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Physical translation details: ALT+key:"+keyCode+" target:"+target);

    147. 

  147. 	                        	translator.addShiftMapping(keyCode, target.charAt(0));

    148. 

  148.                         	}

    149. 

  149.                         }                        

    150. 

  150.                     }

    151. 

  151.                 }

    152. 

  152.                 else if (event == XmlPullParser.END_TAG) {

    153. 

  153.                 	if (XML_TRANSLATION_TAG.equals(tag)) {

    154. 

  154.                     	inTranslations = false;

    155. 

  155.                     	if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Finished parsing "+XML_TRANSLATION_TAG);

    156. 

  156.                     	break;

    157. 

  157.                     } 

    158. 

  158.                 	else if (inTranslations && XML_SEQUENCE_TAG.equals(tag))

    159. 

  159.                     {

    160. 

  160.                 		if (AnySoftKeyboardConfiguration.getInstance().getDEBUG()) Log.d(TAG, "Finished parsing "+XML_SEQUENCE_TAG);

    161. 

  161.                     }

    162. 

  162.                 }

    163. 

  163.             }

    164. 

  164.         } catch (Exception e) {

    165. 

  165.             Log.e(TAG, "Parse error:" + e);

    166. 

  166.             e.printStackTrace();

    167. 

  167.         }

    168. 

  168. 		return translator;

    169. 

  169. 	}

    170. 

  170. 

    171. 

  171. 	private String printInts(int[] keyCodes) {

    172. 

  172. 		String r = "";

    173. 

  173. 		for(int code : keyCodes)

    174. 

  174. 			r += (Integer.toString(code)+",");

    175. 

  175. 		

    176. 

  176. 		return r;

    177. 

  177. 	}

    178. 

  178. 

    179. 

  179. 	private int[] getKeyCodesFromPhysicalSequence(String keyCodesArray) {

    180. 

  180. 		String[] splitted = keyCodesArray.split(",");

    181. 

  181. 		int[] keyCodes = new int[splitted.length];

    182. 

  182. 		for(int i=0;i<keyCodes.length;i++)

    183. 

  183. 		{

    184. 

  184. 			keyCodes[i] = Integer.parseInt(splitted[i]);

    185. 

  185. 		}

    186. 

  186. 		

    187. 

  187. 		return keyCodes;

    188. 

  188. 	}

    189. 

  189. 

    190. 

  190. 	@Override

    191. 

  191. 	public String getDefaultDictionaryLanguage() {

    192. 

  192. 		return mDefaultDictionary;

    193. 

  193. 	}

    194. 

  194. 	

    195. 

  195. 	@Override

    196. 

  196. 	public String getKeyboardPrefId() {

    197. 

  197. 		return mPrefId;

    198. 

  198. 	}

    199. 

  199. 	

    200. 

  200. 	@Override

    201. 

  201. 	public int getKeyboardIconResId() {

    202. 

  202. 		return mIconId;

    203. 

  203. 	}

    204. 

  204. 	

    205. 

  205. 	@Override

    206. 

  206. 	public int getKeyboardNameResId() {

    207. 

  207. 		return mNameResId;

    208. 

  208. 	}

    209. 

  209. 	

    210. 

  210. 	private static int getKeyboardId(Context context, int portraitId, int landscapeId) 

    211. 

  211. 	{

    212. 

  212. 		final boolean inPortraitMode = 

    213. 

  213. 			(context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT);

    214. 

  214. 		

    215. 

  215. 		if (inPortraitMode)

    216. 

  216. 			return portraitId;

    217. 

  217. 		else

    218. 

  218. 			return landscapeId;

    219. 

  219. 	}

    220. 

  220. 	

    221. 

  221. 	//this class implements the HardKeyboardTranslator interface in an empty way, the physical keyboard is Latin...

    222. 

  222. 	public void translatePhysicalCharacter(HardKeyboardAction action) 

    223. 

  223. 	{

    224. 

  224. 		if (mHardKeyboardTranslator != null)

    225. 

  225. 		{

    226. 

  226. 			final char translated;

    227. 

  227. 			if (action.isAltActive())

    228. 

  228. 				translated = mHardKeyboardTranslator.getAltCharacter(action.getKeyCode());

    229. 

  229. 			else if (action.isShiftActive())

    230. 

  230. 				translated = mHardKeyboardTranslator.getShiftCharacter(action.getKeyCode());

    231. 

  231. 			else

    232. 

  232. 				translated = mHardKeyboardTranslator.getSequenceCharacter(action.getKeyCode(), getASKContext());

    233. 

  233. 			

    234. 

  234. 			if (translated != 0)

    235. 

  235. 				action.setNewKeyCode(translated);

    236. 

  236. 		}

    237. 

  237. 	}

    238. 

  238. 	

    239. 

  239. 	@Override

    240. 

  240. 	public boolean isLetter(char keyValue) {

    241. 

  241. 		if (mAdditionalIsLetterExceptions == null)

    242. 

  242. 			return super.isLetter(keyValue);

    243. 

  243. 		else

    244. 

  244. 			return super.isLetter(keyValue) || 

    245. 

  245. 				(mAdditionalIsLetterExceptions.indexOf(keyValue) >= 0);

    246. 

  246. 	}

    247. 

  247. 	

    248. 

  248. 	protected void setPopupKeyChars(Key aKey)

    249. 

  249. 	{

    250. 

  250. 		if (aKey.popupResId > 0)

    251. 

  251. 			return;//if the keyboard XML already specified the popup, then no need to override

    252. 

  252. 		

    253. 

  253. 		if ((aKey.codes != null) && (aKey.codes.length > 0))

    254. 

  254.         {

    255. 

  255. 			switch((char)aKey.codes[0])

    256. 

  256. 			{

    257. 

  257. 				case 'a':

    258. 

  258. 					aKey.popupCharacters = "\u00e0\u00e1\u00e2\u00e3\u00e4\u00e5\u00e6\u0105";

    259. 

  259. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    260. 

  260. 					break;

    261. 

  261. 				case 'c':

    262. 

  262. 					aKey.popupCharacters = "\u00e7\u0107\u0109\u010d";

    263. 

  263. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    264. 

  264. 					break;

    265. 

  265. 				case 'd':

    266. 

  266. 					aKey.popupCharacters = "\u0111";

    267. 

  267. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    268. 

  268. 					break;

    269. 

  269. 				case 'e':

    270. 

  270. 					aKey.popupCharacters = "\u00e8\u00e9\u00ea\u00eb\u0119\u20ac";

    271. 

  271. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    272. 

  272. 					break;

    273. 

  273. 				case 'g':

    274. 

  274. 					aKey.popupCharacters = "\u011d";

    275. 

  275. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    276. 

  276. 					break;

    277. 

  277. 				case 'h':

    278. 

  278. 					aKey.popupCharacters = "\u0125";

    279. 

  279. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    280. 

  280. 					break;

    281. 

  281. 				case 'i':

    282. 

  282. 					aKey.popupCharacters = "\u00ec\u00ed\u00ee\u00ef\u0142";

    283. 

  283. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    284. 

  284. 					break;

    285. 

  285. 				case 'j':

    286. 

  286. 					aKey.popupCharacters = "\u0135";

    287. 

  287. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    288. 

  288. 					break;

    289. 

  289. 				case 'l':

    290. 

  290. 					aKey.popupCharacters = "\u0142";

    291. 

  291. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    292. 

  292. 					break;

    293. 

  293. 				case 'o':

    294. 

  294. 					aKey.popupCharacters = "\u00f2\u00f3\u00f4\u00f5\u00f6\u00f8\u0151\u0153";

    295. 

  295. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    296. 

  296. 					break;

    297. 

  297. 				case 's':

    298. 

  298. 					aKey.popupCharacters = "\u00a7\u00df\u015b\u015d\u0161";

    299. 

  299. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    300. 

  300. 					break;

    301. 

  301. 				case 'u':

    302. 

  302. 					aKey.popupCharacters = "\u00f9\u00fa\u00fb\u00fc\u016d\u0171";

    303. 

  303. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    304. 

  304. 					break;

    305. 

  305. 				case 'n':

    306. 

  306. 					aKey.popupCharacters = "\u00f1";

    307. 

  307. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    308. 

  308. 					break;

    309. 

  309. 				case 'y':

    310. 

  310. 					aKey.popupCharacters = "\u00fd\u00ff";

    311. 

  311. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    312. 

  312. 					break;

    313. 

  313. 				case 'z':

    314. 

  314. 					aKey.popupCharacters = "\u017c\u017e";

    315. 

  315. 					aKey.popupResId = com.menny.android.anysoftkeyboard.R.xml.popup;

    316. 

  316. 					break;

    317. 

  317. 				default:

    318. 

  318. 					super.setPopupKeyChars(aKey);

    319. 

  319. 			}

    320. 

  320.         }

    321. 

  321. 	}

    322. 

  322. }

    323. 

  323.