PageRenderTime 32ms CodeModel.GetById 24ms RepoModel.GetById 0ms app.codeStats 0ms

/tts/src/com/google/tts/TextToSpeechBeta.java

http://eyes-free.googlecode.com/
Java | 1604 lines | 913 code | 103 blank | 588 comment | 88 complexity | e4fafd3ff35c6897b03ad1b069b79b9c MD5 | raw file
Possible License(s): GPL-3.0, Apache-2.0 
    

  1. /*

    2. 

  2.  * Copyright (C) 2009 Google Inc.

    3. 

  3.  * 

    4. 

  4.  * Licensed under the Apache License, Version 2.0 (the "License"); you may not

    5. 

  5.  * use this file except in compliance with the License. You may obtain a copy of

    6. 

  6.  * the License at

    7. 

  7.  * 

    8. 

  8.  * http://www.apache.org/licenses/LICENSE-2.0

    9. 

  9.  * 

    10. 

  10.  * Unless required by applicable law or agreed to in writing, software

    11. 

  11.  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

    12. 

  12.  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

    13. 

  13.  * License for the specific language governing permissions and limitations under

    14. 

  14.  * the License.

    15. 

  15.  */

    16. 

  16. 

    17. 

  17. package com.google.tts;

    18. 

  18. 

    19. 

  19. import com.google.tts.ITtsBeta;

    20. 

  20. import com.google.tts.ITtsCallbackBeta;

    21. 

  21. 

    22. 

  22. // import android.annotation.SdkConstant;

    23. 

  23. // import android.annotation.SdkConstant.SdkConstantType;

    24. 

  24. import android.content.ComponentName;

    25. 

  25. import android.content.Context;

    26. 

  26. import android.content.Intent;

    27. 

  27. import android.content.ServiceConnection;

    28. 

  28. import android.content.pm.PackageInfo;

    29. 

  29. import android.content.pm.PackageManager;

    30. 

  30. import android.content.pm.ResolveInfo;

    31. 

  31. import android.content.pm.PackageManager.NameNotFoundException;

    32. 

  32. import android.media.AudioManager;

    33. 

  33. import android.os.IBinder;

    34. 

  34. import android.os.RemoteException;

    35. 

  35. import android.speech.tts.TextToSpeech;

    36. 

  36. import android.util.Log;

    37. 

  37. import android.view.MotionEvent;

    38. 

  38. 

    39. 

  39. import java.lang.reflect.InvocationTargetException;

    40. 

  40. import java.lang.reflect.Method;

    41. 

  41. import java.util.HashMap;

    42. 

  42. import java.util.Locale;

    43. 

  43. 

    44. 

  44. /**

    45. 

  45.  * Synthesizes speech from text for immediate playback or to create a sound

    46. 

  46.  * file.

    47. 

  47.  * <p>

    48. 

  48.  * A TextToSpeech instance can only be used to synthesize text once it has

    49. 

  49.  * completed its initialization. Implement the

    50. 

  50.  * {@link TextToSpeechBeta.OnInitListener} to be notified of the completion of

    51. 

  51.  * the initialization.<br>

    52. 

  52.  * When you are done using the TextToSpeech instance, call the

    53. 

  53.  * {@link #shutdown()} method to release the native resources used by the

    54. 

  54.  * TextToSpeech engine.

    55. 

  55.  */

    56. 

  56. public class TextToSpeechBeta extends TextToSpeech {

    57. 

  57.     // BEGINNING OF WORKAROUND FOR PRE-FROYO COMPATIBILITY

    58. 

  58.     private static Method Platform_areDefaultsEnforced;

    59. 

  59. 

    60. 

  60.     private static Method Platform_getDefaultEngine;

    61. 

  61. 

    62. 

  62.     private static Method Platform_setEngineByPackageName;

    63. 

  63.     static {

    64. 

  64.         initCompatibility();

    65. 

  65.     }

    66. 

  66. 

    67. 

  67.     private static void initCompatibility() {

    68. 

  68.         try {

    69. 

  69.             Platform_areDefaultsEnforced = TextToSpeech.class.getMethod("areDefaultsEnforced",

    70. 

  70.                     new Class[] {});

    71. 

  71.             Platform_getDefaultEngine = TextToSpeech.class.getMethod("getDefaultEngine",

    72. 

  72.                     new Class[] {});

    73. 

  73.             Platform_setEngineByPackageName = TextToSpeech.class.getMethod(

    74. 

  74.                     "setEngineByPackageName", new Class[] {

    75. 

  75.                         String.class

    76. 

  76.                     });

    77. 

  77.             /* success, this is a newer device */

    78. 

  78.         } catch (NoSuchMethodException nsme) {

    79. 

  79.             /* failure, must be older device */

    80. 

  80.         }

    81. 

  81.     }

    82. 

  82. 

    83. 

  83.     private static boolean usePlatform_areDefaultsEnforced(TextToSpeech ttsObj) {

    84. 

  84.         try {

    85. 

  85.             Object retobj = Platform_areDefaultsEnforced.invoke(ttsObj);

    86. 

  86.             return (Boolean) retobj;

    87. 

  87.         } catch (IllegalAccessException ie) {

    88. 

  88.             System.err.println("unexpected " + ie);

    89. 

  89.         } catch (IllegalArgumentException e) {

    90. 

  90.             // TODO Auto-generated catch block

    91. 

  91.             e.printStackTrace();

    92. 

  92.         } catch (InvocationTargetException e) {

    93. 

  93.             // TODO Auto-generated catch block

    94. 

  94.             e.printStackTrace();

    95. 

  95.         }

    96. 

  96.         return false;

    97. 

  97.     }

    98. 

  98. 

    99. 

  99.     private static String usePlatform_getDefaultEngine(TextToSpeech ttsObj) {

    100. 

  100.         try {

    101. 

  101.             Object retobj = Platform_getDefaultEngine.invoke(ttsObj);

    102. 

  102.             return (String) retobj;

    103. 

  103.         } catch (IllegalAccessException ie) {

    104. 

  104.             System.err.println("unexpected " + ie);

    105. 

  105.         } catch (IllegalArgumentException e) {

    106. 

  106.             // TODO Auto-generated catch block

    107. 

  107.             e.printStackTrace();

    108. 

  108.         } catch (InvocationTargetException e) {

    109. 

  109.             // TODO Auto-generated catch block

    110. 

  110.             e.printStackTrace();

    111. 

  111.         }

    112. 

  112.         return "com.svox.pico";

    113. 

  113.     }

    114. 

  114. 

    115. 

  115.     private static int usePlatform_setEngineByPackageName(TextToSpeech ttsObj, String enginePackageName) {

    116. 

  116.         try {

    117. 

  117.             Object retobj = Platform_setEngineByPackageName.invoke(ttsObj, enginePackageName);

    118. 

  118.             return (Integer) retobj;

    119. 

  119.         } catch (IllegalAccessException ie) {

    120. 

  120.             System.err.println("unexpected " + ie);

    121. 

  121.         } catch (IllegalArgumentException e) {

    122. 

  122.             // TODO Auto-generated catch block

    123. 

  123.             e.printStackTrace();

    124. 

  124.         } catch (InvocationTargetException e) {

    125. 

  125.             // TODO Auto-generated catch block

    126. 

  126.             e.printStackTrace();

    127. 

  127.         }

    128. 

  128.         return ERROR;

    129. 

  129.     }

    130. 

  130. 

    131. 

  131.     // END OF WORKAROUND FOR PRE-FROYO COMPATIBILITY

    132. 

  132. 

    133. 

  133.     public static final String USING_PLATFORM_TTS = "TextToSpeechBeta not installed - defaulting to basic platform TextToSpeech for ";

    134. 

  134. 

    135. 

  135.     public static final String NOT_ON_PLATFORM_TTS = "TextToSpeechBeta not installed - basic platform TextToSpeech does not support ";

    136. 

  136. 

    137. 

  137.     /**

    138. 

  138.      * Denotes a successful operation.

    139. 

  139.      */

    140. 

  140.     public static final int SUCCESS = 0;

    141. 

  141. 

    142. 

  142.     /**

    143. 

  143.      * Denotes a generic operation failure.

    144. 

  144.      */

    145. 

  145.     public static final int ERROR = -1;

    146. 

  146. 

    147. 

  147.     /**

    148. 

  148.      * Queue mode where all entries in the playback queue (media to be played

    149. 

  149.      * and text to be synthesized) are dropped and replaced by the new entry.

    150. 

  150.      */

    151. 

  151.     public static final int QUEUE_FLUSH = 0;

    152. 

  152. 

    153. 

  153.     /**

    154. 

  154.      * Queue mode where the new entry is added at the end of the playback queue.

    155. 

  155.      */

    156. 

  156.     public static final int QUEUE_ADD = 1;

    157. 

  157. 

    158. 

  158.     /**

    159. 

  159.      * Denotes the language is available exactly as specified by the locale.

    160. 

  160.      */

    161. 

  161.     public static final int LANG_COUNTRY_VAR_AVAILABLE = 2;

    162. 

  162. 

    163. 

  163.     /**

    164. 

  164.      * Denotes the language is available for the language and country specified

    165. 

  165.      * by the locale, but not the variant.

    166. 

  166.      */

    167. 

  167.     public static final int LANG_COUNTRY_AVAILABLE = 1;

    168. 

  168. 

    169. 

  169.     /**

    170. 

  170.      * Denotes the language is available for the language by the locale, but not

    171. 

  171.      * the country and variant.

    172. 

  172.      */

    173. 

  173.     public static final int LANG_AVAILABLE = 0;

    174. 

  174. 

    175. 

  175.     /**

    176. 

  176.      * Denotes the language data is missing.

    177. 

  177.      */

    178. 

  178.     public static final int LANG_MISSING_DATA = -1;

    179. 

  179. 

    180. 

  180.     /**

    181. 

  181.      * Denotes the language is not supported.

    182. 

  182.      */

    183. 

  183.     public static final int LANG_NOT_SUPPORTED = -2;

    184. 

  184. 

    185. 

  185.     /**

    186. 

  186.      * Broadcast Action: The TextToSpeech synthesizer has completed processing

    187. 

  187.      * of all the text in the speech queue.

    188. 

  188.      */

    189. 

  189.     // @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)

    190. 

  190.     public static final String ACTION_TTS_QUEUE_PROCESSING_COMPLETED = "android.speech.tts.TTS_QUEUE_PROCESSING_COMPLETED";

    191. 

  191. 

    192. 

  192.     /**

    193. 

  193.      * Interface definition of a callback to be invoked indicating the

    194. 

  194.      * completion of the TextToSpeech engine initialization.

    195. 

  195.      */

    196. 

  196.     public interface OnInitListener {

    197. 

  197.         /**

    198. 

  198.          * Called to signal the completion of the TextToSpeech engine

    199. 

  199.          * initialization.

    200. 

  200.          * 

    201. 

  201.          * @param status {@link TextToSpeechBeta#SUCCESS} or

    202. 

  202.          *            {@link TextToSpeechBeta#ERROR}.

    203. 

  203.          * @param version The version of TextToSpeechBeta Service that the user

    204. 

  204.          *            has installed, or -1 if the user does not have it

    205. 

  205.          *            installed.

    206. 

  206.          */

    207. 

  207.         public void onInit(int status, int version);

    208. 

  208.     }

    209. 

  209. 

    210. 

  210.     /**

    211. 

  211.      * Interface definition of a callback to be invoked indicating the

    212. 

  212.      * TextToSpeech engine has completed synthesizing an utterance with an

    213. 

  213.      * utterance ID set.

    214. 

  214.      */

    215. 

  215.     public interface OnUtteranceCompletedListener {

    216. 

  216.         /**

    217. 

  217.          * Called to signal the completion of the synthesis of the utterance

    218. 

  218.          * that was identified with the string parameter. This identifier is the

    219. 

  219.          * one originally passed in the parameter hashmap of the synthesis

    220. 

  220.          * request in {@link TextToSpeechBeta#speak(String, int, HashMap)} or

    221. 

  221.          * {@link TextToSpeechBeta#synthesizeToFile(String, HashMap, String)}

    222. 

  222.          * with the {@link TextToSpeechBeta.Engine#KEY_PARAM_UTTERANCE_ID} key.

    223. 

  223.          * 

    224. 

  224.          * @param utteranceId the identifier of the utterance.

    225. 

  225.          */

    226. 

  226.         public void onUtteranceCompleted(String utteranceId);

    227. 

  227.     }

    228. 

  228. 

    229. 

  229.     /**

    230. 

  230.      * Internal constants for the TextToSpeech functionality

    231. 

  231.      */

    232. 

  232.     public class Engine {

    233. 

  233.         // default values for a TTS engine when settings are not found in the

    234. 

  234.         // provider

    235. 

  235.         /**

    236. 

  236.          * {@hide}

    237. 

  237.          */

    238. 

  238.         public static final int DEFAULT_RATE = 100; // 1x

    239. 

  239. 

    240. 

  240.         /**

    241. 

  241.          * {@hide}

    242. 

  242.          */

    243. 

  243.         public static final int DEFAULT_PITCH = 100;// 1x

    244. 

  244. 

    245. 

  245.         /**

    246. 

  246.          * {@hide}

    247. 

  247.          */

    248. 

  248.         public static final int USE_DEFAULTS = 0; // false

    249. 

  249. 

    250. 

  250.         /**

    251. 

  251.          * {@hide}

    252. 

  252.          */

    253. 

  253.         public static final String DEFAULT_SYNTH = "com.svox.pico";

    254. 

  254. 

    255. 

  255.         // default values for rendering

    256. 

  256.         /**

    257. 

  257.          * Default audio stream used when playing synthesized speech.

    258. 

  258.          */

    259. 

  259.         public static final int DEFAULT_STREAM = AudioManager.STREAM_MUSIC;

    260. 

  260. 

    261. 

  261.         // return codes for a TTS engine's check data activity

    262. 

  262.         /**

    263. 

  263.          * Indicates success when checking the installation status of the

    264. 

  264.          * resources used by the TextToSpeech engine with the

    265. 

  265.          * {@link #ACTION_CHECK_TTS_DATA} intent.

    266. 

  266.          */

    267. 

  267.         public static final int CHECK_VOICE_DATA_PASS = 1;

    268. 

  268. 

    269. 

  269.         /**

    270. 

  270.          * Indicates failure when checking the installation status of the

    271. 

  271.          * resources used by the TextToSpeech engine with the

    272. 

  272.          * {@link #ACTION_CHECK_TTS_DATA} intent.

    273. 

  273.          */

    274. 

  274.         public static final int CHECK_VOICE_DATA_FAIL = 0;

    275. 

  275. 

    276. 

  276.         /**

    277. 

  277.          * Indicates erroneous data when checking the installation status of the

    278. 

  278.          * resources used by the TextToSpeech engine with the

    279. 

  279.          * {@link #ACTION_CHECK_TTS_DATA} intent.

    280. 

  280.          */

    281. 

  281.         public static final int CHECK_VOICE_DATA_BAD_DATA = -1;

    282. 

  282. 

    283. 

  283.         /**

    284. 

  284.          * Indicates missing resources when checking the installation status of

    285. 

  285.          * the resources used by the TextToSpeech engine with the

    286. 

  286.          * {@link #ACTION_CHECK_TTS_DATA} intent.

    287. 

  287.          */

    288. 

  288.         public static final int CHECK_VOICE_DATA_MISSING_DATA = -2;

    289. 

  289. 

    290. 

  290.         /**

    291. 

  291.          * Indicates missing storage volume when checking the installation

    292. 

  292.          * status of the resources used by the TextToSpeech engine with the

    293. 

  293.          * {@link #ACTION_CHECK_TTS_DATA} intent.

    294. 

  294.          */

    295. 

  295.         public static final int CHECK_VOICE_DATA_MISSING_VOLUME = -3;

    296. 

  296. 

    297. 

  297.         // intents to ask engine to install data or check its data

    298. 

  298.         /**

    299. 

  299.          * Activity Action: Triggers the platform TextToSpeech engine to start

    300. 

  300.          * the activity that installs the resource files on the device that are

    301. 

  301.          * required for TTS to be operational. Since the installation of the

    302. 

  302.          * data can be interrupted or declined by the user, the application

    303. 

  303.          * shouldn't expect successful installation upon return from that

    304. 

  304.          * intent, and if need be, should check installation status with

    305. 

  305.          * {@link #ACTION_CHECK_TTS_DATA}.

    306. 

  306.          */

    307. 

  307.         // @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)

    308. 

  308.         public static final String ACTION_INSTALL_TTS_DATA = "android.speech.tts.engine.INSTALL_TTS_DATA";

    309. 

  309. 

    310. 

  310.         /**

    311. 

  311.          * Broadcast Action: broadcast to signal the completion of the

    312. 

  312.          * installation of the data files used by the synthesis engine. Success

    313. 

  313.          * or failure is indicated in the {@link #EXTRA_TTS_DATA_INSTALLED}

    314. 

  314.          * extra.

    315. 

  315.          */

    316. 

  316.         // @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)

    317. 

  317.         public static final String ACTION_TTS_DATA_INSTALLED = "android.speech.tts.engine.TTS_DATA_INSTALLED";

    318. 

  318. 

    319. 

  319.         /**

    320. 

  320.          * Activity Action: Starts the activity from the platform TextToSpeech

    321. 

  321.          * engine to verify the proper installation and availability of the

    322. 

  322.          * resource files on the system. Upon completion, the activity will

    323. 

  323.          * return one of the following codes: {@link #CHECK_VOICE_DATA_PASS},

    324. 

  324.          * {@link #CHECK_VOICE_DATA_FAIL}, {@link #CHECK_VOICE_DATA_BAD_DATA},

    325. 

  325.          * {@link #CHECK_VOICE_DATA_MISSING_DATA}, or

    326. 

  326.          * {@link #CHECK_VOICE_DATA_MISSING_VOLUME}.

    327. 

  327.          * <p>

    328. 

  328.          * Moreover, the data received in the activity result will contain the

    329. 

  329.          * following fields:

    330. 

  330.          * <ul>

    331. 

  331.          * <li>{@link #EXTRA_VOICE_DATA_ROOT_DIRECTORY} which indicates the path

    332. 

  332.          * to the location of the resource files,</li>

    333. 

  333.          * <li>{@link #EXTRA_VOICE_DATA_FILES} which contains the list of all

    334. 

  334.          * the resource files,</li>

    335. 

  335.          * <li>and {@link #EXTRA_VOICE_DATA_FILES_INFO} which contains, for each

    336. 

  336.          * resource file, the description of the language covered by the file in

    337. 

  337.          * the xxx-YYY format, where xxx is the 3-letter ISO language code, and

    338. 

  338.          * YYY is the 3-letter ISO country code.</li>

    339. 

  339.          * </ul>

    340. 

  340.          */

    341. 

  341.         // @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)

    342. 

  342.         public static final String ACTION_CHECK_TTS_DATA = "android.speech.tts.engine.CHECK_TTS_DATA";

    343. 

  343. 

    344. 

  344.         // extras for a TTS engine's check data activity

    345. 

  345.         /**

    346. 

  346.          * Extra information received with the {@link #ACTION_CHECK_TTS_DATA}

    347. 

  347.          * intent where the TextToSpeech engine specifies the path to its

    348. 

  348.          * resources.

    349. 

  349.          */

    350. 

  350.         public static final String EXTRA_VOICE_DATA_ROOT_DIRECTORY = "dataRoot";

    351. 

  351. 

    352. 

  352.         /**

    353. 

  353.          * Extra information received with the {@link #ACTION_CHECK_TTS_DATA}

    354. 

  354.          * intent where the TextToSpeech engine specifies the file names of its

    355. 

  355.          * resources under the resource path.

    356. 

  356.          */

    357. 

  357.         public static final String EXTRA_VOICE_DATA_FILES = "dataFiles";

    358. 

  358. 

    359. 

  359.         /**

    360. 

  360.          * Extra information received with the {@link #ACTION_CHECK_TTS_DATA}

    361. 

  361.          * intent where the TextToSpeech engine specifies the locale associated

    362. 

  362.          * with each resource file.

    363. 

  363.          */

    364. 

  364.         public static final String EXTRA_VOICE_DATA_FILES_INFO = "dataFilesInfo";

    365. 

  365. 

    366. 

  366.         // extras for a TTS engine's data installation

    367. 

  367.         /**

    368. 

  368.          * Extra information received with the

    369. 

  369.          * {@link #ACTION_TTS_DATA_INSTALLED} intent. It indicates whether the

    370. 

  370.          * data files for the synthesis engine were successfully installed. The

    371. 

  371.          * installation was initiated with the {@link #ACTION_INSTALL_TTS_DATA}

    372. 

  372.          * intent. The possible values for this extra are

    373. 

  373.          * {@link TextToSpeechBeta#SUCCESS} and {@link TextToSpeechBeta#ERROR}.

    374. 

  374.          */

    375. 

  375.         public static final String EXTRA_TTS_DATA_INSTALLED = "dataInstalled";

    376. 

  376. 

    377. 

  377.         // keys for the parameters passed with speak commands. Hidden keys are

    378. 

  378.         // used

    379. 

  379.         // internally

    380. 

  380.         // to maintain engine state for each TextToSpeech instance.

    381. 

  381.         /**

    382. 

  382.          * {@hide}

    383. 

  383.          */

    384. 

  384.         public static final String KEY_PARAM_RATE = "rate";

    385. 

  385. 

    386. 

  386.         /**

    387. 

  387.          * {@hide}

    388. 

  388.          */

    389. 

  389.         public static final String KEY_PARAM_LANGUAGE = "language";

    390. 

  390. 

    391. 

  391.         /**

    392. 

  392.          * {@hide}

    393. 

  393.          */

    394. 

  394.         public static final String KEY_PARAM_COUNTRY = "country";

    395. 

  395. 

    396. 

  396.         /**

    397. 

  397.          * {@hide}

    398. 

  398.          */

    399. 

  399.         public static final String KEY_PARAM_VARIANT = "variant";

    400. 

  400. 

    401. 

  401.         /**

    402. 

  402.          * Parameter key to specify the audio stream type to be used when

    403. 

  403.          * speaking text or playing back a file.

    404. 

  404.          * 

    405. 

  405.          * @see TextToSpeechBeta#speak(String, int, HashMap)

    406. 

  406.          * @see TextToSpeechBeta#playEarcon(String, int, HashMap)

    407. 

  407.          */

    408. 

  408.         public static final String KEY_PARAM_STREAM = "streamType";

    409. 

  409. 

    410. 

  410.         /**

    411. 

  411.          * Parameter key to identify an utterance in the

    412. 

  412.          * {@link TextToSpeechBeta.OnUtteranceCompletedListener} after text has

    413. 

  413.          * been spoken, a file has been played back or a silence duration has

    414. 

  414.          * elapsed.

    415. 

  415.          * 

    416. 

  416.          * @see TextToSpeechBeta#speak(String, int, HashMap)

    417. 

  417.          * @see TextToSpeechBeta#playEarcon(String, int, HashMap)

    418. 

  418.          * @see TextToSpeechBeta#synthesizeToFile(String, HashMap, String)

    419. 

  419.          */

    420. 

  420.         public static final String KEY_PARAM_UTTERANCE_ID = "utteranceId";

    421. 

  421. 

    422. 

  422.         /**

    423. 

  423.          * Parameter key to specify the synthesis engine

    424. 

  424.          * 

    425. 

  425.          * @see TextToSpeechBeta#setEngineByPackageName(String)

    426. 

  426.          */

    427. 

  427.         public static final String KEY_PARAM_ENGINE = "engine";

    428. 

  428. 

    429. 

  429.         public static final String KEY_PARAM_PITCH = "pitch";

    430. 

  430. 

    431. 

  431.         // key positions in the array of cached parameters

    432. 

  432.         /**

    433. 

  433.          * {@hide}

    434. 

  434.          */

    435. 

  435.         protected static final int PARAM_POSITION_RATE = 0;

    436. 

  436. 

    437. 

  437.         /**

    438. 

  438.          * {@hide}

    439. 

  439.          */

    440. 

  440.         protected static final int PARAM_POSITION_LANGUAGE = 2;

    441. 

  441. 

    442. 

  442.         /**

    443. 

  443.          * {@hide}

    444. 

  444.          */

    445. 

  445.         protected static final int PARAM_POSITION_COUNTRY = 4;

    446. 

  446. 

    447. 

  447.         /**

    448. 

  448.          * {@hide}

    449. 

  449.          */

    450. 

  450.         protected static final int PARAM_POSITION_VARIANT = 6;

    451. 

  451. 

    452. 

  452.         /**

    453. 

  453.          * {@hide}

    454. 

  454.          */

    455. 

  455.         protected static final int PARAM_POSITION_STREAM = 8;

    456. 

  456. 

    457. 

  457.         /**

    458. 

  458.          * {@hide}

    459. 

  459.          */

    460. 

  460.         protected static final int PARAM_POSITION_UTTERANCE_ID = 10;

    461. 

  461. 

    462. 

  462.         /**

    463. 

  463.          * {@hide}

    464. 

  464.          */

    465. 

  465.         protected static final int PARAM_POSITION_ENGINE = 12;

    466. 

  466. 

    467. 

  467.         /**

    468. 

  468.          * {@hide}

    469. 

  469.          */

    470. 

  470.         protected static final int NB_CACHED_PARAMS = 7;

    471. 

  471.     }

    472. 

  472. 

    473. 

  473.     /**

    474. 

  474.      * Connection needed for the TTS.

    475. 

  475.      */

    476. 

  476.     private ServiceConnection mServiceConnection;

    477. 

  477. 

    478. 

  478.     private ITtsBeta mITts = null;

    479. 

  479. 

    480. 

  480.     private ITtsCallbackBeta mITtscallback = null;

    481. 

  481. 

    482. 

  482.     private Context mContext = null;

    483. 

  483. 

    484. 

  484.     private String mPackageName = "";

    485. 

  485. 

    486. 

  486.     private static OnInitListener mInitListener = null;

    487. 

  487. 

    488. 

  488.     private boolean mStarted = false;

    489. 

  489. 

    490. 

  490.     private final Object mStartLock = new Object();

    491. 

  491. 

    492. 

  492.     /**

    493. 

  493.      * Used to store the cached parameters sent along with each synthesis

    494. 

  494.      * request to the TTS service.

    495. 

  495.      */

    496. 

  496.     private String[] mCachedParams;

    497. 

  497. 

    498. 

  498.     static boolean ttsBetaInstalled = false;

    499. 

  499. 

    500. 

  500.     static TextToSpeech.OnInitListener platformOnInitListener = new TextToSpeech.OnInitListener() {

    501. 

  501.         public void onInit(int status) {

    502. 

  502.             if (!ttsBetaInstalled) {

    503. 

  503.                 if (mInitListener != null) {

    504. 

  504.                     mInitListener.onInit(status, -1);

    505. 

  505.                 }

    506. 

  506.             }

    507. 

  507.         }

    508. 

  508.     };

    509. 

  509. 

    510. 

  510.     /**

    511. 

  511.      * The constructor for the TextToSpeech class. This will also initialize the

    512. 

  512.      * associated TextToSpeech engine if it isn't already running.

    513. 

  513.      * 

    514. 

  514.      * @param context The context this instance is running in.

    515. 

  515.      * @param listener The {@link TextToSpeechBeta.OnInitListener} that will be

    516. 

  516.      *            called when the TextToSpeech engine has initialized.

    517. 

  517.      */

    518. 

  518.     public TextToSpeechBeta(Context context, OnInitListener listener) {

    519. 

  519.         super(context, platformOnInitListener);

    520. 

  520.         ttsBetaInstalled = isInstalled(context);

    521. 

  521.         mInitListener = listener;

    522. 

  522.         if (ttsBetaInstalled) {

    523. 

  523.             super.shutdown();

    524. 

  524.             mContext = context;

    525. 

  525.             mPackageName = mContext.getPackageName();

    526. 

  526. 

    527. 

  527.             mCachedParams = new String[2 * Engine.NB_CACHED_PARAMS]; // store

    528. 

  528.             // key and

    529. 

  529.             // value

    530. 

  530.             mCachedParams[Engine.PARAM_POSITION_RATE] = Engine.KEY_PARAM_RATE;

    531. 

  531.             mCachedParams[Engine.PARAM_POSITION_LANGUAGE] = Engine.KEY_PARAM_LANGUAGE;

    532. 

  532.             mCachedParams[Engine.PARAM_POSITION_COUNTRY] = Engine.KEY_PARAM_COUNTRY;

    533. 

  533.             mCachedParams[Engine.PARAM_POSITION_VARIANT] = Engine.KEY_PARAM_VARIANT;

    534. 

  534.             mCachedParams[Engine.PARAM_POSITION_STREAM] = Engine.KEY_PARAM_STREAM;

    535. 

  535.             mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID] = Engine.KEY_PARAM_UTTERANCE_ID;

    536. 

  536.             mCachedParams[Engine.PARAM_POSITION_ENGINE] = Engine.KEY_PARAM_ENGINE;

    537. 

  537. 

    538. 

  538.             mCachedParams[Engine.PARAM_POSITION_RATE + 1] = String.valueOf(Engine.DEFAULT_RATE);

    539. 

  539.             // initialize the language cached parameters with the current Locale

    540. 

  540.             Locale defaultLoc = Locale.getDefault();

    541. 

  541.             mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1] = defaultLoc.getISO3Language();

    542. 

  542.             mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1] = defaultLoc.getISO3Country();

    543. 

  543.             mCachedParams[Engine.PARAM_POSITION_VARIANT + 1] = defaultLoc.getVariant();

    544. 

  544. 

    545. 

  545.             mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = String.valueOf(Engine.DEFAULT_STREAM);

    546. 

  546.             mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = "";

    547. 

  547. 

    548. 

  548.             mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = "";

    549. 

  549. 

    550. 

  550.             initTts();

    551. 

  551.         }

    552. 

  552.     }

    553. 

  553. 

    554. 

  554.     private void initTts() {

    555. 

  555.         mStarted = false;

    556. 

  556. 

    557. 

  557.         // Initialize the TTS, run the callback after the binding is successful

    558. 

  558.         mServiceConnection = new ServiceConnection() {

    559. 

  559.             public void onServiceConnected(ComponentName name, IBinder service) {

    560. 

  560.                 synchronized (mStartLock) {

    561. 

  561.                     mITts = ITtsBeta.Stub.asInterface(service);

    562. 

  562.                     mStarted = true;

    563. 

  563.                     // Cache the default engine and current language

    564. 

  564.                     setEngineByPackageNameExtended(getDefaultEngineExtended());

    565. 

  565.                     setLanguage(getLanguage());

    566. 

  566.                     if (mInitListener != null) {

    567. 

  567.                         try {

    568. 

  568.                             PackageManager pm = mContext.getPackageManager();

    569. 

  569.                             PackageInfo info = pm.getPackageInfo("com.google.tts", 0);

    570. 

  570.                             mInitListener.onInit(SUCCESS, info.versionCode);

    571. 

  571.                         } catch (NameNotFoundException e) {

    572. 

  572.                             e.printStackTrace();

    573. 

  573.                         }

    574. 

  574.                     }

    575. 

  575.                 }

    576. 

  576.             }

    577. 

  577. 

    578. 

  578.             public void onServiceDisconnected(ComponentName name) {

    579. 

  579.                 synchronized (mStartLock) {

    580. 

  580.                     mITts = null;

    581. 

  581.                     mInitListener = null;

    582. 

  582.                     mStarted = false;

    583. 

  583.                 }

    584. 

  584.             }

    585. 

  585.         };

    586. 

  586. 

    587. 

  587.         // Remove "_BETA" tags when in framework

    588. 

  588.         Intent intent = new Intent("com.google.intent.action.START_TTS_SERVICE_BETA");

    589. 

  589.         intent.addCategory("com.google.intent.category.TTS_BETA");

    590. 

  590.         mContext.bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);

    591. 

  591.         // TODO handle case where the binding works (should always work) but

    592. 

  592.         // the plugin fails

    593. 

  593.     }

    594. 

  594. 

    595. 

  595.     /**

    596. 

  596.      * Releases the resources used by the TextToSpeech engine. It is good

    597. 

  597.      * practice for instance to call this method in the onDestroy() method of an

    598. 

  598.      * Activity so the TextToSpeech engine can be cleanly stopped.

    599. 

  599.      */

    600. 

  600.     public void shutdown() {

    601. 

  601.         if (!ttsBetaInstalled) {

    602. 

  602.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "shutdown");

    603. 

  603.             super.shutdown();

    604. 

  604.             return;

    605. 

  605.         }

    606. 

  606.         try {

    607. 

  607.             mContext.unbindService(mServiceConnection);

    608. 

  608.         } catch (IllegalArgumentException e) {

    609. 

  609.             // Do nothing and fail silently since an error here indicates that

    610. 

  610.             // binding never succeeded in the first place.

    611. 

  611.         }

    612. 

  612.     }

    613. 

  613. 

    614. 

  614.     /**

    615. 

  615.      * Adds a mapping between a string of text and a sound resource in a

    616. 

  616.      * package. After a call to this method, subsequent calls to

    617. 

  617.      * {@link #speak(String, int, HashMap)} will play the specified sound

    618. 

  618.      * resource if it is available, or synthesize the text it is missing.

    619. 

  619.      * 

    620. 

  620.      * @param text The string of text. Example: <code>"south_south_east"</code>

    621. 

  621.      * @param packagename Pass the packagename of the application that contains

    622. 

  622.      *            the resource. If the resource is in your own application (this

    623. 

  623.      *            is the most common case), then put the packagename of your

    624. 

  624.      *            application here.<br/>

    625. 

  625.      *            Example: <b>"com.google.marvin.compass"</b><br/>

    626. 

  626.      *            The packagename can be found in the AndroidManifest.xml of

    627. 

  627.      *            your application.

    628. 

  628.      *            <p>

    629. 

  629.      *            <code>&lt;manifest xmlns:android=&quot;...&quot;

    630. 

  630.      *      package=&quot;<b>com.google.marvin.compass</b>&quot;&gt;</code>

    631. 

  631.      *            </p>

    632. 

  632.      * @param resourceId Example: <code>R.raw.south_south_east</code>

    633. 

  633.      * @return Code indicating success or failure. See {@link #ERROR} and

    634. 

  634.      *         {@link #SUCCESS}.

    635. 

  635.      */

    636. 

  636.     public int addSpeech(String text, String packagename, int resourceId) {

    637. 

  637.         if (!ttsBetaInstalled) {

    638. 

  638.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "addSpeech");

    639. 

  639.             return super.addSpeech(text, packagename, resourceId);

    640. 

  640.         }

    641. 

  641.         synchronized (mStartLock) {

    642. 

  642.             if (!mStarted) {

    643. 

  643.                 return ERROR;

    644. 

  644.             }

    645. 

  645.             try {

    646. 

  646.                 mITts.addSpeech(mPackageName, text, packagename, resourceId);

    647. 

  647.                 return SUCCESS;

    648. 

  648.             } catch (RemoteException e) {

    649. 

  649.                 // TTS died; restart it.

    650. 

  650.                 Log.e("TextToSpeech.java - addSpeech", "RemoteException");

    651. 

  651.                 e.printStackTrace();

    652. 

  652.                 mStarted = false;

    653. 

  653.                 initTts();

    654. 

  654.             } catch (NullPointerException e) {

    655. 

  655.                 // TTS died; restart it.

    656. 

  656.                 Log.e("TextToSpeech.java - addSpeech", "NullPointerException");

    657. 

  657.                 e.printStackTrace();

    658. 

  658.                 mStarted = false;

    659. 

  659.                 initTts();

    660. 

  660.             } catch (IllegalStateException e) {

    661. 

  661.                 // TTS died; restart it.

    662. 

  662.                 Log.e("TextToSpeech.java - addSpeech", "IllegalStateException");

    663. 

  663.                 e.printStackTrace();

    664. 

  664.                 mStarted = false;

    665. 

  665.                 initTts();

    666. 

  666.             }

    667. 

  667.             return ERROR;

    668. 

  668.         }

    669. 

  669.     }

    670. 

  670. 

    671. 

  671.     /**

    672. 

  672.      * Adds a mapping between a string of text and a sound file. Using this, it

    673. 

  673.      * is possible to add custom pronounciations for a string of text. After a

    674. 

  674.      * call to this method, subsequent calls to

    675. 

  675.      * {@link #speak(String, int, HashMap)} will play the specified sound

    676. 

  676.      * resource if it is available, or synthesize the text it is missing.

    677. 

  677.      * 

    678. 

  678.      * @param text The string of text. Example: <code>"south_south_east"</code>

    679. 

  679.      * @param filename The full path to the sound file (for example:

    680. 

  680.      *            "/sdcard/mysounds/hello.wav")

    681. 

  681.      * @return Code indicating success or failure. See {@link #ERROR} and

    682. 

  682.      *         {@link #SUCCESS}.

    683. 

  683.      */

    684. 

  684.     public int addSpeech(String text, String filename) {

    685. 

  685.         if (!ttsBetaInstalled) {

    686. 

  686.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "addSpeech");

    687. 

  687.             return super.addSpeech(text, filename);

    688. 

  688.         }

    689. 

  689.         synchronized (mStartLock) {

    690. 

  690.             if (!mStarted) {

    691. 

  691.                 return ERROR;

    692. 

  692.             }

    693. 

  693.             try {

    694. 

  694.                 mITts.addSpeechFile(mPackageName, text, filename);

    695. 

  695.                 return SUCCESS;

    696. 

  696.             } catch (RemoteException e) {

    697. 

  697.                 // TTS died; restart it.

    698. 

  698.                 Log.e("TextToSpeech.java - addSpeech", "RemoteException");

    699. 

  699.                 e.printStackTrace();

    700. 

  700.                 mStarted = false;

    701. 

  701.                 initTts();

    702. 

  702.             } catch (NullPointerException e) {

    703. 

  703.                 // TTS died; restart it.

    704. 

  704.                 Log.e("TextToSpeech.java - addSpeech", "NullPointerException");

    705. 

  705.                 e.printStackTrace();

    706. 

  706.                 mStarted = false;

    707. 

  707.                 initTts();

    708. 

  708.             } catch (IllegalStateException e) {

    709. 

  709.                 // TTS died; restart it.

    710. 

  710.                 Log.e("TextToSpeech.java - addSpeech", "IllegalStateException");

    711. 

  711.                 e.printStackTrace();

    712. 

  712.                 mStarted = false;

    713. 

  713.                 initTts();

    714. 

  714.             }

    715. 

  715.             return ERROR;

    716. 

  716.         }

    717. 

  717.     }

    718. 

  718. 

    719. 

  719.     /**

    720. 

  720.      * Adds a mapping between a string of text and a sound resource in a

    721. 

  721.      * package. Use this to add custom earcons.

    722. 

  722.      * 

    723. 

  723.      * @see #playEarcon(String, int, HashMap)

    724. 

  724.      * @param earcon The name of the earcon. Example: <code>"[tick]"</code><br/>

    725. 

  725.      * @param packagename the package name of the application that contains the

    726. 

  726.      *            resource. This can for instance be the package name of your

    727. 

  727.      *            own application. Example: <b>"com.google.marvin.compass"</b><br/>

    728. 

  728.      *            The package name can be found in the AndroidManifest.xml of

    729. 

  729.      *            the application containing the resource.

    730. 

  730.      *            <p>

    731. 

  731.      *            <code>&lt;manifest xmlns:android=&quot;...&quot;

    732. 

  732.      *      package=&quot;<b>com.google.marvin.compass</b>&quot;&gt;</code>

    733. 

  733.      *            </p>

    734. 

  734.      * @param resourceId Example: <code>R.raw.tick_snd</code>

    735. 

  735.      * @return Code indicating success or failure. See {@link #ERROR} and

    736. 

  736.      *         {@link #SUCCESS}.

    737. 

  737.      */

    738. 

  738.     public int addEarcon(String earcon, String packagename, int resourceId) {

    739. 

  739.         if (!ttsBetaInstalled) {

    740. 

  740.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "addEarcon");

    741. 

  741.             return super.addEarcon(earcon, packagename, resourceId);

    742. 

  742.         }

    743. 

  743.         synchronized (mStartLock) {

    744. 

  744.             if (!mStarted) {

    745. 

  745.                 return ERROR;

    746. 

  746.             }

    747. 

  747.             try {

    748. 

  748.                 mITts.addEarcon(mPackageName, earcon, packagename, resourceId);

    749. 

  749.                 return SUCCESS;

    750. 

  750.             } catch (RemoteException e) {

    751. 

  751.                 // TTS died; restart it.

    752. 

  752.                 Log.e("TextToSpeech.java - addEarcon", "RemoteException");

    753. 

  753.                 e.printStackTrace();

    754. 

  754.                 mStarted = false;

    755. 

  755.                 initTts();

    756. 

  756.             } catch (NullPointerException e) {

    757. 

  757.                 // TTS died; restart it.

    758. 

  758.                 Log.e("TextToSpeech.java - addEarcon", "NullPointerException");

    759. 

  759.                 e.printStackTrace();

    760. 

  760.                 mStarted = false;

    761. 

  761.                 initTts();

    762. 

  762.             } catch (IllegalStateException e) {

    763. 

  763.                 // TTS died; restart it.

    764. 

  764.                 Log.e("TextToSpeech.java - addEarcon", "IllegalStateException");

    765. 

  765.                 e.printStackTrace();

    766. 

  766.                 mStarted = false;

    767. 

  767.                 initTts();

    768. 

  768.             }

    769. 

  769.             return ERROR;

    770. 

  770.         }

    771. 

  771.     }

    772. 

  772. 

    773. 

  773.     /**

    774. 

  774.      * Adds a mapping between a string of text and a sound file. Use this to add

    775. 

  775.      * custom earcons.

    776. 

  776.      * 

    777. 

  777.      * @see #playEarcon(String, int, HashMap)

    778. 

  778.      * @param earcon The name of the earcon. Example: <code>"[tick]"</code>

    779. 

  779.      * @param filename The full path to the sound file (for example:

    780. 

  780.      *            "/sdcard/mysounds/tick.wav")

    781. 

  781.      * @return Code indicating success or failure. See {@link #ERROR} and

    782. 

  782.      *         {@link #SUCCESS}.

    783. 

  783.      */

    784. 

  784.     public int addEarcon(String earcon, String filename) {

    785. 

  785.         if (!ttsBetaInstalled) {

    786. 

  786.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "addEarcon");

    787. 

  787.             return super.addEarcon(earcon, filename);

    788. 

  788.         }

    789. 

  789.         synchronized (mStartLock) {

    790. 

  790.             if (!mStarted) {

    791. 

  791.                 return ERROR;

    792. 

  792.             }

    793. 

  793.             try {

    794. 

  794.                 mITts.addEarconFile(mPackageName, earcon, filename);

    795. 

  795.                 return SUCCESS;

    796. 

  796.             } catch (RemoteException e) {

    797. 

  797.                 // TTS died; restart it.

    798. 

  798.                 Log.e("TextToSpeech.java - addEarcon", "RemoteException");

    799. 

  799.                 e.printStackTrace();

    800. 

  800.                 mStarted = false;

    801. 

  801.                 initTts();

    802. 

  802.             } catch (NullPointerException e) {

    803. 

  803.                 // TTS died; restart it.

    804. 

  804.                 Log.e("TextToSpeech.java - addEarcon", "NullPointerException");

    805. 

  805.                 e.printStackTrace();

    806. 

  806.                 mStarted = false;

    807. 

  807.                 initTts();

    808. 

  808.             } catch (IllegalStateException e) {

    809. 

  809.                 // TTS died; restart it.

    810. 

  810.                 Log.e("TextToSpeech.java - addEarcon", "IllegalStateException");

    811. 

  811.                 e.printStackTrace();

    812. 

  812.                 mStarted = false;

    813. 

  813.                 initTts();

    814. 

  814.             }

    815. 

  815.             return ERROR;

    816. 

  816.         }

    817. 

  817.     }

    818. 

  818. 

    819. 

  819.     /**

    820. 

  820.      * Speaks the string using the specified queuing strategy and speech

    821. 

  821.      * parameters.

    822. 

  822.      * 

    823. 

  823.      * @param text The string of text to be spoken.

    824. 

  824.      * @param queueMode The queuing strategy to use. {@link #QUEUE_ADD} or

    825. 

  825.      *            {@link #QUEUE_FLUSH}.

    826. 

  826.      * @param params The list of parameters to be used. Can be null if no

    827. 

  827.      *            parameters are given. They are specified using a (key, value)

    828. 

  828.      *            pair, where the key can be {@link Engine#KEY_PARAM_STREAM} or

    829. 

  829.      *            {@link Engine#KEY_PARAM_UTTERANCE_ID}.

    830. 

  830.      * @return Code indicating success or failure. See {@link #ERROR} and

    831. 

  831.      *         {@link #SUCCESS}.

    832. 

  832.      */

    833. 

  833.     public int speak(String text, int queueMode, HashMap<String, String> params) {

    834. 

  834.         if (!ttsBetaInstalled) {

    835. 

  835.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "speak");

    836. 

  836.             return super.speak(text, queueMode, params);

    837. 

  837.         }

    838. 

  838.         synchronized (mStartLock) {

    839. 

  839.             int result = ERROR;

    840. 

  840.             Log.i("TTS received: ", text);

    841. 

  841.             if (!mStarted) {

    842. 

  842.                 return result;

    843. 

  843.             }

    844. 

  844.             try {

    845. 

  845.                 if ((params != null) && (!params.isEmpty())) {

    846. 

  846.                     String extra = params.get(Engine.KEY_PARAM_STREAM);

    847. 

  847.                     if (extra != null) {

    848. 

  848.                         mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = extra;

    849. 

  849.                     }

    850. 

  850.                     extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);

    851. 

  851.                     if (extra != null) {

    852. 

  852.                         mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;

    853. 

  853.                     }

    854. 

  854.                     extra = params.get(Engine.KEY_PARAM_ENGINE);

    855. 

  855.                     if (extra != null) {

    856. 

  856.                         mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = extra;

    857. 

  857.                     }

    858. 

  858.                 }

    859. 

  859.                 result = mITts.speak(mPackageName, text, queueMode, mCachedParams);

    860. 

  860.             } catch (RemoteException e) {

    861. 

  861.                 // TTS died; restart it.

    862. 

  862.                 Log.e("TextToSpeech.java - speak", "RemoteException");

    863. 

  863.                 e.printStackTrace();

    864. 

  864.                 mStarted = false;

    865. 

  865.                 initTts();

    866. 

  866.             } catch (NullPointerException e) {

    867. 

  867.                 // TTS died; restart it.

    868. 

  868.                 Log.e("TextToSpeech.java - speak", "NullPointerException");

    869. 

  869.                 e.printStackTrace();

    870. 

  870.                 mStarted = false;

    871. 

  871.                 initTts();

    872. 

  872.             } catch (IllegalStateException e) {

    873. 

  873.                 // TTS died; restart it.

    874. 

  874.                 Log.e("TextToSpeech.java - speak", "IllegalStateException");

    875. 

  875.                 e.printStackTrace();

    876. 

  876.                 mStarted = false;

    877. 

  877.                 initTts();

    878. 

  878.             } finally {

    879. 

  879.                 resetCachedParams();

    880. 

  880.                 return result;

    881. 

  881.             }

    882. 

  882.         }

    883. 

  883.     }

    884. 

  884. 

    885. 

  885.     /**

    886. 

  886.      * Plays the earcon using the specified queueing mode and parameters.

    887. 

  887.      * 

    888. 

  888.      * @param earcon The earcon that should be played

    889. 

  889.      * @param queueMode {@link #QUEUE_ADD} or {@link #QUEUE_FLUSH}.

    890. 

  890.      * @param params The list of parameters to be used. Can be null if no

    891. 

  891.      *            parameters are given. They are specified using a (key, value)

    892. 

  892.      *            pair, where the key can be {@link Engine#KEY_PARAM_STREAM} or

    893. 

  893.      *            {@link Engine#KEY_PARAM_UTTERANCE_ID}.

    894. 

  894.      * @return Code indicating success or failure. See {@link #ERROR} and

    895. 

  895.      *         {@link #SUCCESS}.

    896. 

  896.      */

    897. 

  897.     public int playEarcon(String earcon, int queueMode, HashMap<String, String> params) {

    898. 

  898.         if (!ttsBetaInstalled) {

    899. 

  899.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "playEarcon");

    900. 

  900.             return super.playEarcon(earcon, queueMode, params);

    901. 

  901.         }

    902. 

  902.         synchronized (mStartLock) {

    903. 

  903.             int result = ERROR;

    904. 

  904.             if (!mStarted) {

    905. 

  905.                 return result;

    906. 

  906.             }

    907. 

  907.             try {

    908. 

  908.                 if ((params != null) && (!params.isEmpty())) {

    909. 

  909.                     String extra = params.get(Engine.KEY_PARAM_STREAM);

    910. 

  910.                     if (extra != null) {

    911. 

  911.                         mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = extra;

    912. 

  912.                     }

    913. 

  913.                     extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);

    914. 

  914.                     if (extra != null) {

    915. 

  915.                         mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;

    916. 

  916.                     }

    917. 

  917.                 }

    918. 

  918.                 result = mITts.playEarcon(mPackageName, earcon, queueMode, null);

    919. 

  919.             } catch (RemoteException e) {

    920. 

  920.                 // TTS died; restart it.

    921. 

  921.                 Log.e("TextToSpeech.java - playEarcon", "RemoteException");

    922. 

  922.                 e.printStackTrace();

    923. 

  923.                 mStarted = false;

    924. 

  924.                 initTts();

    925. 

  925.             } catch (NullPointerException e) {

    926. 

  926.                 // TTS died; restart it.

    927. 

  927.                 Log.e("TextToSpeech.java - playEarcon", "NullPointerException");

    928. 

  928.                 e.printStackTrace();

    929. 

  929.                 mStarted = false;

    930. 

  930.                 initTts();

    931. 

  931.             } catch (IllegalStateException e) {

    932. 

  932.                 // TTS died; restart it.

    933. 

  933.                 Log.e("TextToSpeech.java - playEarcon", "IllegalStateException");

    934. 

  934.                 e.printStackTrace();

    935. 

  935.                 mStarted = false;

    936. 

  936.                 initTts();

    937. 

  937.             } finally {

    938. 

  938.                 resetCachedParams();

    939. 

  939.                 return result;

    940. 

  940.             }

    941. 

  941.         }

    942. 

  942.     }

    943. 

  943. 

    944. 

  944.     /**

    945. 

  945.      * Plays silence for the specified amount of time using the specified queue

    946. 

  946.      * mode.

    947. 

  947.      * 

    948. 

  948.      * @param durationInMs A long that indicates how long the silence should

    949. 

  949.      *            last.

    950. 

  950.      * @param queueMode {@link #QUEUE_ADD} or {@link #QUEUE_FLUSH}.

    951. 

  951.      * @param params The list of parameters to be used. Can be null if no

    952. 

  952.      *            parameters are given. They are specified using a (key, value)

    953. 

  953.      *            pair, where the key can be

    954. 

  954.      *            {@link Engine#KEY_PARAM_UTTERANCE_ID}.

    955. 

  955.      * @return Code indicating success or failure. See {@link #ERROR} and

    956. 

  956.      *         {@link #SUCCESS}.

    957. 

  957.      */

    958. 

  958.     public int playSilence(long durationInMs, int queueMode, HashMap<String, String> params) {

    959. 

  959.         if (!ttsBetaInstalled) {

    960. 

  960.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "playSilence");

    961. 

  961.             return super.playSilence(durationInMs, queueMode, params);

    962. 

  962.         }

    963. 

  963.         synchronized (mStartLock) {

    964. 

  964.             int result = ERROR;

    965. 

  965.             if (!mStarted) {

    966. 

  966.                 return result;

    967. 

  967.             }

    968. 

  968.             try {

    969. 

  969.                 if ((params != null) && (!params.isEmpty())) {

    970. 

  970.                     String extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);

    971. 

  971.                     if (extra != null) {

    972. 

  972.                         mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;

    973. 

  973.                     }

    974. 

  974.                 }

    975. 

  975.                 result = mITts.playSilence(mPackageName, durationInMs, queueMode, mCachedParams);

    976. 

  976.             } catch (RemoteException e) {

    977. 

  977.                 // TTS died; restart it.

    978. 

  978.                 Log.e("TextToSpeech.java - playSilence", "RemoteException");

    979. 

  979.                 e.printStackTrace();

    980. 

  980.                 mStarted = false;

    981. 

  981.                 initTts();

    982. 

  982.             } catch (NullPointerException e) {

    983. 

  983.                 // TTS died; restart it.

    984. 

  984.                 Log.e("TextToSpeech.java - playSilence", "NullPointerException");

    985. 

  985.                 e.printStackTrace();

    986. 

  986.                 mStarted = false;

    987. 

  987.                 initTts();

    988. 

  988.             } catch (IllegalStateException e) {

    989. 

  989.                 // TTS died; restart it.

    990. 

  990.                 Log.e("TextToSpeech.java - playSilence", "IllegalStateException");

    991. 

  991.                 e.printStackTrace();

    992. 

  992.                 mStarted = false;

    993. 

  993.                 initTts();

    994. 

  994.             } finally {

    995. 

  995.                 return result;

    996. 

  996.             }

    997. 

  997.         }

    998. 

  998.     }

    999. 

  999. 

    1000. 

  1000.     /**

    1001. 

  1001.      * Returns whether or not the TextToSpeech engine is busy speaking.

    1002. 

  1002.      * 

    1003. 

  1003.      * @return Whether or not the TextToSpeech engine is busy speaking.

    1004. 

  1004.      */

    1005. 

  1005.     public boolean isSpeaking() {

    1006. 

  1006.         if (!ttsBetaInstalled) {

    1007. 

  1007.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "isSpeaking");

    1008. 

  1008.             return super.isSpeaking();

    1009. 

  1009.         }

    1010. 

  1010.         synchronized (mStartLock) {

    1011. 

  1011.             if (!mStarted) {

    1012. 

  1012.                 return false;

    1013. 

  1013.             }

    1014. 

  1014.             try {

    1015. 

  1015.                 return mITts.isSpeaking();

    1016. 

  1016.             } catch (RemoteException e) {

    1017. 

  1017.                 // TTS died; restart it.

    1018. 

  1018.                 Log.e("TextToSpeech.java - isSpeaking", "RemoteException");

    1019. 

  1019.                 e.printStackTrace();

    1020. 

  1020.                 mStarted = false;

    1021. 

  1021.                 initTts();

    1022. 

  1022.             } catch (NullPointerException e) {

    1023. 

  1023.                 // TTS died; restart it.

    1024. 

  1024.                 Log.e("TextToSpeech.java - isSpeaking", "NullPointerException");

    1025. 

  1025.                 e.printStackTrace();

    1026. 

  1026.                 mStarted = false;

    1027. 

  1027.                 initTts();

    1028. 

  1028.             } catch (IllegalStateException e) {

    1029. 

  1029.                 // TTS died; restart it.

    1030. 

  1030.                 Log.e("TextToSpeech.java - isSpeaking", "IllegalStateException");

    1031. 

  1031.                 e.printStackTrace();

    1032. 

  1032.                 mStarted = false;

    1033. 

  1033.                 initTts();

    1034. 

  1034.             }

    1035. 

  1035.             return false;

    1036. 

  1036.         }

    1037. 

  1037.     }

    1038. 

  1038. 

    1039. 

  1039.     /**

    1040. 

  1040.      * Interrupts the current utterance (whether played or rendered to file) and

    1041. 

  1041.      * discards other utterances in the queue.

    1042. 

  1042.      * 

    1043. 

  1043.      * @return Code indicating success or failure. See {@link #ERROR} and

    1044. 

  1044.      *         {@link #SUCCESS}.

    1045. 

  1045.      */

    1046. 

  1046.     public int stop() {

    1047. 

  1047.         if (!ttsBetaInstalled) {

    1048. 

  1048.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "stop");

    1049. 

  1049.             return super.stop();

    1050. 

  1050.         }

    1051. 

  1051.         synchronized (mStartLock) {

    1052. 

  1052.             int result = ERROR;

    1053. 

  1053.             if (!mStarted) {

    1054. 

  1054.                 return result;

    1055. 

  1055.             }

    1056. 

  1056.             try {

    1057. 

  1057.                 result = mITts.stop(mPackageName);

    1058. 

  1058.             } catch (RemoteException e) {

    1059. 

  1059.                 // TTS died; restart it.

    1060. 

  1060.                 Log.e("TextToSpeech.java - stop", "RemoteException");

    1061. 

  1061.                 e.printStackTrace();

    1062. 

  1062.                 mStarted = false;

    1063. 

  1063.                 initTts();

    1064. 

  1064.             } catch (NullPointerException e) {

    1065. 

  1065.                 // TTS died; restart it.

    1066. 

  1066.                 Log.e("TextToSpeech.java - stop", "NullPointerException");

    1067. 

  1067.                 e.printStackTrace();

    1068. 

  1068.                 mStarted = false;

    1069. 

  1069.                 initTts();

    1070. 

  1070.             } catch (IllegalStateException e) {

    1071. 

  1071.                 // TTS died; restart it.

    1072. 

  1072.                 Log.e("TextToSpeech.java - stop", "IllegalStateException");

    1073. 

  1073.                 e.printStackTrace();

    1074. 

  1074.                 mStarted = false;

    1075. 

  1075.                 initTts();

    1076. 

  1076.             } finally {

    1077. 

  1077.                 return result;

    1078. 

  1078.             }

    1079. 

  1079.         }

    1080. 

  1080.     }

    1081. 

  1081. 

    1082. 

  1082.     /**

    1083. 

  1083.      * Sets the speech rate for the TextToSpeech engine. This has no effect on

    1084. 

  1084.      * any pre-recorded speech.

    1085. 

  1085.      * 

    1086. 

  1086.      * @param speechRate The speech rate for the TextToSpeech engine. 1 is the

    1087. 

  1087.      *            normal speed, lower values slow down the speech (0.5 is half

    1088. 

  1088.      *            the normal speech rate), greater values accelerate it (2 is

    1089. 

  1089.      *            twice the normal speech rate).

    1090. 

  1090.      * @return Code indicating success or failure. See {@link #ERROR} and

    1091. 

  1091.      *         {@link #SUCCESS}.

    1092. 

  1092.      */

    1093. 

  1093.     public int setSpeechRate(float speechRate) {

    1094. 

  1094.         if (!ttsBetaInstalled) {

    1095. 

  1095.             Log.d("TextToSpeechBeta",

    1096. 

  1096.                     "TextToSpeechBeta not installed - defaulting to basic platform TextToSpeech");

    1097. 

  1097.             return super.setSpeechRate(speechRate);

    1098. 

  1098.         }

    1099. 

  1099.         synchronized (mStartLock) {

    1100. 

  1100.             int result = ERROR;

    1101. 

  1101.             if (!mStarted) {

    1102. 

  1102.                 return result;

    1103. 

  1103.             }

    1104. 

  1104.             try {

    1105. 

  1105.                 if (speechRate > 0) {

    1106. 

  1106.                     int rate = (int) (speechRate * 100);

    1107. 

  1107.                     mCachedParams[Engine.PARAM_POSITION_RATE + 1] = String.valueOf(rate);

    1108. 

  1108.                     // the rate is not set here, instead it is cached so it will

    1109. 

  1109.                     // be

    1110. 

  1110.                     // associated

    1111. 

  1111.                     // with all upcoming utterances.

    1112. 

  1112.                     if (speechRate > 0.0f) {

    1113. 

  1113.                         result = SUCCESS;

    1114. 

  1114.                     } else {

    1115. 

  1115.                         result = ERROR;

    1116. 

  1116.                     }

    1117. 

  1117.                 }

    1118. 

  1118.             } catch (NullPointerException e) {

    1119. 

  1119.                 // TTS died; restart it.

    1120. 

  1120.                 Log.e("TextToSpeech.java - setSpeechRate", "NullPointerException");

    1121. 

  1121.                 e.printStackTrace();

    1122. 

  1122.                 mStarted = false;

    1123. 

  1123.                 initTts();

    1124. 

  1124.             } catch (IllegalStateException e) {

    1125. 

  1125.                 // TTS died; restart it.

    1126. 

  1126.                 Log.e("TextToSpeech.java - setSpeechRate", "IllegalStateException");

    1127. 

  1127.                 e.printStackTrace();

    1128. 

  1128.                 mStarted = false;

    1129. 

  1129.                 initTts();

    1130. 

  1130.             } finally {

    1131. 

  1131.                 return result;

    1132. 

  1132.             }

    1133. 

  1133.         }

    1134. 

  1134.     }

    1135. 

  1135. 

    1136. 

  1136.     /**

    1137. 

  1137.      * Sets the speech pitch for the TextToSpeech engine. This has no effect on

    1138. 

  1138.      * any pre-recorded speech.

    1139. 

  1139.      * 

    1140. 

  1140.      * @param pitch The pitch for the TextToSpeech engine. 1 is the normal

    1141. 

  1141.      *            pitch, lower values lower the tone of the synthesized voice,

    1142. 

  1142.      *            greater values increase it.

    1143. 

  1143.      * @return Code indicating success or failure. See {@link #ERROR} and

    1144. 

  1144.      *         {@link #SUCCESS}.

    1145. 

  1145.      */

    1146. 

  1146.     public int setPitch(float pitch) {

    1147. 

  1147.         if (!ttsBetaInstalled) {

    1148. 

  1148.             Log.d("TextToSpeechBeta",

    1149. 

  1149.                     "TextToSpeechBeta not installed - defaulting to basic platform TextToSpeech");

    1150. 

  1150.             return super.setPitch(pitch);

    1151. 

  1151.         }

    1152. 

  1152.         synchronized (mStartLock) {

    1153. 

  1153.             int result = ERROR;

    1154. 

  1154.             if (!mStarted) {

    1155. 

  1155.                 return result;

    1156. 

  1156.             }

    1157. 

  1157.             try {

    1158. 

  1158.                 if (pitch > 0) {

    1159. 

  1159.                     result = mITts.setPitch(mPackageName, (int) (pitch * 100));

    1160. 

  1160.                 }

    1161. 

  1161.             } catch (RemoteException e) {

    1162. 

  1162.                 // TTS died; restart it.

    1163. 

  1163.                 Log.e("TextToSpeech.java - setPitch", "RemoteException");

    1164. 

  1164.                 e.printStackTrace();

    1165. 

  1165.                 mStarted = false;

    1166. 

  1166.                 initTts();

    1167. 

  1167.             } catch (NullPointerException e) {

    1168. 

  1168.                 // TTS died; restart it.

    1169. 

  1169.                 Log.e("TextToSpeech.java - setPitch", "NullPointerException");

    1170. 

  1170.                 e.printStackTrace();

    1171. 

  1171.                 mStarted = false;

    1172. 

  1172.                 initTts();

    1173. 

  1173.             } catch (IllegalStateException e) {

    1174. 

  1174.                 // TTS died; restart it.

    1175. 

  1175.                 Log.e("TextToSpeech.java - setPitch", "IllegalStateException");

    1176. 

  1176.                 e.printStackTrace();

    1177. 

  1177.                 mStarted = false;

    1178. 

  1178.                 initTts();

    1179. 

  1179.             } finally {

    1180. 

  1180.                 return result;

    1181. 

  1181.             }

    1182. 

  1182.         }

    1183. 

  1183.     }

    1184. 

  1184. 

    1185. 

  1185.     /**

    1186. 

  1186.      * Sets the language for the TextToSpeech engine. The TextToSpeech engine

    1187. 

  1187.      * will try to use the closest match to the specified language as

    1188. 

  1188.      * represented by the Locale, but there is no guarantee that the exact same

    1189. 

  1189.      * Locale will be used. Use {@link #isLanguageAvailable(Locale)} to check

    1190. 

  1190.      * the level of support before choosing the language to use for the next

    1191. 

  1191.      * utterances.

    1192. 

  1192.      * 

    1193. 

  1193.      * @param loc The locale describing the language to be used.

    1194. 

  1194.      * @return code indicating the support status for the locale. See

    1195. 

  1195.      *         {@link #LANG_AVAILABLE}, {@link #LANG_COUNTRY_AVAILABLE},

    1196. 

  1196.      *         {@link #LANG_COUNTRY_VAR_AVAILABLE}, {@link #LANG_MISSING_DATA}

    1197. 

  1197.      *         and {@link #LANG_NOT_SUPPORTED}.

    1198. 

  1198.      */

    1199. 

  1199.     public int setLanguage(Locale loc) {

    1200. 

  1200.         if (!ttsBetaInstalled) {

    1201. 

  1201.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "setLanguage");

    1202. 

  1202.             return super.setLanguage(loc);

    1203. 

  1203.         }

    1204. 

  1204.         synchronized (mStartLock) {

    1205. 

  1205.             int result = LANG_NOT_SUPPORTED;

    1206. 

  1206.             if (!mStarted) {

    1207. 

  1207.                 return result;

    1208. 

  1208.             }

    1209. 

  1209.             try {

    1210. 

  1210.                 mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1] = loc.getISO3Language();

    1211. 

  1211.                 mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1] = loc.getISO3Country();

    1212. 

  1212.                 mCachedParams[Engine.PARAM_POSITION_VARIANT + 1] = loc.getVariant();

    1213. 

  1213.                 // the language is not set here, instead it is cached so it will

    1214. 

  1214.                 // be

    1215. 

  1215.                 // associated

    1216. 

  1216.                 // with all upcoming utterances. But we still need to report the

    1217. 

  1217.                 // language support,

    1218. 

  1218.                 // which is achieved by calling isLanguageAvailable()

    1219. 

  1219.                 result = mITts.isLanguageAvailable(

    1220. 

  1220.                         mCachedParams[Engine.PARAM_POSITION_LANGUAGE + 1],

    1221. 

  1221.                         mCachedParams[Engine.PARAM_POSITION_COUNTRY + 1],

    1222. 

  1222.                         mCachedParams[Engine.PARAM_POSITION_VARIANT + 1], mCachedParams);

    1223. 

  1223.             } catch (RemoteException e) {

    1224. 

  1224.                 // TTS died; restart it.

    1225. 

  1225.                 Log.e("TextToSpeech.java - setLanguage", "RemoteException");

    1226. 

  1226.                 e.printStackTrace();

    1227. 

  1227.                 mStarted = false;

    1228. 

  1228.                 initTts();

    1229. 

  1229.             } catch (NullPointerException e) {

    1230. 

  1230.                 // TTS died; restart it.

    1231. 

  1231.                 Log.e("TextToSpeech.java - setLanguage", "NullPointerException");

    1232. 

  1232.                 e.printStackTrace();

    1233. 

  1233.                 mStarted = false;

    1234. 

  1234.                 initTts();

    1235. 

  1235.             } catch (IllegalStateException e) {

    1236. 

  1236.                 // TTS died; restart it.

    1237. 

  1237.                 Log.e("TextToSpeech.java - setLanguage", "IllegalStateException");

    1238. 

  1238.                 e.printStackTrace();

    1239. 

  1239.                 mStarted = false;

    1240. 

  1240.                 initTts();

    1241. 

  1241.             } finally {

    1242. 

  1242.                 return result;

    1243. 

  1243.             }

    1244. 

  1244.         }

    1245. 

  1245.     }

    1246. 

  1246. 

    1247. 

  1247.     /**

    1248. 

  1248.      * Returns a Locale instance describing the language currently being used by

    1249. 

  1249.      * the TextToSpeech engine.

    1250. 

  1250.      * 

    1251. 

  1251.      * @return language, country (if any) and variant (if any) used by the

    1252. 

  1252.      *         engine stored in a Locale instance, or null is the TextToSpeech

    1253. 

  1253.      *         engine has failed.

    1254. 

  1254.      */

    1255. 

  1255.     public Locale getLanguage() {

    1256. 

  1256.         if (!ttsBetaInstalled) {

    1257. 

  1257.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "getLanguage");

    1258. 

  1258.             return super.getLanguage();

    1259. 

  1259.         }

    1260. 

  1260.         synchronized (mStartLock) {

    1261. 

  1261.             if (!mStarted) {

    1262. 

  1262.                 return null;

    1263. 

  1263.             }

    1264. 

  1264.             try {

    1265. 

  1265.                 String[] locStrings = mITts.getLanguage();

    1266. 

  1266.                 if ((locStrings != null) && (locStrings.length == 3)) {

    1267. 

  1267.                     return new Locale(locStrings[0], locStrings[1], locStrings[2]);

    1268. 

  1268.                 } else {

    1269. 

  1269.                     return null;

    1270. 

  1270.                 }

    1271. 

  1271.             } catch (RemoteException e) {

    1272. 

  1272.                 // TTS died; restart it.

    1273. 

  1273.                 Log.e("TextToSpeech.java - getLanguage", "RemoteException");

    1274. 

  1274.                 e.printStackTrace();

    1275. 

  1275.                 mStarted = false;

    1276. 

  1276.                 initTts();

    1277. 

  1277.             } catch (NullPointerException e) {

    1278. 

  1278.                 // TTS died; restart it.

    1279. 

  1279.                 Log.e("TextToSpeech.java - getLanguage", "NullPointerException");

    1280. 

  1280.                 e.printStackTrace();

    1281. 

  1281.                 mStarted = false;

    1282. 

  1282.                 initTts();

    1283. 

  1283.             } catch (IllegalStateException e) {

    1284. 

  1284.                 // TTS died; restart it.

    1285. 

  1285.                 Log.e("TextToSpeech.java - getLanguage", "IllegalStateException");

    1286. 

  1286.                 e.printStackTrace();

    1287. 

  1287.                 mStarted = false;

    1288. 

  1288.                 initTts();

    1289. 

  1289.             }

    1290. 

  1290.             return null;

    1291. 

  1291.         }

    1292. 

  1292.     }

    1293. 

  1293. 

    1294. 

  1294.     /**

    1295. 

  1295.      * Checks if the specified language as represented by the Locale is

    1296. 

  1296.      * available and supported.

    1297. 

  1297.      * 

    1298. 

  1298.      * @param loc The Locale describing the language to be used.

    1299. 

  1299.      * @return code indicating the support status for the locale. See

    1300. 

  1300.      *         {@link #LANG_AVAILABLE}, {@link #LANG_COUNTRY_AVAILABLE},

    1301. 

  1301.      *         {@link #LANG_COUNTRY_VAR_AVAILABLE}, {@link #LANG_MISSING_DATA}

    1302. 

  1302.      *         and {@link #LANG_NOT_SUPPORTED}.

    1303. 

  1303.      */

    1304. 

  1304.     public int isLanguageAvailable(Locale loc) {

    1305. 

  1305.         if (!ttsBetaInstalled) {

    1306. 

  1306.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "isLanguageAvailable");

    1307. 

  1307.             return super.isLanguageAvailable(loc);

    1308. 

  1308.         }

    1309. 

  1309.         synchronized (mStartLock) {

    1310. 

  1310.             int result = LANG_NOT_SUPPORTED;

    1311. 

  1311.             if (!mStarted) {

    1312. 

  1312.                 return result;

    1313. 

  1313.             }

    1314. 

  1314.             try {

    1315. 

  1315.                 result = mITts.isLanguageAvailable(loc.getISO3Language(), loc.getISO3Country(), loc

    1316. 

  1316.                         .getVariant(), mCachedParams);

    1317. 

  1317.             } catch (RemoteException e) {

    1318. 

  1318.                 // TTS died; restart it.

    1319. 

  1319.                 Log.e("TextToSpeech.java - isLanguageAvailable", "RemoteException");

    1320. 

  1320.                 e.printStackTrace();

    1321. 

  1321.                 mStarted = false;

    1322. 

  1322.                 initTts();

    1323. 

  1323.             } catch (NullPointerException e) {

    1324. 

  1324.                 // TTS died; restart it.

    1325. 

  1325.                 Log.e("TextToSpeech.java - isLanguageAvailable", "NullPointerException");

    1326. 

  1326.                 e.printStackTrace();

    1327. 

  1327.                 mStarted = false;

    1328. 

  1328.                 initTts();

    1329. 

  1329.             } catch (IllegalStateException e) {

    1330. 

  1330.                 // TTS died; restart it.

    1331. 

  1331.                 Log.e("TextToSpeech.java - isLanguageAvailable", "IllegalStateException");

    1332. 

  1332.                 e.printStackTrace();

    1333. 

  1333.                 mStarted = false;

    1334. 

  1334.                 initTts();

    1335. 

  1335.             } finally {

    1336. 

  1336.                 return result;

    1337. 

  1337.             }

    1338. 

  1338.         }

    1339. 

  1339.     }

    1340. 

  1340. 

    1341. 

  1341.     /**

    1342. 

  1342.      * Synthesizes the given text to a file using the specified parameters.

    1343. 

  1343.      * 

    1344. 

  1344.      * @param text The String of text that should be synthesized

    1345. 

  1345.      * @param params The list of parameters to be used. Can be null if no

    1346. 

  1346.      *            parameters are given. They are specified using a (key, value)

    1347. 

  1347.      *            pair, where the key can be

    1348. 

  1348.      *            {@link Engine#KEY_PARAM_UTTERANCE_ID}.

    1349. 

  1349.      * @param filename The string that gives the full output filename; it should

    1350. 

  1350.      *            be something like "/sdcard/myappsounds/mysound.wav".

    1351. 

  1351.      * @return Code indicating success or failure. See {@link #ERROR} and

    1352. 

  1352.      *         {@link #SUCCESS}.

    1353. 

  1353.      */

    1354. 

  1354.     public int synthesizeToFile(String text, HashMap<String, String> params, String filename) {

    1355. 

  1355.         if (!ttsBetaInstalled) {

    1356. 

  1356.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "synthesizeToFile");

    1357. 

  1357.             return super.synthesizeToFile(text, params, filename);

    1358. 

  1358.         }

    1359. 

  1359.         synchronized (mStartLock) {

    1360. 

  1360.             int result = ERROR;

    1361. 

  1361.             if (!mStarted) {

    1362. 

  1362.                 return result;

    1363. 

  1363.             }

    1364. 

  1364.             try {

    1365. 

  1365.                 if ((params != null) && (!params.isEmpty())) {

    1366. 

  1366.                     // no need to read the stream type here

    1367. 

  1367.                     String extra = params.get(Engine.KEY_PARAM_UTTERANCE_ID);

    1368. 

  1368.                     if (extra != null) {

    1369. 

  1369.                         mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = extra;

    1370. 

  1370.                     }

    1371. 

  1371.                     extra = params.get(Engine.KEY_PARAM_ENGINE);

    1372. 

  1372.                     if (extra != null) {

    1373. 

  1373.                         mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = extra;

    1374. 

  1374.                     }

    1375. 

  1375.                 }

    1376. 

  1376.                 if (mITts.synthesizeToFile(mPackageName, text, mCachedParams, filename)) {

    1377. 

  1377.                     result = SUCCESS;

    1378. 

  1378.                 }

    1379. 

  1379.             } catch (RemoteException e) {

    1380. 

  1380.                 // TTS died; restart it.

    1381. 

  1381.                 Log.e("TextToSpeech.java - synthesizeToFile", "RemoteException");

    1382. 

  1382.                 e.printStackTrace();

    1383. 

  1383.                 mStarted = false;

    1384. 

  1384.                 initTts();

    1385. 

  1385.             } catch (NullPointerException e) {

    1386. 

  1386.                 // TTS died; restart it.

    1387. 

  1387.                 Log.e("TextToSpeech.java - synthesizeToFile", "NullPointerException");

    1388. 

  1388.                 e.printStackTrace();

    1389. 

  1389.                 mStarted = false;

    1390. 

  1390.                 initTts();

    1391. 

  1391.             } catch (IllegalStateException e) {

    1392. 

  1392.                 // TTS died; restart it.

    1393. 

  1393.                 Log.e("TextToSpeech.java - synthesizeToFile", "IllegalStateException");

    1394. 

  1394.                 e.printStackTrace();

    1395. 

  1395.                 mStarted = false;

    1396. 

  1396.                 initTts();

    1397. 

  1397.             } finally {

    1398. 

  1398.                 resetCachedParams();

    1399. 

  1399.                 return result;

    1400. 

  1400.             }

    1401. 

  1401.         }

    1402. 

  1402.     }

    1403. 

  1403. 

    1404. 

  1404.     /**

    1405. 

  1405.      * Convenience method to reset the cached parameters to the current default

    1406. 

  1406.      * values if they are not persistent between calls to the service.

    1407. 

  1407.      */

    1408. 

  1408.     private void resetCachedParams() {

    1409. 

  1409.         if (!ttsBetaInstalled) {

    1410. 

  1410.             Log.d("TextToSpeechBeta", NOT_ON_PLATFORM_TTS + "resetCachedParams");

    1411. 

  1411.             return;

    1412. 

  1412.         }

    1413. 

  1413.         mCachedParams[Engine.PARAM_POSITION_STREAM + 1] = String.valueOf(Engine.DEFAULT_STREAM);

    1414. 

  1414.         mCachedParams[Engine.PARAM_POSITION_UTTERANCE_ID + 1] = "";

    1415. 

  1415.     }

    1416. 

  1416. 

    1417. 

  1417.     /**

    1418. 

  1418.      * Sets the OnUtteranceCompletedListener that will fire when an utterance

    1419. 

  1419.      * completes.

    1420. 

  1420.      * 

    1421. 

  1421.      * @param listener The OnUtteranceCompletedListener

    1422. 

  1422.      * @return Code indicating success or failure. See {@link #ERROR} and

    1423. 

  1423.      *         {@link #SUCCESS}.

    1424. 

  1424.      */

    1425. 

  1425.     public int setOnUtteranceCompletedListener(final OnUtteranceCompletedListener listener) {

    1426. 

  1426.         if (!ttsBetaInstalled) {

    1427. 

  1427.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "setOnUtteranceCompletedListener");

    1428. 

  1428.             TextToSpeech.OnUtteranceCompletedListener platformUtteranceCompletedListener = new TextToSpeech.OnUtteranceCompletedListener() {

    1429. 

  1429.                 public void onUtteranceCompleted(String utteranceId) {

    1430. 

  1430.                     listener.onUtteranceCompleted(utteranceId);

    1431. 

  1431.                 }

    1432. 

  1432.             };

    1433. 

  1433.             return super.setOnUtteranceCompletedListener(platformUtteranceCompletedListener);

    1434. 

  1434.         }

    1435. 

  1435.         synchronized (mStartLock) {

    1436. 

  1436.             int result = ERROR;

    1437. 

  1437.             if (!mStarted) {

    1438. 

  1438.                 return result;

    1439. 

  1439.             }

    1440. 

  1440.             mITtscallback = new ITtsCallbackBeta.Stub() {

    1441. 

  1441.                 public void utteranceCompleted(String utteranceId) throws RemoteException {

    1442. 

  1442.                     if (listener != null) {

    1443. 

  1443.                         listener.onUtteranceCompleted(utteranceId);

    1444. 

  1444.                     }

    1445. 

  1445.                 }

    1446. 

  1446.             };

    1447. 

  1447.             try {

    1448. 

  1448.                 result = mITts.registerCallback(mPackageName, mITtscallback);

    1449. 

  1449.             } catch (RemoteException e) {

    1450. 

  1450.                 // TTS died; restart it.

    1451. 

  1451.                 Log.e("TextToSpeech.java - registerCallback", "RemoteException");

    1452. 

  1452.                 e.printStackTrace();

    1453. 

  1453.                 mStarted = false;

    1454. 

  1454.                 initTts();

    1455. 

  1455.             } catch (NullPointerException e) {

    1456. 

  1456.                 // TTS died; restart it.

    1457. 

  1457.                 Log.e("TextToSpeech.java - registerCallback", "NullPointerException");

    1458. 

  1458.                 e.printStackTrace();

    1459. 

  1459.                 mStarted = false;

    1460. 

  1460.                 initTts();

    1461. 

  1461.             } catch (IllegalStateException e) {

    1462. 

  1462.                 // TTS died; restart it.

    1463. 

  1463.                 Log.e("TextToSpeech.java - registerCallback", "IllegalStateException");

    1464. 

  1464.                 e.printStackTrace();

    1465. 

  1465.                 mStarted = false;

    1466. 

  1466.                 initTts();

    1467. 

  1467.             } finally {

    1468. 

  1468.                 return result;

    1469. 

  1469.             }

    1470. 

  1470.         }

    1471. 

  1471.     }

    1472. 

  1472. 

    1473. 

  1473.     public int setEngineByPackageNameExtended(String enginePackageName) {

    1474. 

  1474.         if (!ttsBetaInstalled) {

    1475. 

  1475.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "setEngineByPackageName");

    1476. 

  1476.             return usePlatform_setEngineByPackageName(this, enginePackageName);

    1477. 

  1477.         }

    1478. 

  1478.         synchronized (mStartLock) {

    1479. 

  1479.             int result = TextToSpeechBeta.ERROR;

    1480. 

  1480.             if (!mStarted) {

    1481. 

  1481.                 return result;

    1482. 

  1482.             }

    1483. 

  1483.             try {

    1484. 

  1484.                 result = mITts.setEngineByPackageName(enginePackageName);

    1485. 

  1485.                 if (result == TextToSpeechBeta.SUCCESS) {

    1486. 

  1486.                     mCachedParams[Engine.PARAM_POSITION_ENGINE + 1] = enginePackageName;

    1487. 

  1487.                 }

    1488. 

  1488.             } catch (RemoteException e) {

    1489. 

  1489.                 // TTS died; restart it.

    1490. 

  1490.                 Log.e("TextToSpeech.java - setEngineByPackageName", "RemoteException");

    1491. 

  1491.                 e.printStackTrace();

    1492. 

  1492.                 mStarted = false;

    1493. 

  1493.                 initTts();

    1494. 

  1494.             } catch (NullPointerException e) {

    1495. 

  1495.                 // TTS died; restart it.

    1496. 

  1496.                 Log.e("TextToSpeech.java - setEngineByPackageName", "NullPointerException");

    1497. 

  1497.                 e.printStackTrace();

    1498. 

  1498.                 mStarted = false;

    1499. 

  1499.                 initTts();

    1500. 

  1500.             } catch (IllegalStateException e) {

    1501. 

  1501.                 // TTS died; restart it.

    1502. 

  1502.                 Log.e("TextToSpeech.java - setEngineByPackageName", "IllegalStateException");

    1503. 

  1503.                 e.printStackTrace();

    1504. 

  1504.                 mStarted = false;

    1505. 

  1505.                 initTts();

    1506. 

  1506.             } finally {

    1507. 

  1507.                 return result;

    1508. 

  1508.             }

    1509. 

  1509.         }

    1510. 

  1510.     }

    1511. 

  1511. 

    1512. 

  1512.     /**

    1513. 

  1513.      * Gets the packagename of the default speech synthesis engine.

    1514. 

  1514.      * 

    1515. 

  1515.      * @return Packagename of the TTS engine that the user has chosen as their

    1516. 

  1516.      *         default.

    1517. 

  1517.      */

    1518. 

  1518.     public String getDefaultEngineExtended() {

    1519. 

  1519.         if (!ttsBetaInstalled) {

    1520. 

  1520.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "getDefaultEngine");

    1521. 

  1521.             return usePlatform_getDefaultEngine(this);

    1522. 

  1522.         }

    1523. 

  1523.         synchronized (mStartLock) {

    1524. 

  1524.             String engineName = "";

    1525. 

  1525.             if (!mStarted) {

    1526. 

  1526.                 return engineName;

    1527. 

  1527.             }

    1528. 

  1528.             try {

    1529. 

  1529.                 engineName = mITts.getDefaultEngine();

    1530. 

  1530.             } catch (RemoteException e) {

    1531. 

  1531.                 // TTS died; restart it.

    1532. 

  1532.                 Log.e("TextToSpeech.java - setEngineByPackageName", "RemoteException");

    1533. 

  1533.                 e.printStackTrace();

    1534. 

  1534.                 mStarted = false;

    1535. 

  1535.                 initTts();

    1536. 

  1536.             } catch (NullPointerException e) {

    1537. 

  1537.                 // TTS died; restart it.

    1538. 

  1538.                 Log.e("TextToSpeech.java - setEngineByPackageName", "NullPointerException");

    1539. 

  1539.                 e.printStackTrace();

    1540. 

  1540.                 mStarted = false;

    1541. 

  1541.                 initTts();

    1542. 

  1542.             } catch (IllegalStateException e) {

    1543. 

  1543.                 // TTS died; restart it.

    1544. 

  1544.                 Log.e("TextToSpeech.java - setEngineByPackageName", "IllegalStateException");

    1545. 

  1545.                 e.printStackTrace();

    1546. 

  1546.                 mStarted = false;

    1547. 

  1547.                 initTts();

    1548. 

  1548.             } finally {

    1549. 

  1549.                 return engineName;

    1550. 

  1550.             }

    1551. 

  1551.         }

    1552. 

  1552.     }

    1553. 

  1553. 

    1554. 

  1554.     /**

    1555. 

  1555.      * Returns whether or not the user is forcing their defaults to override the

    1556. 

  1556.      * Text-To-Speech settings set by applications.

    1557. 

  1557.      * 

    1558. 

  1558.      * @return Whether or not defaults are enforced.

    1559. 

  1559.      */

    1560. 

  1560.     public boolean areDefaultsEnforcedExtended() {

    1561. 

  1561.         if (!ttsBetaInstalled) {

    1562. 

  1562.             Log.d("TextToSpeechBeta", USING_PLATFORM_TTS + "setOnUtteranceCompletedListener");

    1563. 

  1563.             return usePlatform_areDefaultsEnforced(this);

    1564. 

  1564.         }

    1565. 

  1565. 

    1566. 

  1566.         synchronized (mStartLock) {

    1567. 

  1567.             boolean defaultsEnforced = false;

    1568. 

  1568.             if (!mStarted) {

    1569. 

  1569.                 return defaultsEnforced;

    1570. 

  1570.             }

    1571. 

  1571.             try {

    1572. 

  1572.                 defaultsEnforced = mITts.areDefaultsEnforced();

    1573. 

  1573.             } catch (RemoteException e) {

    1574. 

  1574.                 // TTS died; restart it.

    1575. 

  1575.                 Log.e("TextToSpeech.java - areDefaultsEnforced", "RemoteException");

    1576. 

  1576.                 e.printStackTrace();

    1577. 

  1577.                 mStarted = false;

    1578. 

  1578.                 initTts();

    1579. 

  1579.             } catch (NullPointerException e) {

    1580. 

  1580.                 // TTS died; restart it.

    1581. 

  1581.                 Log.e("TextToSpeech.java - areDefaultsEnforced", "NullPointerException");

    1582. 

  1582.                 e.printStackTrace();

    1583. 

  1583.                 mStarted = false;

    1584. 

  1584.                 initTts();

    1585. 

  1585.             } catch (IllegalStateException e) {

    1586. 

  1586.                 // TTS died; restart it.

    1587. 

  1587.                 Log.e("TextToSpeech.java - areDefaultsEnforced", "IllegalStateException");

    1588. 

  1588.                 e.printStackTrace();

    1589. 

  1589.                 mStarted = false;

    1590. 

  1590.                 initTts();

    1591. 

  1591.             } finally {

    1592. 

  1592.                 return defaultsEnforced;

    1593. 

  1593.             }

    1594. 

  1594.         }

    1595. 

  1595.     }

    1596. 

  1596. 

    1597. 

  1597.     /**

    1598. 

  1598.      * Standalone TTS ONLY! Checks if the TTS service is installed or not

    1599. 

  1599.      * 

    1600. 

  1600.      * @return A boolean that indicates whether the TTS service is installed

    1601. 

  1601.      */

    1602. 

  1602.     public static boolean isInstalled(Context ctx) {

    1603. 

  1603.         PackageManager pm = ctx.getPackageManager();

    1604. 

  1604.         Intent inten
    1605.