--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
+\r
+\r
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __TIZEN_UIX_STT_H__
+#define __TIZEN_UIX_STT_H__
+
+#include <tizen.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup CAPI_UIX_STT_MODULE
+ * @{
+ */
+
+/**
+* @brief Enumerations of error codes.
+*/
+typedef enum {
+ STT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ STT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of Memory */
+ STT_ERROR_IO_ERROR = TIZEN_ERROR_IO_ERROR, /**< I/O error */
+ STT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ STT_ERROR_TIMED_OUT = TIZEN_ERROR_CONNECTION_TIME_OUT, /**< No answer from the daemon */
+ STT_ERROR_RECORDER_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Busy recorder */
+ STT_ERROR_OUT_OF_NETWORK = TIZEN_ERROR_NETWORK_DOWN, /**< Out of network */
+ STT_ERROR_INVALID_STATE = TIZEN_ERROR_UIX_CLASS | 0x31, /**< Invalid state */
+ STT_ERROR_INVALID_LANGUAGE = TIZEN_ERROR_UIX_CLASS | 0x32, /**< Invalid language */
+ STT_ERROR_ENGINE_NOT_FOUND = TIZEN_ERROR_UIX_CLASS | 0x33, /**< No available engine */
+ STT_ERROR_OPERATION_FAILED = TIZEN_ERROR_UIX_CLASS | 0x34, /**< Operation failed */
+ STT_ERROR_NOT_SUPPORTED_FEATURE = TIZEN_ERROR_UIX_CLASS | 0x35 /**< Not supported feature of current engine */
+}stt_error_e;
+
+/**
+* @brief Recognition type : free form dictation or default type.
+*/
+#define STT_RECOGNITION_TYPE_FREE "stt.recognition.type.FREE"
+
+/**
+* @brief Recognition type : web search.
+*/
+#define STT_RECOGNITION_TYPE_WEB_SEARCH "stt.recognition.type.WEB_SEARCH"
+
+/**
+* @brief Recognition type : all voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND "stt.recognition.type.COMMAND"
+
+/**
+* @brief Recognition type : call of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_CALL "stt.recognition.type.COMMAND.CALL"
+
+/**
+* @brief Recognition type : music of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_MUSIC "stt.recognition.type.COMMAND.MUSIC"
+
+/**
+* @brief Recognition type : web search of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_WEB_SEARCH "stt.recognition.type.COMMAND.WEB_SEARCH"
+
+/**
+* @brief Recognition type : schedule of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_SCHEDULE "stt.recognition.type.COMMAND.SCHEDULE"
+
+/**
+* @brief Recognition type : search of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_SEARCH "stt.recognition.type.COMMAND.SEARCH"
+
+/**
+* @brief Recognition type : contact of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_CONTACT "stt.recognition.type.COMMAND.CONTACT"
+
+/**
+* @brief Recognition type : social of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_SOCIAL "stt.recognition.type.COMMAND.SOCIAL"
+
+/**
+* @brief Recognition type : message of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_MESSAGE "stt.recognition.type.COMMAND.MESSAGE"
+
+/**
+* @brief Recognition type : email of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_EMAIL "stt.recognition.type.COMMAND.EMAIL"
+
+/**
+* @brief Recognition type : memo of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_MEMO "stt.recognition.type.COMMAND.MEMO"
+
+/**
+* @brief Recognition type : alarm of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_ALARM "stt.recognition.type.COMMAND.ALARM"
+
+/**
+* @brief Recognition type : application of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_APPLICATION "stt.recognition.type.COMMAND.APPLICATION"
+
+/**
+* @brief Recognition type : driving mode of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_DRIVING_MODE "stt.recognition.type.COMMAND.DRIVING_MODE"
+
+/**
+* @brief Recognition type : navigation of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_NAVIGATION "stt.recognition.type.COMMAND.NAVIGATION"
+
+/**
+* @brief Recognition type : text-to-speech of voice commands
+*/
+#define STT_RECOGNITION_TYPE_COMMAND_TTS "stt.recognition.type.COMMAND.TTS"
+
+/**
+* @brief Result message : None message
+*/
+#define STT_RESULT_MESSAGE_NONE "stt.result.message.none"
+
+/**
+* @brief Result warning message : The speech has started too soon
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_SOON "stt.result.message.warning.too.soon"
+
+/**
+* @brief Result warning message : The speech is too short
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_SHORT "stt.result.message.warning.too.short"
+
+/**
+* @brief Result warning message : The speech is too long
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_LONG "stt.result.message.warning.too.long"
+
+/**
+* @brief Result warning message : The speech is too quiet to listen
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_QUIET "stt.result.message.warning.too.quiet"
+
+/**
+* @brief Result warning message : The speech is too loud to listen
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_LOUD "stt.result.message.warning.too.loud"
+
+/**
+* @brief Result warning message : The speech is too fast to listen
+*/
+#define STT_RESULT_MESSAGE_WARNING_TOO_FAST "stt.result.message.warning.too.fast"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too soon
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_SOON "stt.result.message.error.too.soon"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too short
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_SHORT "stt.result.message.error.too.short"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too long
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_LONG "stt.result.message.error.too.long"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too quiet to listen
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_QUIET "stt.result.message.error.too.quiet"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too loud to listen
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_LOUD "stt.result.message.error.too.loud"
+
+/**
+* @brief Result error message : Recognition was failed because the speech started too fast to listen
+*/
+#define STT_RESULT_MESSAGE_ERROR_TOO_FAST "stt.result.message.error.too.fast"
+
+
+/**
+* @brief Enumerations of state.
+*/
+typedef enum {
+ STT_STATE_READY = 0, /**< 'READY' state */
+ STT_STATE_RECORDING, /**< 'RECORDING' state */
+ STT_STATE_PROCESSING /**< 'PROCESSING' state*/
+}stt_state_e;
+
+/**
+* @brief Enumerations of silence detection type.
+*/
+typedef enum {
+ STT_OPTION_SILENCE_DETECTION_FALSE = 0, /**< Silence detection type - False */
+ STT_OPTION_SILENCE_DETECTION_TRUE = 1, /**< Silence detection type - True */
+ STT_OPTION_SILENCE_DETECTION_AUTO = 2 /**< Silence detection type - Auto */
+}stt_option_silence_detection_e;
+
+/**
+* @brief A structure of handle for STT
+*/
+typedef struct stt_s *stt_h;
+
+/**
+* @brief Called when STT gets the recognition result from engine after the application call stt_stop().
+*
+* @remark If results of recognition is valid after stt_stop() is called or silence is detected from recording,
+* this function is called.
+*
+* @param[in] stt The handle for STT
+* @param[in] type Recognition type (e.g. #STT_RECOGNITION_TYPE_FREE, #STT_RECOGNITION_TYPE_COMMAND)
+* @param[in] data Result texts
+* @param[in] data_count Result text count
+* @param[in] msg Engine message (e.g. #STT_RESULT_MESSAGE_WARNING_TOO_SOON, #STT_RESULT_MESSAGE_ERROR_TOO_SHORT)
+* @param[in] user_data The user data passed from the callback registration function
+*
+* @pre stt_stop() will invoke this callback if you register it using stt_set_result_cb().
+* @post If this function is called, the STT state will be #STT_STATE_READY.
+*
+* @see stt_stop()
+* @see stt_set_result_cb()
+* @see stt_unset_result_cb()
+*/
+typedef void (*stt_result_cb)(stt_h stt, const char* type, const char** data, int data_count, const char* msg, void *user_data);
+
+/**
+* @brief Called when STT gets recognition the partial result from engine after the application calls stt_start().
+*
+* @remark If a current engine supports partial result of recognition, this function can be called.
+*
+* @param[in] stt The handle for STT
+* @param[in] data Result data
+* @param[in] user_data The user data passed from the callback registration function
+*
+* @pre stt_start() will invoke this callback if you register it using stt_set_partial_result_cb().
+*
+* @see stt_start()
+* @see stt_set_partial_result_cb()
+* @see stt_unset_partial_result_cb()
+* @see stt_is_partial_result_supported()
+*/
+typedef void (*stt_partial_result_cb)(stt_h stt, const char* data, void *user_data);
+
+/**
+* @brief Called when the state of STT is changed.
+*
+* @param[in] stt The handle for STT
+* @param[in] previous A previous state
+* @param[in] current A current state
+* @param[in] user_data The user data passed from the callback registration function.
+*
+* @pre An application registers this callback using stt_set_state_changed_cb() to detect changing state.
+*
+* @see stt_start()
+* @see stt_stop()
+* @see stt_cancel()
+* @see stt_result_cb()
+* @see stt_set_state_changed_cb()
+* @see stt_unset_state_changed_cb()
+*/
+typedef void (*stt_state_changed_cb)(stt_h stt, stt_state_e previous, stt_state_e current, void* user_data);
+
+/**
+* @brief Called when error occurred.
+*
+* @param[in] stt The handle for STT
+* @param[in] reason The error type (e.g. #STT_ERROR_OUT_OF_NETWORK, #STT_ERROR_IO_ERROR)
+* @param[in] user_data The user data passed from the callback registration function
+*
+* @pre An application registers this callback using stt_set_error_cb() to detect error.
+*
+* @see stt_set_error_cb()
+* @see stt_unset_error_cb()
+*/
+typedef void (*stt_error_cb)(stt_h stt, stt_error_e reason, void *user_data);
+
+/**
+* @brief Called to retrieve the supported languages.
+*
+* @param[in] stt The handle for STT
+* @param[in] language A language is specified as an ISO 3166 alpha-2 two letter country-code \n
+* followed by ISO 639-1 for the two-letter language code. \n
+* For example, "ko_KR" for Korean, "en_US" for American English.
+* @param[in] user_data The user data passed from the foreach function
+*
+* @return @c true to continue with the next iteration of the loop, \n @c false to break out of the loop.
+* @pre stt_foreach_supported_languages() will invoke this callback.
+*
+* @see stt_foreach_supported_languages()
+*/
+typedef bool(*stt_supported_language_cb)(stt_h stt, const char* language, void* user_data);
+
+
+/**
+* @brief Creates a handle for STT and connects daemon.
+*
+* @param[out] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_TIMED_OUT The daemon is blocked or do not exist
+* @retval #STT_ERROR_ENGINE_NOT_FOUND No available engine \n Engine should be installed
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_OUT_OF_MEMORY Out of memory
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+*
+* @see stt_destroy()
+*/
+int stt_create(stt_h* stt);
+
+/**
+* @brief Destroys the handle and disconnects the daemon.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+*
+* @see stt_create()
+*/
+int stt_destroy(stt_h stt);
+
+/**
+* @brief Retrieves all supported languages of current engine using callback function.
+*
+* @param[in] stt The handle for STT
+* @param[in] callback The callback function to invoke
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+* @post This function invokes stt_supported_language_cb() repeatedly for getting languages.
+*
+* @see stt_supported_language_cb()
+* @see stt_get_default_language()
+*/
+int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data);
+
+/**
+* @brief Gets the default language set by user.
+*
+* @remark If the function succeeds, @a language must be released with free() by you when you no longer need it.
+*
+* @param[in] stt The handle for STT
+* @param[out] language A language is specified as an ISO 3166 alpha-2 two letter country-code \n
+* followed by ISO 639-1 for the two-letter language code. \n
+* For example, "ko_KR" for Korean, "en_US" for American English.
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_OUT_OF_MEMORY Out of memory
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_foreach_supported_languages()
+*/
+int stt_get_default_language(stt_h stt, char** language);
+
+/**
+* @brief Gets the current state of STT.
+*
+* @param[in] stt The handle for STT
+* @param[out] state The current state of STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+*
+* @see stt_start()
+* @see stt_stop()
+* @see stt_cancel()
+* @see stt_state_changed_cb()
+*/
+int stt_get_state(stt_h stt, stt_state_e* state);
+
+/**
+* @brief Checks whether the partial results can be returned while a recognition is in process.
+*
+* @param[in] stt The handle for STT
+* @param[out] partial_result The partial result status : (@c true = supported, @c false = not supported)
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_partial_result_cb()
+*/
+int stt_is_partial_result_supported(stt_h stt, bool* partial_result);
+
+/**
+* @brief Sets silence detection.
+*
+* @param[in] stt The handle for STT
+* @param[in] type The option type
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+* @retval #STT_ERROR_NOT_SUPPORTED_FEATURE Not supported feature of current engine
+*
+* @pre The state should be #STT_STATE_READY.
+*/
+int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type);
+
+/**
+* @brief Starts recording and recognition.
+*
+* @remark This function starts recording in the daemon and sending recording data to engine. \n
+* This work continues until stt_stop(), stt_cancel() or silence detected.
+*
+* @param[in] stt The handle for STT
+* @param[in] language The language selected from stt_foreach_supported_languages()
+* @param[in] type The type for recognition (e.g. #STT_RECOGNITION_TYPE_FREE, #STT_RECOGNITION_TYPE_WEB_SEARCH)
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter.
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+* @retval #STT_ERROR_RECORDER_BUSY Recorder busy
+* @retval #STT_ERROR_INVALID_LANGUAGE Invalid language
+*
+* @pre The state should be #STT_STATE_READY.
+* @post It will invoke stt_state_changed_cb(), if you register a callback with stt_state_changed_cb(). \n
+* If this function succeeds, the STT state will be #STT_STATE_RECORDING.
+*
+* @see stt_stop()
+* @see stt_cancel()
+* @see stt_state_changed_cb()
+* @see stt_error_cb()
+*/
+int stt_start(stt_h stt, const char* language, const char* type);
+
+/**
+* @brief Finishes recording and starts recognition processing in engine.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_OUT_OF_MEMORY Not enough memory
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+*
+* @pre The state should be #STT_STATE_RECORDING.
+* @post It will invoke stt_state_changed_cb(), if you register a callback with stt_state_changed_cb(). \n
+* If this function succeeds, the STT state will be #STT_STATE_PROCESSING. \n
+* After processing of engine, stt_result_cb() is called.
+*
+* @see stt_start()
+* @see stt_cancel()
+* @see stt_state_changed_cb()
+* @see stt_error_cb()
+*/
+int stt_stop(stt_h stt);
+
+/**
+* @brief Cancels processing recognition and recording.
+*
+* @remark This function cancels recording and engine cancels recognition processing. \n
+* After successful cancel, stt_state_changed_cb() is called otherwise if error is occurred, stt_error_cb() is called.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_OUT_OF_MEMORY Not enough memory
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+*
+* @pre The state should be #STT_STATE_RECORDING or #STT_STATE_PROCESSING.
+* @post It will invoke stt_state_changed_cb(), if you register a callback with stt_state_changed_cb(). \n
+* If this function succeeds, the STT state will be #STT_STATE_READY.
+*
+* @see stt_start()
+* @see stt_stop()
+* @see stt_state_changed_cb()
+* @see stt_error_cb()
+*/
+int stt_cancel(stt_h stt);
+
+/**
+* @brief Gets the microphone volume during recording.
+*
+* @param[in] stt The handle for STT
+* @param[out] volume Recording volume
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+* @retval #STT_ERROR_OPERATION_FAILED Operation failure
+*
+* @pre The state should be #STT_STATE_RECORDING.
+*
+* @see stt_start()
+*/
+int stt_get_recording_volume(stt_h stt, float* volume);
+
+/**
+* @brief Registers a callback function for getting recognition result.
+*
+* @param[in] stt The handle for STT
+* @param[in] callback The callback function to register
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_result_cb()
+* @see stt_unset_result_cb()
+*/
+int stt_set_result_cb(stt_h stt, stt_result_cb callback, void* user_data);
+
+/**
+* @brief Unregisters the callback function.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_set_result_cb()
+*/
+int stt_unset_result_cb(stt_h stt);
+
+/**
+* @brief Registers a callback function for getting partial result of recognition.
+*
+* @param[in] stt The handle for STT
+* @param[in] callback The callback function to register
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @see stt_partial_result_cb()
+* @see stt_unset_partial_result_cb()
+*/
+int stt_set_partial_result_cb(stt_h stt, stt_partial_result_cb callback, void* user_data);
+
+/**
+* @brief Unregisters the callback function.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_set_partial_result_cb()
+*/
+int stt_unset_partial_result_cb(stt_h stt);
+
+/**
+* @brief Registers a callback function to be called when STT state changes.
+*
+* @param[in] stt The handle for STT
+* @param[in] callback The callback function to register
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_state_changed_cb()
+* @see stt_unset_state_changed_cb()
+*/
+int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data);
+
+/**
+* @brief Unregisters the callback function.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_set_state_changed_cb()
+*/
+int stt_unset_state_changed_cb(stt_h stt);
+
+/**
+* @brief Registers a callback function to be called when an error occurred.
+*
+* @param[in] stt The handle for STT
+* @param[in] callback The callback function to register
+* @param[in] user_data The user data to be passed to the callback function
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_error_cb()
+* @see stt_unset_error_cb()
+*/
+int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data);
+
+/**
+* @brief Unregisters the callback function.
+*
+* @param[in] stt The handle for STT
+*
+* @return 0 on success, otherwise a negative error value
+* @retval #STT_ERROR_NONE Successful
+* @retval #STT_ERROR_INVALID_PARAMETER Invalid parameter
+* @retval #STT_ERROR_INVALID_STATE Invalid state
+*
+* @pre The state should be #STT_STATE_READY.
+*
+* @see stt_set_error_cb()
+*/
+int stt_unset_error_cb(stt_h stt);
+
+
+/**
+* @}
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_UIX_STT_H__ */
+
projects / framework / api / stt-api.git / commitdiff