static void __stt_notify_state_changed(void *data);
-static Eina_Bool __stt_notify_error(void *data);
+static void __stt_notify_error(void *data);
static Ecore_Timer* g_connect_timer = NULL;
static float g_volume_db = 0;
static int g_feature_enabled = -1;
static int g_privilege_allowed = -1;
+static int g_privilege_applaunch_allowed = -1;
+
static cynara *p_cynara = NULL;
static bool g_err_callback_status = false;
return ret == CYNARA_API_SUCCESS;
}
-static int __check_privilege(const char* uid, const char * privilege)
+static bool __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;
+ 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");
+ if (0 >= fread(smack_label, 1, sizeof(smack_label), fp))
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to fread");
- fclose(fp);
+ fclose(fp);
}
pid_t pid = getpid();
}
if (ret != CYNARA_API_ACCESS_ALLOWED)
- return false;
+ return false;
return true;
}
return STT_ERROR_PERMISSION_DENIED;
}
snprintf(uid, 16, "%d", getuid());
- if (false == __check_privilege(uid, STT_PRIVILEGE)) {
+ if (false == __check_privilege(uid, STT_PRIVILEGE_RECORDER)) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied");
g_privilege_allowed = 0;
__check_privilege_deinitialize();
return STT_ERROR_NONE;
}
+static int __stt_check_privilege_for_applaunch()
+{
+ char uid[16];
+
+ if (0 == g_privilege_applaunch_allowed) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission for applaunch is denied");
+ return STT_ERROR_PERMISSION_DENIED;
+ } else if (-1 == g_privilege_applaunch_allowed) {
+ if (false == __check_privilege_initialize()) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] privilege initialize is failed (applaunch)");
+ return STT_ERROR_PERMISSION_DENIED;
+ }
+ snprintf(uid, 16, "%d", getuid());
+ if (false == __check_privilege(uid, STT_PRIVILEGE_APPLAUNCH)) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Permission is denied : appmanager.launch");
+ g_privilege_applaunch_allowed = 0;
+ __check_privilege_deinitialize();
+ return STT_ERROR_PERMISSION_DENIED;
+ }
+ __check_privilege_deinitialize();
+ }
+
+ g_privilege_applaunch_allowed = 1;
+ return STT_ERROR_NONE;
+}
+
static const char* __stt_get_error_code(stt_error_e err)
{
switch (err) {
if (0 != __stt_check_privilege()) {
return STT_ERROR_PERMISSION_DENIED;
}
+ if (0 != __stt_check_privilege_for_applaunch()) {
+ return STT_ERROR_PERMISSION_DENIED;
+ }
if (0 != __stt_check_handle(stt, &client)) {
return STT_ERROR_INVALID_PARAMETER;
}
static Eina_Bool __stt_connect_daemon(void *data)
{
stt_client_s* client = (stt_client_s*)data;
+ int ret = -1;
if (NULL == client) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] A handle is not available");
return EINA_FALSE;
}
+ if (0 == stt_client_get_size() || NULL == stt_client_get_by_uid(client->uid)) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Client has been already destroyed");
+ return EINA_FALSE;
+ }
+
+ /* Check and Set vconfkey of custom engine before sending hello */
+ if (1 == g_privilege_applaunch_allowed && NULL != client->current_engine_id) {
+ /* Set vconfkey */
+ ret = __stt_set_buxtonkey(client->current_engine_id);
+ if (0 != ret) {
+ SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] set buxtonkey Failed!!! (inside __stt_connect_daemon)");
+ return EINA_TRUE;
+ }
+ }
+
/* Send hello */
- int ret = -1;
ret = stt_dbus_request_hello(client->uid);
if (0 != ret) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to initialize : %s", __stt_get_error_code(ret));
client->reason = STT_ERROR_ENGINE_NOT_FOUND;
- ecore_timer_add(0, __stt_notify_error, (void*)client);
+ ecore_main_loop_thread_safe_call_async(__stt_notify_error, (void*)client);
return EINA_FALSE;
return STT_ERROR_INVALID_STATE;
}
- g_connect_timer = ecore_timer_add(0, __stt_connect_daemon, (void*)client);
+ g_connect_timer = ecore_timer_add(0.02, __stt_connect_daemon, (void*)client);
SLOG(LOG_DEBUG, TAG_STTC, "=====");
SLOG(LOG_DEBUG, TAG_STTC, " ");
}
int ret = -1;
- char appid[128] = {0, };
- ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid));
+ char appid[1024] = {0, };
+ ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
temp = strdup(language);
}
+ if (NULL == temp) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
+ return STT_ERROR_OUT_OF_MEMORY;
+ }
+
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);
+ free(temp);
+ temp = NULL;
return STT_ERROR_PERMISSION_DENIED;
}
+ client->internal_state = STT_INTERNAL_STATE_STARTING;
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));
+ client->internal_state = STT_INTERNAL_STATE_NONE;
} else {
SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
- client->internal_state = STT_INTERNAL_STATE_STARTING;
}
- if (NULL != temp) free(temp);
+ free(temp);
+ temp = NULL;
SLOG(LOG_DEBUG, TAG_STTC, "=====");
SLOG(LOG_DEBUG, TAG_STTC, " ");
return STT_ERROR_IN_PROGRESS_TO_PROCESSING;
}
+ client->internal_state = STT_INTERNAL_STATE_STOPPING;
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));
+ client->internal_state = STT_INTERNAL_STATE_NONE;
} else {
SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Stop is successful but not done");
- client->internal_state = STT_INTERNAL_STATE_STOPPING;
}
SLOG(LOG_DEBUG, TAG_STTC, "=====");
return STT_ERROR_IN_PROGRESS_TO_READY;
}
+ client->internal_state = STT_INTERNAL_STATE_CANCELING;
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));
+ client->internal_state = STT_INTERNAL_STATE_NONE;
} else {
SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel is successful but not done");
- client->internal_state = STT_INTERNAL_STATE_CANCELING;
}
SLOG(LOG_DEBUG, TAG_STTC, "=====");
return ret;
}
-static Eina_Bool __stt_notify_error(void *data)
+static void __stt_notify_error(void *data)
{
stt_client_s* client = (stt_client_s*)data;
/* check handle */
if (NULL == client) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to notify error : A handle is not valid");
- return EINA_FALSE;
+ return;
}
if (NULL == stt_client_get_by_uid(client->uid))
- return EINA_FALSE;
+ return;
if (NULL != client->error_cb) {
stt_client_use_callback(client);
SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
}
- return EINA_FALSE;
+ return;
}
int __stt_cb_error(int uid, int reason, char* err_msg)
SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
if (NULL != data->error_cb) {
- ecore_timer_add(0, __stt_notify_error, data);
+ ecore_main_loop_thread_safe_call_async(__stt_notify_error, data);
} else {
SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
}
SLOG(LOG_INFO, TAG_STTC, "internal state is initialized to 0");
if (NULL != client->error_cb) {
- ecore_timer_add(0, __stt_notify_error, client);
+ ecore_main_loop_thread_safe_call_async(__stt_notify_error, client);
} else {
SLOG(LOG_WARN, TAG_STTC, "[WARNING] Error callback is null");
}
client->state_changed_cb(client->stt, client->before_state,
client->current_state, client->state_changed_user_data);
stt_client_not_use_callback(client);
- SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called");
+ SLOG(LOG_DEBUG, TAG_STTC, "State changed callback is called, State(%d)", client->current_state);
} else {
- SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null");
+ SLOG(LOG_WARN, TAG_STTC, "[WARNING] State changed callback is null, State(%d)", client->current_state);
}
return;
}
if (NULL != msg)
- SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
+ SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result Message = %s", msg);
int i = 0;
for (i = 0; i < data_count; i++) {
if (NULL != data[i])
- SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
+ SECURE_SLOG(LOG_DEBUG, TAG_STTC, "Recognition Result[%d] = %s", i, data[i]);
}
if (NULL != client->recognition_result_cb) {
SLOG(LOG_ERROR, TAG_STTC, "[ERROR] User result callback is null");
}
- ecore_timer_add(0, __stt_notify_result, client);
+ __stt_notify_result(client);
return STT_ERROR_NONE;
}
return 0;
}
+
+int stt_start_file(stt_h stt, const char* language, const char* type, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
+{
+ 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 == filepath) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Input parameter is NULL");
+ return STT_ERROR_INVALID_PARAMETER;
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTC, "===== STT START FILE");
+
+ /* 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);
+ 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_IN_PROGRESS_TO_RECORDING;
+ }
+
+ int ret = -1;
+ char appid[1024] = {0, };
+ ret = aul_app_get_appid_bypid(getpid(), appid, sizeof(appid) - 1);
+
+ if ((AUL_R_OK != ret) || (0 == strlen(appid))) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to get application ID");
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Current app id is %s", appid);
+ }
+
+ char* temp = NULL;
+ if (NULL == language) {
+ temp = strdup("default");
+ } else {
+ temp = strdup(language);
+ }
+
+ if (NULL == temp) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
+ return STT_ERROR_OUT_OF_MEMORY;
+ }
+
+ 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);
+ free(temp);
+ temp = NULL;
+ return STT_ERROR_PERMISSION_DENIED;
+ }
+
+ client->internal_state = STT_INTERNAL_STATE_STARTING;
+ ret = stt_dbus_request_start_file(client->uid, temp, type, client->silence, appid, client->credential, filepath, audio_type, sample_rate);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to start file : %s", __stt_get_error_code(ret));
+ client->internal_state = STT_INTERNAL_STATE_NONE;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Start is successful but not done");
+ }
+
+ free(temp);
+ temp = NULL;
+
+ SLOG(LOG_DEBUG, TAG_STTC, "=====");
+ SLOG(LOG_DEBUG, TAG_STTC, " ");
+
+ return ret;
+}
+
+int stt_cancel_file(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;
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTC, "===== STT CANCEL FILE");
+
+ /* 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_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;
+ }
+
+ client->internal_state = STT_INTERNAL_STATE_CANCELING;
+ int ret = stt_dbus_request_cancel_file(client->uid);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to cancel file : %s", __stt_get_error_code(ret));
+ client->internal_state = STT_INTERNAL_STATE_NONE;
+ } else {
+ SLOG(LOG_DEBUG, TAG_STTC, "[SUCCESS] Cancel file is successful but not done");
+ }
+
+ SLOG(LOG_DEBUG, TAG_STTC, "=====");
+ SLOG(LOG_DEBUG, TAG_STTC, " ");
+
+ return ret;
+}
+