X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=client%2Fstt.c;h=163d67aa19d5841596966512f7294848d6618b1d;hb=b6aed48b1a283015e0948fa4b37578c80bd921fe;hp=4394ae977b7888409283c13b7c6474903c83ad18;hpb=c310764dac3605c159a7617807968a00e869e5a9;p=platform%2Fcore%2Fuifw%2Fstt.git diff --git a/client/stt.c b/client/stt.c old mode 100755 new mode 100644 index 4394ae9..163d67a --- a/client/stt.c +++ b/client/stt.c @@ -1,5 +1,5 @@ /* -* Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved +* Copyright (c) 2011-2016 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 @@ -12,6 +12,9 @@ */ #include +#include +#include +#include #include #include #include @@ -37,6 +40,11 @@ static float g_volume_db = 0; static int g_feature_enabled = -1; +static int g_privilege_allowed = -1; +static cynara *p_cynara = NULL; + +static bool g_err_callback_status = false; + const char* stt_tag() { return "sttc"; @@ -72,6 +80,80 @@ static int __stt_get_feature_enabled() return 0; } +static int __check_privilege_initialize() +{ + int ret = cynara_initialize(&p_cynara, NULL); + if (CYNARA_API_SUCCESS != ret) + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to initialize"); + + return ret == CYNARA_API_SUCCESS; +} + +static int __check_privilege(const char* uid, const char * privilege) +{ + FILE *fp = NULL; + char label_path[1024] = "/proc/self/attr/current"; + char smack_label[1024] = {'\0',}; + + if (!p_cynara) { + return false; + } + + fp = fopen(label_path, "r"); + if (fp != NULL) { + if (fread(smack_label, 1, sizeof(smack_label), fp) <= 0) + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread"); + + fclose(fp); + } + + pid_t pid = getpid(); + char *session = cynara_session_from_pid(pid); + int ret = cynara_check(p_cynara, smack_label, session, uid, privilege); + SLOG(LOG_DEBUG, TAG_STTC, "[Client]cynara_check returned %d(%s)", ret, (CYNARA_API_ACCESS_ALLOWED == ret) ? "Allowed" : "Denied"); + if (session) { + free(session); + session = NULL; + } + + if (ret != CYNARA_API_ACCESS_ALLOWED) + return false; + return true; +} + +static void __check_privilege_deinitialize() +{ + if (p_cynara) + cynara_finish(p_cynara); + p_cynara = NULL; +} + +static int __stt_check_privilege() +{ + char uid[16]; + + if (0 == g_privilege_allowed) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied"); + return STT_ERROR_PERMISSION_DENIED; + } else if (-1 == g_privilege_allowed) { + if (false == __check_privilege_initialize()) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed"); + return STT_ERROR_PERMISSION_DENIED; + } + snprintf(uid, 16, "%d", getuid()); + if (false == __check_privilege(uid, STT_PRIVILEGE)) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied"); + g_privilege_allowed = 0; + __check_privilege_deinitialize(); + return STT_ERROR_PERMISSION_DENIED; + } + __check_privilege_deinitialize(); + } + + g_privilege_allowed = 1; + return STT_ERROR_NONE; +} + static const char* __stt_get_error_code(stt_error_e err) { switch (err) { @@ -89,6 +171,7 @@ static const char* __stt_get_error_code(stt_error_e err) case STT_ERROR_ENGINE_NOT_FOUND: return "STT_ERROR_ENGINE_NOT_FOUND"; case STT_ERROR_OPERATION_FAILED: return "STT_ERROR_OPERATION_FAILED"; case STT_ERROR_NOT_SUPPORTED_FEATURE: return "STT_ERROR_NOT_SUPPORTED_FEATURE"; + case STT_ERROR_SERVICE_RESET: return "STT_ERROR_SERVICE_RESET"; default: return "Invalid error code"; } @@ -145,11 +228,58 @@ void __stt_config_lang_changed_cb(const char* before_language, const char* curre return; } +void __stt_config_engine_changed_cb(const char* engine_id, const char* setting, const char* language, bool support_silence, bool need_credential, void* user_data) +{ + stt_h stt = (stt_h)user_data; + + stt_client_s* client = stt_client_get(stt); + if (NULL == client) { + SLOG(LOG_ERROR, TAG_STTC, "[WARNING] A handle is not valid"); + return; + } + + if (NULL != engine_id) SLOG(LOG_DEBUG, TAG_STTC, "Engine id(%s)", engine_id); + if (NULL != setting) SLOG(LOG_DEBUG, TAG_STTC, "Engine setting(%s)", setting); + if (NULL != language) SLOG(LOG_DEBUG, TAG_STTC, "Language(%s)", language); + SLOG(LOG_DEBUG, TAG_STTC, "Silence(%s), Credential(%s)", support_silence ? "on" : "off", need_credential ? "need" : "no need"); + + /* call callback function */ + if (NULL != client->engine_changed_cb) { + client->engine_changed_cb(stt, engine_id, language, support_silence, need_credential, client->engine_changed_user_data); + } else { + SLOG(LOG_WARN, TAG_STTC, "No registered callback function for engine change"); + } + return; +} + +static int __stt_check_handle(stt_h stt, stt_client_s** client) +{ + if (NULL == stt) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null"); + return STT_ERROR_INVALID_PARAMETER; + } + + stt_client_s* temp = NULL; + temp = stt_client_get(stt); + + /* check handle */ + if (NULL == temp) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + return STT_ERROR_INVALID_PARAMETER; + } + *client = temp; + + return STT_ERROR_NONE; +} + int stt_create(stt_h* stt) { if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } SLOG(LOG_DEBUG, TAG_STTC, "===== Create STT"); @@ -185,7 +315,7 @@ int stt_create(stt_h* stt) return ret; } - ret = stt_config_mgr_set_callback(client->uid, NULL, __stt_config_lang_changed_cb, NULL, NULL); + ret = stt_config_mgr_set_callback(client->uid, __stt_config_engine_changed_cb, __stt_config_lang_changed_cb, NULL, client->stt); ret = __stt_convert_config_error_code(ret); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set config changed : %s", __stt_get_error_code(ret)); @@ -203,25 +333,19 @@ int stt_create(stt_h* stt) int stt_destroy(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== Destroy STT"); + /* check used callback */ if (0 != stt_client_get_use_callback(client)) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Cannot destroy in Callback function"); @@ -292,22 +416,21 @@ bool __stt_config_supported_engine_cb(const char* engine_id, const char* engine_ int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine"); - - if (NULL == stt || NULL == callback) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); + SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported engine"); - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -337,22 +460,21 @@ int stt_foreach_supported_engines(stt_h stt, stt_supported_engine_cb callback, v int stt_get_engine(stt_h stt, char** engine_id) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine"); - - if (NULL == stt || NULL == engine_id) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); + SLOG(LOG_DEBUG, TAG_STTC, "===== Get current engine"); - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == engine_id) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -385,22 +507,21 @@ int stt_get_engine(stt_h stt, char** engine_id) int stt_set_engine(stt_h stt, const char* engine_id) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine"); - - if (NULL == stt || NULL == engine_id) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); + SLOG(LOG_DEBUG, TAG_STTC, "===== Set current engine"); - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == engine_id) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -412,8 +533,11 @@ int stt_set_engine(stt_h stt, const char* engine_id) if (NULL != client->current_engine_id) { free(client->current_engine_id); + client->current_engine_id = NULL; } + SLOG(LOG_DEBUG, TAG_STTC, "===== engined_id(%s)", engine_id); + client->current_engine_id = strdup(engine_id); SLOG(LOG_DEBUG, TAG_STTC, "====="); @@ -422,6 +546,152 @@ int stt_set_engine(stt_h stt, const char* engine_id) return 0; } +int stt_set_credential(stt_h stt, const char* credential) +{ + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_STTC, "===== Set credential"); + + if (NULL == credential) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + return STT_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (client->current_state != STT_STATE_CREATED && client->current_state != STT_STATE_READY) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not CREATED or READY", client->current_state); + return STT_ERROR_INVALID_STATE; + } + + if (NULL != client->credential) { + free(client->credential); + client->credential = NULL; + } + client->credential = strdup(credential); + + SLOG(LOG_DEBUG, TAG_STTC, "====="); + SLOG(LOG_DEBUG, TAG_STTC, " "); + + return STT_ERROR_NONE; +} + +int stt_set_private_data(stt_h stt, const char* key, const char* data) +{ + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_STTC, "===== Set private data"); + + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter"); + return STT_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (STT_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); + return STT_ERROR_INVALID_STATE; + } + + int ret = -1; + int count = 0; + while (0 != ret) { + ret = stt_dbus_request_set_private_data(client->uid, key, data); + if (0 != ret) { + if (STT_ERROR_TIMED_OUT != ret) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set private data : %s", __stt_get_error_code(ret)); + return ret; + } else { + SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret)); + usleep(10000); + count++; + if (STT_RETRY_COUNT == count) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request"); + return ret; + } + } + } + } + + SLOG(LOG_DEBUG, TAG_STTC, "====="); + SLOG(LOG_DEBUG, TAG_STTC, ""); + + return STT_ERROR_NONE; + +} +int stt_get_private_data(stt_h stt, const char* key, char** data) +{ + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } + + SLOG(LOG_DEBUG, TAG_STTC, "===== Get private data"); + + if (NULL == key || NULL == data) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid parameter"); + return STT_ERROR_INVALID_PARAMETER; + } + + /* check state */ + if (STT_STATE_READY != client->current_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); + return STT_ERROR_INVALID_STATE; + } + + int ret = -1; + int count = 0; + while (0 != ret) { + ret = stt_dbus_request_get_private_data(client->uid, key, data); + if (0 != ret) { + if (STT_ERROR_TIMED_OUT != ret) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get private data : %s", __stt_get_error_code(ret)); + return ret; + } else { + SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry : %s", __stt_get_error_code(ret)); + usleep(10000); + count++; + if (STT_RETRY_COUNT == count) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request"); + return ret; + } + } + } + } + + if (0 == strncmp(*data, "NULL", strlen(*data))) { + free(*data); + *data = NULL; + } + + SLOG(LOG_DEBUG, TAG_STTC, "====="); + SLOG(LOG_DEBUG, TAG_STTC, ""); + + return STT_ERROR_NONE; +} static Eina_Bool __stt_connect_daemon(void *data) { stt_client_s* client = (stt_client_s*)data; @@ -445,12 +715,13 @@ static Eina_Bool __stt_connect_daemon(void *data) } g_connect_timer = NULL; - SLOG(LOG_DEBUG, TAG_STTC, "===== Connect daemon"); + SLOG(LOG_DEBUG, TAG_STTC, "===== Connect stt-service"); /* request initialization */ bool silence_supported = false; + bool credential_needed = false; - ret = stt_dbus_request_initialize(client->uid, &silence_supported); + ret = stt_dbus_request_initialize(client->uid, &silence_supported, &credential_needed); if (STT_ERROR_ENGINE_NOT_FOUND == ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret)); @@ -464,17 +735,22 @@ static Eina_Bool __stt_connect_daemon(void *data) SLOG(LOG_ERROR, TAG_STTC, "[WARNING] Fail to connection. Retry to connect"); return EINA_TRUE; } else { - /* success to connect stt-daemon */ + /* success to connect stt-service */ client->silence_supported = silence_supported; - SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s)", silence_supported ? "true" : "false"); + client->credential_needed = credential_needed; + SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need"); } +#ifdef __UNUSED_CODES__ if (NULL != client->current_engine_id) { ret = -1; int count = 0; silence_supported = false; + credential_needed = false; + SLOG(LOG_DEBUG, TAG_STTC, "[WARNING] current_engine_id(%s)", client->current_engine_id); + while (0 != ret) { - ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported); + ret = stt_dbus_request_set_current_engine(client->uid, client->current_engine_id, &silence_supported, &credential_needed); if (0 != ret) { if (STT_ERROR_TIMED_OUT != ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to set current engine : %s", __stt_get_error_code(ret)); @@ -493,11 +769,11 @@ static Eina_Bool __stt_connect_daemon(void *data) /* success to change engine */ client->silence_supported = silence_supported; - SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s)", silence_supported ? "true" : "false"); + SLOG(LOG_DEBUG, TAG_STTC, "Supported options : silence(%s), credential(%s)", silence_supported ? "support" : "no support", credential_needed ? "need" : "no need"); } } } - +#endif SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] uid(%d)", client->uid); client->before_state = client->current_state; @@ -521,17 +797,14 @@ static Eina_Bool __stt_connect_daemon(void *data) int stt_prepare(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Prepare STT"); - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -551,20 +824,19 @@ int stt_prepare(stt_h stt) int stt_unprepare(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT"); - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== Unprepare STT"); + /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not 'READY'", client->current_state); @@ -638,22 +910,21 @@ bool __stt_config_supported_language_cb(const char* engine_id, const char* langu int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language"); - - if (NULL == stt || NULL == callback) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); + SLOG(LOG_DEBUG, TAG_STTC, "===== Foreach Supported Language"); - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == callback) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -686,6 +957,7 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac if (NULL != current_engine_id) { free(current_engine_id); + current_engine_id = NULL; } client->supported_lang_cb = NULL; @@ -699,23 +971,24 @@ int stt_foreach_supported_languages(stt_h stt, stt_supported_language_cb callbac int stt_get_default_language(stt_h stt, char** language) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } SLOG(LOG_DEBUG, TAG_STTC, "===== Get Default Language"); - if (NULL == stt || NULL == language) { + if (NULL == language) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); - return STT_ERROR_INVALID_PARAMETER; - } - int ret = 0; ret = stt_config_mgr_get_default_language(language); ret = __stt_convert_config_error_code(ret); @@ -733,48 +1006,86 @@ int stt_get_default_language(stt_h stt, char** language) int stt_get_state(stt_h stt, stt_state_e* state) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt || NULL == state) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); + if (NULL == state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } *state = client->current_state; switch (*state) { - case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break; - case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break; - case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break; - case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break; - default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break; + case STT_STATE_CREATED: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'CREATED'"); break; + case STT_STATE_READY: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Ready'"); break; + case STT_STATE_RECORDING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Recording'"); break; + case STT_STATE_PROCESSING: SLOG(LOG_DEBUG, TAG_STTC, "Current state is 'Processing'"); break; + default: SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid value"); break; } return STT_ERROR_NONE; } -int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support) +int stt_get_error_message(stt_h stt, char** err_msg) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } - if (NULL == stt || NULL == type || NULL == support) { + if (NULL == err_msg) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not valid"); + if (false == g_err_callback_status) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] This callback should be called during an err_callback"); + return STT_ERROR_OPERATION_FAILED; + } + + if (NULL != client->err_msg) { + *err_msg = strdup(client->err_msg); + SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (%s)", *err_msg); + } else { + SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Error msg (NULL)"); + } + + SLOG(LOG_DEBUG, TAG_STTC, "====="); + SLOG(LOG_DEBUG, TAG_STTC, " "); + + return STT_ERROR_NONE; +} + +int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support) +{ + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } + + if (NULL == type || NULL == support) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -812,18 +1123,14 @@ int stt_is_recognition_type_supported(stt_h stt, const char* type, bool* support int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -849,13 +1156,20 @@ int stt_set_silence_detection(stt_h stt, stt_option_silence_detection_e type) int stt_set_start_sound(stt_h stt, const char* filename) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET START SOUND"); - if (NULL == stt || NULL == filename) { + if (NULL == filename) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -865,12 +1179,6 @@ int stt_set_start_sound(stt_h stt, const char* filename) return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); - return STT_ERROR_INVALID_PARAMETER; - } - /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); @@ -905,24 +1213,19 @@ int stt_set_start_sound(stt_h stt, const char* filename) int stt_unset_start_sound(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET START SOUND"); + /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); @@ -957,13 +1260,20 @@ int stt_unset_start_sound(stt_h stt) int stt_set_stop_sound(stt_h stt, const char* filename) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } SLOG(LOG_DEBUG, TAG_STTC, "===== STT SET STOP SOUND"); - if (NULL == stt || NULL == filename) { + if (NULL == filename) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -973,13 +1283,6 @@ int stt_set_stop_sound(stt_h stt, const char* filename) return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); - return STT_ERROR_INVALID_PARAMETER; - } - /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); @@ -1014,24 +1317,19 @@ int stt_set_stop_sound(stt_h stt, const char* filename) int stt_unset_stop_sound(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get state : A handle is not valid"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== STT UNSET STOP SOUND"); + /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); @@ -1066,23 +1364,19 @@ int stt_unset_stop_sound(stt_h stt) int stt_start(stt_h stt, const char* language, const char* type) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== STT START"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); - return STT_ERROR_INVALID_PARAMETER; - } - - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== STT START"); + /* check state */ if (client->current_state != STT_STATE_READY) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State: Current state(%d) is not READY", client->current_state); @@ -1091,7 +1385,7 @@ int stt_start(stt_h stt, const char* language, const char* type) if (STT_INTERNAL_STATE_NONE != client->internal_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state); - return STT_ERROR_INVALID_STATE; + return STT_ERROR_IN_PROGRESS_TO_RECORDING; } int ret = -1; @@ -1111,55 +1405,12 @@ int stt_start(stt_h stt, const char* language, const char* type) temp = strdup(language); } -#if 0 - ret = -1; - /* do request */ - int count = 0; - while (0 != ret) { - ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid); - if (0 > ret) { - /* Failure */ - if (STT_ERROR_TIMED_OUT != ret) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret)); - if (NULL != temp) free(temp); - return ret; - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry to start"); - usleep(10000); - count++; - if (STT_RETRY_COUNT == count) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request"); - if (NULL != temp) free(temp); - return ret; - } - } - } else { - /* Success */ - if (NULL != temp) free(temp); - - if (STT_RESULT_STATE_DONE == ret) { - SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is done : %d", ret); - client->before_state = client->current_state; - client->current_state = STT_STATE_RECORDING; - - if (NULL != client->state_changed_cb) { - ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client); - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null"); - } - } else if (STT_RESULT_STATE_NOT_DONE == ret) { - SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is not done : %d", ret); - client->internal_state = STT_INTERNAL_STATE_STARTING; - } else { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret); - } - - ret = STT_ERROR_NONE; - break; - } + if (true == client->credential_needed && NULL == client->credential) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Do not have app credential for this engine(%s)", client->current_engine_id); + return STT_ERROR_PERMISSION_DENIED; } -#else - ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid); + + ret = stt_dbus_request_start(client->uid, temp, type, client->silence, appid, client->credential); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start : %s", __stt_get_error_code(ret)); } else { @@ -1168,7 +1419,7 @@ int stt_start(stt_h stt, const char* language, const char* type) } if (NULL != temp) free(temp); -#endif + SLOG(LOG_DEBUG, TAG_STTC, "====="); SLOG(LOG_DEBUG, TAG_STTC, " "); @@ -1177,85 +1428,45 @@ int stt_start(stt_h stt, const char* language, const char* type) int stt_stop(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== STT STOP"); + /* check state */ if (client->current_state != STT_STATE_RECORDING) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Current state(%d) is NOT RECORDING", client->current_state); return STT_ERROR_INVALID_STATE; } - if (STT_INTERNAL_STATE_NONE != client->internal_state) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state); - return STT_ERROR_INVALID_STATE; - } -#if 0 - int ret = -1; - /* do request */ - int count = 0; - while (0 != ret) { - ret = stt_dbus_request_stop(client->uid); - if (0 > ret) { - /* Failure */ - if (STT_ERROR_TIMED_OUT != ret) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret)); - return ret; - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry stop"); - usleep(10000); - count++; - if (STT_RETRY_COUNT == count) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request"); - return ret; - } - } - } else { - if (STT_RESULT_STATE_DONE == ret) { - SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is done : %d", ret); - client->before_state = client->current_state; - client->current_state = STT_STATE_PROCESSING; - - if (NULL != client->state_changed_cb) { - ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client); - SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called"); - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null"); - } - } else if (STT_RESULT_STATE_NOT_DONE == ret) { - SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is not done : %d", ret); - client->internal_state = STT_INTERNAL_STATE_STOPING; - } else { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid result : %d", ret); - } - ret = STT_ERROR_NONE; - break; - } + if (STT_INTERNAL_STATE_STARTING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_RECORDING; + } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_READY; + } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_PROCESSING; } -#else + int ret = stt_dbus_request_stop(client->uid); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to stop : %s", __stt_get_error_code(ret)); } else { SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done"); - client->internal_state = STT_INTERNAL_STATE_STOPING; + client->internal_state = STT_INTERNAL_STATE_STOPPING; } -#endif + SLOG(LOG_DEBUG, TAG_STTC, "====="); SLOG(LOG_DEBUG, TAG_STTC, " "); @@ -1265,72 +1476,36 @@ int stt_stop(stt_h stt) int stt_cancel(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL"); - - if (NULL == stt) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input handle is null"); - return STT_ERROR_INVALID_PARAMETER; + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; } - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } + SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL"); + /* check state */ if (STT_STATE_RECORDING != client->current_state && STT_STATE_PROCESSING != client->current_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid state : Current state(%d) is 'Ready'", client->current_state); return STT_ERROR_INVALID_STATE; } - if (STT_INTERNAL_STATE_NONE != client->internal_state) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is NOT none : %d", client->internal_state); - return STT_ERROR_INVALID_STATE; + if (STT_INTERNAL_STATE_STARTING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STARTING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_RECORDING; + } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is STOPPING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_PROCESSING; + } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Invalid State : Internal state is CANCELING : %d", client->internal_state); + return STT_ERROR_IN_PROGRESS_TO_READY; } -#if 0 - int ret = -1; - /* do request */ - int count = 0; - while (0 != ret) { - ret = stt_dbus_request_cancel(client->uid); - if (0 != ret) { - /* Failure */ - if (STT_ERROR_TIMED_OUT != ret) { - SLOG(LOG_DEBUG, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret)); - return ret; - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] retry"); - usleep(10000); - count++; - if (STT_RETRY_COUNT == count) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to request"); - return ret; - } - } - } else { - SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS]"); - - client->before_state = client->current_state; - client->current_state = STT_STATE_READY; - if (NULL != client->state_changed_cb) { - ecore_main_loop_thread_safe_call_async(__stt_notify_state_changed, client); - SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called"); - } else { - SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null"); - } - ret = STT_ERROR_NONE; - break; - } - } -#else int ret = stt_dbus_request_cancel(client->uid); if (0 != ret) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel : %s", __stt_get_error_code(ret)); @@ -1338,7 +1513,7 @@ int stt_cancel(stt_h stt) SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done"); client->internal_state = STT_INTERNAL_STATE_CANCELING; } -#endif + SLOG(LOG_DEBUG, TAG_STTC, "====="); SLOG(LOG_DEBUG, TAG_STTC, " "); @@ -1368,20 +1543,19 @@ int __stt_cb_set_volume(int uid, float volume) int stt_get_recording_volume(stt_h stt, float* volume) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt || NULL == volume) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == volume) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL"); return STT_ERROR_INVALID_PARAMETER; } @@ -1420,9 +1594,16 @@ bool __stt_result_time_cb(int index, int event, const char* text, long start_tim int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } SLOG(LOG_DEBUG, TAG_STTC, "===== STT FOREACH DETAILED RESULT"); @@ -1431,14 +1612,6 @@ int stt_foreach_detailed_result(stt_h stt, stt_result_time_cb callback, void* us return STT_ERROR_INVALID_PARAMETER; } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail : A handle is not valid"); - return STT_ERROR_INVALID_PARAMETER; - } - client->result_time_cb = callback; client->result_time_user_data = user_data; @@ -1475,7 +1648,9 @@ static Eina_Bool __stt_notify_error(void *data) if (NULL != client->error_cb) { stt_client_use_callback(client); + g_err_callback_status = true; client->error_cb(client->stt, client->reason, client->error_user_data); + g_err_callback_status = false; stt_client_not_use_callback(client); SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is called : reason [%d]", client->reason); } else { @@ -1485,7 +1660,7 @@ static Eina_Bool __stt_notify_error(void *data) return EINA_FALSE; } -int __stt_cb_error(int uid, int reason) +int __stt_cb_error(int uid, int reason, char* err_msg) { stt_client_s* client = stt_client_get_by_uid(uid); if (NULL == client) { @@ -1495,6 +1670,12 @@ int __stt_cb_error(int uid, int reason) client->reason = reason; client->internal_state = STT_INTERNAL_STATE_NONE; + if (NULL != client->err_msg) { + free(client->err_msg); + client->err_msg = NULL; + } + client->err_msg = strdup(err_msg); + SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0"); if (NULL != client->error_cb) { @@ -1503,6 +1684,15 @@ int __stt_cb_error(int uid, int reason) SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null"); } + if (STT_ERROR_SERVICE_RESET == reason) { + SLOG(LOG_WARN, TAG_STTC, "[WARNING] Service reset"); + + client->current_state = STT_STATE_CREATED; + if (0 != stt_prepare(client->stt)) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to prepare"); + } + } + return 0; } @@ -1523,7 +1713,7 @@ static void __stt_notify_state_changed(void *data) if (STT_INTERNAL_STATE_STARTING == client->internal_state && STT_STATE_RECORDING == client->current_state) { client->internal_state = STT_INTERNAL_STATE_NONE; SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE"); - } else if (STT_INTERNAL_STATE_STOPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) { + } else if (STT_INTERNAL_STATE_STOPPING == client->internal_state && STT_STATE_PROCESSING == client->current_state) { client->internal_state = STT_INTERNAL_STATE_NONE; SLOG(LOG_DEBUG, TAG_STTC, "Internal state change to NONE"); } else if (STT_INTERNAL_STATE_CANCELING == client->internal_state && STT_STATE_READY == client->current_state) { @@ -1685,20 +1875,19 @@ int __stt_cb_set_state(int uid, int state) int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (stt == NULL || callback == NULL) + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; + } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (callback == NULL) return STT_ERROR_INVALID_PARAMETER; - } if (STT_STATE_CREATED != client->current_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); @@ -1713,18 +1902,14 @@ int stt_set_recognition_result_cb(stt_h stt, stt_recognition_result_cb callback, int stt_unset_recognition_result_cb(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt) - return STT_ERROR_INVALID_PARAMETER; - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -1741,20 +1926,19 @@ int stt_unset_recognition_result_cb(stt_h stt) int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt || NULL == callback) + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; + } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == callback) return STT_ERROR_INVALID_PARAMETER; - } if (STT_STATE_CREATED != client->current_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); @@ -1769,18 +1953,14 @@ int stt_set_state_changed_cb(stt_h stt, stt_state_changed_cb callback, void* use int stt_unset_state_changed_cb(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt) - return STT_ERROR_INVALID_PARAMETER; - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -1797,20 +1977,19 @@ int stt_unset_state_changed_cb(stt_h stt) int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt || NULL == callback) + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; + } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == callback) return STT_ERROR_INVALID_PARAMETER; - } if (STT_STATE_CREATED != client->current_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); @@ -1825,18 +2004,14 @@ int stt_set_error_cb(stt_h stt, stt_error_cb callback, void* user_data) int stt_unset_error_cb(stt_h stt) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt) - return STT_ERROR_INVALID_PARAMETER; - - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -1853,20 +2028,19 @@ int stt_unset_error_cb(stt_h stt) int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_cb callback, void* user_data) { + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } - - if (NULL == stt || NULL == callback) + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; + } - stt_client_s* client = stt_client_get(stt); - - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + if (NULL == callback) return STT_ERROR_INVALID_PARAMETER; - } if (STT_STATE_CREATED != client->current_state) { SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); @@ -1881,18 +2055,65 @@ int stt_set_default_language_changed_cb(stt_h stt, stt_default_language_changed_ int stt_unset_default_language_changed_cb(stt_h stt) { + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } + + if (STT_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); + return STT_ERROR_INVALID_STATE; + } + + client->default_lang_changed_cb = NULL; + client->default_lang_changed_user_data = NULL; + + return 0; +} + +int stt_set_engine_changed_cb(stt_h stt, stt_engine_changed_cb callback, void* user_data) +{ + stt_client_s* client = NULL; if (0 != __stt_get_feature_enabled()) { return STT_ERROR_NOT_SUPPORTED; } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { + return STT_ERROR_INVALID_PARAMETER; + } - if (NULL == stt) + if (NULL == callback) return STT_ERROR_INVALID_PARAMETER; - stt_client_s* client = stt_client_get(stt); + if (STT_STATE_CREATED != client->current_state) { + SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Current state(%d) is not 'Created'", client->current_state); + return STT_ERROR_INVALID_STATE; + } - /* check handle */ - if (NULL == client) { - SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available"); + client->engine_changed_cb = callback; + client->engine_changed_user_data = user_data; + + return 0; +} + +int stt_unset_engine_changed_cb(stt_h stt) +{ + stt_client_s* client = NULL; + if (0 != __stt_get_feature_enabled()) { + return STT_ERROR_NOT_SUPPORTED; + } + if (0 != __stt_check_privilege()) { + return STT_ERROR_PERMISSION_DENIED; + } + if (0 != __stt_check_handle(stt, &client)) { return STT_ERROR_INVALID_PARAMETER; } @@ -1901,8 +2122,8 @@ int stt_unset_default_language_changed_cb(stt_h stt) return STT_ERROR_INVALID_STATE; } - client->default_lang_changed_cb = NULL; - client->default_lang_changed_user_data = NULL; + client->engine_changed_cb = NULL; + client->engine_changed_user_data = NULL; return 0; }