/*
-* 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
#include <unistd.h>
#include <sys/inotify.h>
#include <vconf.h>
+#include <buxton2.h>
#include "stt_config_mgr.h"
#include "stt_defs.h"
#include "stt_config_parser.h"
-#define VCONFKEY_VOICE_INPUT_LANGUAGE "db/voice_input/language"
typedef struct {
int uid;
stt_config_lang_changed_cb lang_cb;
stt_config_bool_changed_cb bool_cb;
void* user_data;
-}stt_config_client_s;
+} stt_config_client_s;
extern const char* stt_tag();
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
- int i = 1;
+ int i = 1;
while (NULL != iter_lang) {
/*Get handle data from list*/
engine_lang = iter_lang->data;
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", i, engine_lang);
+ SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", i, engine_lang);
if (0 == strcmp(language, engine_lang)) {
return true;
{
if (NULL == engine_id || NULL == language) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Input parameter is NULL");
- return false;
+ return STT_CONFIG_ERROR_INVALID_PARAMETER;
}
GSList *iter = NULL;
if (0 >= g_slist_length(g_engine_list)) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] There is no engine!!");
- return false;
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
}
/* Get a first item */
if (NULL == engine_info) {
SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
- return false;
+ iter = g_slist_next(iter);
+ continue;
}
if (0 != strcmp(engine_id, engine_info->uuid)) {
iter = g_slist_next(iter);
continue;
}
-
- GSList *iter_lang = NULL;
- char* engine_lang = NULL;
- if (g_slist_length(engine_info->languages) > 0) {
- /* Get a first item */
- iter_lang = g_slist_nth(engine_info->languages, 0);
-
- while (NULL != iter_lang) {
- engine_lang = iter_lang->data;
- if (NULL != engine_lang) {
- /* Default language is STT_BASE_LANGUAGE */
- if (0 == strcmp(STT_BASE_LANGUAGE, engine_lang)) {
- *language = strdup(engine_lang);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *language);
- return 0;
- }
- }
- iter_lang = g_slist_next(iter_lang);
- }
+ if (NULL == engine_info->default_lang) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Default language of the engine info is NULL");
+ return STT_CONFIG_ERROR_INVALID_LANGUAGE;
+ }
- /* Not support STT_BASE_LANGUAGE */
- if (NULL != engine_lang) {
- *language = strdup(engine_lang);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *language);
- return 0;
- }
+ *language = strdup(engine_info->default_lang);
+
+ if (NULL != *language) {
+ SLOG(LOG_DEBUG, stt_tag(), "Selected language : %s", *language);
+ return STT_CONFIG_ERROR_NONE;
}
- break;
}
- return -1;
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
}
Eina_Bool stt_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty Inotify event");
SLOG(LOG_DEBUG, stt_tag(), "=====");
SLOG(LOG_DEBUG, stt_tag(), " ");
- return ECORE_CALLBACK_PASS_ON;
+ return ECORE_CALLBACK_PASS_ON;
}
if (IN_MODIFY == event.mask) {
char* lang = NULL;
int auto_lang = -1;
int silence = -1;
+ int credential = -1;
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
- if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence))
+ if (0 != stt_parser_find_config_changed(&engine, &setting, &auto_lang, &lang, &silence, &credential))
return ECORE_CALLBACK_PASS_ON;
/* Engine changed */
if (-1 != silence) g_config_info->silence_detection = silence;
+ if (-1 != credential) g_config_info->credential = credential;
+
/* Call all callbacks of client*/
iter = g_slist_nth(g_config_client_list, 0);
if (NULL != temp_client) {
if (NULL != temp_client->engine_cb) {
temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
- g_config_info->silence_detection, temp_client->user_data);
+ g_config_info->silence_detection, g_config_info->credential, temp_client->user_data);
}
}
wd = inotify_add_watch(fd, STT_CONFIG, IN_MODIFY);
g_wd_noti = wd;
- g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
+ g_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)stt_config_mgr_inotify_event_cb, NULL, NULL, NULL);
if (NULL == g_fd_handler_noti) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get handler_noti");
return -1;
int __stt_config_set_auto_language()
{
char* value = NULL;
- value = vconf_get_str(VCONFKEY_VOICE_INPUT_LANGUAGE);
+ char candidate_lang[6] = {'\0', };
+
+ value = vconf_get_str(VCONFKEY_LANGSET);
if (NULL == value) {
- SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get voice input language");
+ SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
return -1;
}
- char candidate_lang[6] = {'\0', };
+ strncpy(candidate_lang, value, 5);
+ free(value);
- /* Check auto is on or not */
- if (0 == strncmp(value, "auto", 4)) {
- free(value);
-
- value = vconf_get_str(VCONFKEY_LANGSET);
- if (NULL == value) {
- SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Fail to get display language");
- return -1;
- }
+ /* Check current config info */
+ if (NULL == g_config_info) {
+ SLOG(LOG_ERROR, stt_tag(), "Current config info is NULL");
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
- strncpy(candidate_lang, value, 5);
- free(value);
+ /* Check current language */
+ if (NULL == g_config_info->language) {
+ SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
- /* Check current language */
- if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
- return 0;
- } else {
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
- }
+ if (0 == strncmp(g_config_info->language, candidate_lang, 5)) {
+ SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. STT language(%s) is same with display lang", g_config_info->language);
+ return 0;
} else {
- strncpy(candidate_lang, value, 5);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Voice input language is NOT auto. Voice input language : %s", candidate_lang);
-
- free(value);
+ SLOG(LOG_DEBUG, stt_tag(), "[Config] Display language : %s", candidate_lang);
}
if (true == __stt_config_mgr_check_lang_is_valid(g_config_info->engine_id, candidate_lang)) {
- /* stt default language change */
- if (NULL == g_config_info->language) {
- SLOG(LOG_ERROR, stt_tag(), "Current config language is NULL");
- return -1;
- }
-
char* before_lang = NULL;
if (0 != stt_parser_set_language(candidate_lang)) {
SLOG(LOG_ERROR, stt_tag(), "Fail to save default language");
free(g_config_info->language);
g_config_info->language = strdup(candidate_lang);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
+ SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto. Set default language(%s)", g_config_info->language);
/* Call all callbacks of client*/
GSList *iter = NULL;
return -1;
}
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
+ SLOG(LOG_DEBUG, stt_tag(), "[Config] Language is auto but display lang is not supported. Default language change(%s)", tmp_language);
/* Call all callbacks of client*/
GSList *iter = NULL;
iter = g_slist_next(iter);
}
- if (NULL != g_config_info->language) {
- free(g_config_info->language);
- g_config_info->language = strdup(tmp_language);
- }
+ free(g_config_info->language);
+ g_config_info->language = strdup(tmp_language);
free(tmp_language);
+ tmp_language = NULL;
}
return 0;
return;
}
-int stt_config_mgr_initialize(int uid)
+void __stt_config_release_client(int uid)
{
GSList *iter = NULL;
- int* get_uid;
stt_config_client_s* temp_client = NULL;
if (0 < g_slist_length(g_config_client_list)) {
iter = g_slist_nth(g_config_client_list, 0);
while (NULL != iter) {
- get_uid = iter->data;
+ temp_client = iter->data;
- if (uid == *get_uid) {
- SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
- return 0;
+ if (NULL != temp_client) {
+ if (uid == temp_client->uid) {
+ g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
+ free(temp_client);
+ temp_client = NULL;
+ break;
+ }
}
iter = g_slist_next(iter);
}
+ }
- temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
- temp_client->uid = uid;
- temp_client->bool_cb = NULL;
- temp_client->engine_cb = NULL;
- temp_client->lang_cb = NULL;
- temp_client->user_data = NULL;
+ if (0 < g_slist_length(g_config_client_list)) {
+ SLOG(LOG_DEBUG, stt_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
+ }
+ return;
+}
- /* Add uid */
- g_config_client_list = g_slist_append(g_config_client_list, temp_client);
+void __stt_config_release_engine()
+{
+ GSList *iter = NULL;
+ stt_engine_info_s *engine_info = NULL;
- SECURE_SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
- return STT_CONFIG_ERROR_NONE;
+ if (0 < g_slist_length(g_engine_list)) {
+
+ /* Get a first item */
+ iter = g_slist_nth(g_engine_list, 0);
+
+ while (NULL != iter) {
+ engine_info = iter->data;
+
+ if (NULL != engine_info) {
+ g_engine_list = g_slist_remove(g_engine_list, engine_info);
+
+ stt_parser_free_engine_info(engine_info);
+ }
+
+ iter = g_slist_nth(g_engine_list, 0);
+ }
}
+ return;
+}
- /* Get file name from default engine directory */
+int __stt_config_mgr_check_engine_is_valid(const char* engine_id)
+{
+ if (NULL == engine_id) {
+ SLOG(LOG_ERROR, stt_tag(), "Input parameter is NULL");
+ return STT_CONFIG_ERROR_INVALID_PARAMETER;
+ }
+
+ GSList *iter = NULL;
+ stt_engine_info_s *engine_info = NULL;
+
+ if (0 >= g_slist_length(g_engine_list)) {
+ SLOG(LOG_ERROR, stt_tag(), "There is no engine!!");
+ return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
+ }
+
+ /* Get a first item */
+ iter = g_slist_nth(g_engine_list, 0);
+
+ while (NULL != iter) {
+ engine_info = iter->data;
+
+ if (NULL == engine_info) {
+ SLOG(LOG_ERROR, stt_tag(), "engine info is NULL");
+ return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
+ }
+
+ if (0 == strcmp(engine_id, engine_info->uuid)) {
+ SLOG(LOG_DEBUG, stt_tag(), "Default engine is valid : %s", engine_id);
+ return STT_CONFIG_ERROR_NONE;
+ }
+
+ iter = g_slist_next(iter);
+ }
+
+ /* Change default engine */
+ iter = g_slist_nth(g_engine_list, 0);
+ if (NULL == iter) {
+ SLOG(LOG_ERROR, stt_tag(), "Operation failed - false engine");
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+
+ engine_info = iter->data;
+ if (NULL == engine_info) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Engine info is NULL");
+ return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
+ }
+
+ if (NULL != g_config_info->engine_id) {
+ free(g_config_info->engine_id);
+ g_config_info->engine_id = NULL;
+ }
+ if (NULL != g_config_info->setting) {
+ free(g_config_info->setting);
+ g_config_info->setting = NULL;
+ }
+
+ if (NULL != engine_info->uuid) {
+ g_config_info->engine_id = strdup(engine_info->uuid);
+ }
+
+ if (NULL != engine_info->setting) {
+ g_config_info->setting = strdup(engine_info->setting);
+ }
+
+ /* Engine is valid*/
+ GSList *iter_lang = NULL;
+ char* lang;
+ bool is_valid_lang = false;
+
+ if (0 >= g_slist_length(engine_info->languages)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Empty supported language");
+ return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
+ }
+
+ /* Get a first item */
+ iter_lang = g_slist_nth(engine_info->languages, 0);
+
+ while (NULL != iter_lang) {
+ /*Get handle data from list*/
+ lang = iter_lang->data;
+
+ SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
+ if (NULL != lang) {
+ if (0 == strcmp(lang, g_config_info->language)) {
+ /* language is valid */
+ is_valid_lang = true;
+ break;
+ }
+ }
+
+ /*Get next item*/
+ iter_lang = g_slist_next(iter_lang);
+ }
+
+ if (false == is_valid_lang) {
+ iter_lang = g_slist_nth(engine_info->languages, 0);
+ if (NULL != iter_lang) {
+ lang = iter_lang->data;
+ if (NULL != lang) {
+ if (NULL != g_config_info->language)
+ free(g_config_info->language);
+ g_config_info->language = strdup(lang);
+ }
+ }
+ }
+
+ /* Check options */
+ if (false == engine_info->support_silence_detection) {
+ if (true == g_config_info->silence_detection)
+ g_config_info->silence_detection = false;
+ }
+
+ SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
+ SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
+ SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
+ SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
+ SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
+ SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
+
+ if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
+ g_config_info->silence_detection, g_config_info->credential)) {
+ SLOG(LOG_ERROR, stt_tag(), "Fail to save config");
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+
+ return STT_CONFIG_ERROR_NONE;
+}
+
+static void __get_engine_list(const char* directory)
+{
DIR *dp = NULL;
- int ret = -1;
- struct dirent entry;
struct dirent *dirp = NULL;
- g_engine_list = NULL;
+ if (NULL == directory) {
+ SLOG(LOG_ERROR, stt_tag(), "[Directory ERROR] Directory is NULL");
+ return;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "[Directory DEBUG] Directory: %s", directory);
+ }
- dp = opendir(STT_DEFAULT_ENGINE_INFO);
+ dp = opendir(directory);
if (NULL != dp) {
do {
- ret = readdir_r(dp, &entry, &dirp);
- if (0 != ret) {
- SLOG(LOG_ERROR, stt_tag(), "[File ERROR] Fail to read directory");
- break;
- }
+ dirp = readdir(dp);
if (NULL != dirp) {
if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
continue;
stt_engine_info_s* info;
- char* filepath;
+ char* filepath = NULL;
int filesize;
- filesize = strlen(STT_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 5;
+ filesize = strlen(directory) + strlen(dirp->d_name) + 5;
filepath = (char*)calloc(filesize, sizeof(char));
if (NULL != filepath) {
- snprintf(filepath, filesize, "%s/%s", STT_DEFAULT_ENGINE_INFO, dirp->d_name);
+ snprintf(filepath, filesize, "%s/%s", directory, dirp->d_name);
} else {
SLOG(LOG_ERROR, stt_tag(), "[Config ERROR] Memory not enough!!");
continue;
}
+ SLOG(LOG_DEBUG, stt_tag(), "[File DEBUG] File path: %s", filepath);
+
if (0 == stt_parser_get_engine_info(filepath, &info)) {
g_engine_list = g_slist_append(g_engine_list, info);
}
- if (NULL != filepath)
+ if (NULL != filepath) {
free(filepath);
+ filepath = NULL;
+ }
}
} while (NULL != dirp);
closedir(dp);
} else {
- SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open default directory");
+ SLOG(LOG_WARN, stt_tag(), "[Config WARNING] Fail to open directory");
}
+ return;
+}
+
+int stt_config_mgr_initialize(int uid)
+{
+ GSList *iter = NULL;
+ int* get_uid;
+ stt_config_client_s* temp_client = NULL;
+
+ if (0 < g_slist_length(g_config_client_list)) {
+ /* Check uid */
+ iter = g_slist_nth(g_config_client_list, 0);
+
+ while (NULL != iter) {
+ get_uid = iter->data;
+
+ if (uid == *get_uid) {
+ SLOG(LOG_WARN, stt_tag(), "[CONFIG] uid(%d) has already registered", uid);
+ return 0;
+ }
+
+ iter = g_slist_next(iter);
+ }
+
+ temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
+ if (NULL == temp_client) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+ return STT_CONFIG_ERROR_OUT_OF_MEMORY;
+ }
+ temp_client->uid = uid;
+ temp_client->bool_cb = NULL;
+ temp_client->engine_cb = NULL;
+ temp_client->lang_cb = NULL;
+ temp_client->user_data = NULL;
+
+ /* Add uid */
+ g_config_client_list = g_slist_append(g_config_client_list, temp_client);
+
+ SLOG(LOG_WARN, stt_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
+ return STT_CONFIG_ERROR_NONE;
+ }
+
+ /* Make directories */
+ if (0 != access(STT_CONFIG_BASE, F_OK)) {
+ if (0 != mkdir(STT_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_CONFIG_BASE);
+ __stt_config_release_client(uid);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_CONFIG_BASE);
+ }
+ }
+
+ if (0 != access(STT_HOME, F_OK)) {
+ if (0 != mkdir(STT_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_HOME);
+ __stt_config_release_client(uid);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_HOME);
+ }
+ }
+
+ if (0 != access(STT_DOWNLOAD_BASE, F_OK)) {
+ if (0 != mkdir(STT_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_BASE);
+ __stt_config_release_client(uid);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_BASE);
+ }
+ }
+
+ if (0 != access(STT_DOWNLOAD_ENGINE_INFO, F_OK)) {
+ if (0 != mkdir(STT_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
+ __stt_config_release_client(uid);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "Success to make directory : %s", STT_DOWNLOAD_ENGINE_INFO);
+ }
+ }
+
+
+ /* Get file name from default engine directory */
+ g_engine_list = NULL;
+
+ SLOG(LOG_WARN, stt_tag(), "[CONFIG] default engine info(%s)", STT_DEFAULT_ENGINE_INFO);
+
+ SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get default engine list");
+ __get_engine_list(STT_DEFAULT_ENGINE_INFO);
+ SLOG(LOG_DEBUG, stt_tag(), "[CONFIG] Get download engine list");
+ __get_engine_list(STT_DOWNLOAD_ENGINE_INFO);
+
__stt_config_mgr_print_engine_info();
if (0 != stt_parser_load_config(&g_config_info)) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to parse configure information");
- return -1;
+ __stt_config_release_client(uid);
+ __stt_config_release_engine();
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+
+ /* Check whether engine id is valid */
+ if (0 != __stt_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to get default engine");
+ __stt_config_release_client(uid);
+ __stt_config_release_engine();
+ stt_parser_unload_config(g_config_info);
+ return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
}
if (true == g_config_info->auto_lang) {
char* tmp_language;
if (0 != __stt_config_mgr_select_lang(g_config_info->engine_id, &tmp_language)) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to select language");
- return -1;
+ __stt_config_release_client(uid);
+ __stt_config_release_engine();
+ stt_parser_unload_config(g_config_info);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
}
if (NULL != tmp_language) {
}
}
- /* print daemon config */
- SLOG(LOG_DEBUG, stt_tag(), "== Daemon config ==");
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
+ /* print stt-service config */
+ SLOG(LOG_DEBUG, stt_tag(), "== STT service config ==");
+ SLOG(LOG_DEBUG, stt_tag(), " engine : %s", g_config_info->engine_id);
+ SLOG(LOG_DEBUG, stt_tag(), " setting : %s", g_config_info->setting);
+ SLOG(LOG_DEBUG, stt_tag(), " auto language : %s", g_config_info->auto_lang ? "on" : "off");
+ SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
+ SLOG(LOG_DEBUG, stt_tag(), " silence detection : %s", g_config_info->silence_detection ? "on" : "off");
+ SLOG(LOG_DEBUG, stt_tag(), " credential : %s", g_config_info->credential ? "true" : "false");
SLOG(LOG_DEBUG, stt_tag(), "===================");
if (0 != __stt_config_mgr_register_config_event()) {
SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to register config event");
+ __stt_config_release_client(uid);
+ __stt_config_release_engine();
+ stt_parser_unload_config(g_config_info);
return STT_CONFIG_ERROR_OPERATION_FAILED;
}
/* Register to detect display language change */
vconf_notify_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb, NULL);
- vconf_notify_key_changed(VCONFKEY_VOICE_INPUT_LANGUAGE, __stt_config_language_changed_cb, NULL);
temp_client = (stt_config_client_s*)calloc(1, sizeof(stt_config_client_s));
+ if (NULL == temp_client) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+ return STT_CONFIG_ERROR_OUT_OF_MEMORY;
+ }
temp_client->uid = uid;
temp_client->bool_cb = NULL;
temp_client->engine_cb = NULL;
}
vconf_ignore_key_changed(VCONFKEY_LANGSET, __stt_config_language_changed_cb);
- vconf_ignore_key_changed(VCONFKEY_VOICE_INPUT_LANGUAGE, __stt_config_language_changed_cb);
__stt_config_mgr_unregister_config_event();
}
int stt_config_mgr_unset_callback(int uid)
-{
+{
GSList *iter = NULL;
stt_config_client_s* temp_client = NULL;
engine_info->setting, engine_info->support_silence_detection, user_data)) {
break;
}
-
+
iter = g_slist_next(iter);
}
return STT_CONFIG_ERROR_NONE;
}
+int __stt_config_set_buxtonkey(const char* engine)
+{
+ /* Set vconfkey */
+ struct buxton_client * bux_cli;
+ struct buxton_layer * bux_layer;
+ struct buxton_value * bux_val;
+
+ int ret = buxton_open(&bux_cli, NULL, NULL);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+ bux_layer = buxton_create_layer("system");
+ if (NULL == bux_layer) {
+ SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
+ buxton_close(bux_cli);
+ bux_cli = NULL;
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+ bux_val = buxton_value_create_string(engine);
+ if (NULL == bux_val) {
+ SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
+ buxton_free_layer(bux_layer);
+ buxton_close(bux_cli);
+ bux_layer = NULL;
+ bux_cli = NULL;
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ } else {
+ SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
+ }
+
+ ret = buxton_set_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, bux_val);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, stt_tag(), "[DBUS-BUXTON2] Fail to set value sync, ret(%d)", ret);
+ buxton_value_free(bux_val);
+ buxton_free_layer(bux_layer);
+ buxton_close(bux_cli);
+
+ bux_cli = NULL;
+ bux_layer = NULL;
+ bux_val = NULL;
+ return STT_CONFIG_ERROR_OPERATION_FAILED;
+ }
+ SLOG(LOG_DEBUG, stt_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %s", STT_ENGINE_DB_DEFAULT);
+
+ buxton_value_free(bux_val);
+ buxton_free_layer(bux_layer);
+ buxton_close(bux_cli);
+
+ bux_cli = NULL;
+ bux_layer = NULL;
+ bux_val = NULL;
+
+ return STT_CONFIG_ERROR_NONE;
+}
+
int stt_config_mgr_set_engine(const char* engine)
{
if (0 >= g_slist_length(g_config_client_list)) {
return 0;
}
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
+ SLOG(LOG_DEBUG, stt_tag(), "New engine id : %s", engine);
+
+ int ret = __stt_config_set_buxtonkey(engine);
+ if (0 != ret) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] set buxtonkey Failed!!!");
+ return ret;
+ }
GSList *iter = NULL;
stt_engine_info_s *engine_info = NULL;
continue;
}
- if (NULL != g_config_info->engine_id)
+ if (NULL != g_config_info->engine_id) {
free(g_config_info->engine_id);
+ g_config_info->engine_id = NULL;
+ }
g_config_info->engine_id = strdup(engine);
if (NULL != g_config_info->setting) {
free(g_config_info->setting);
+ g_config_info->setting = NULL;
}
if (NULL != engine_info->setting) {
/*Get handle data from list*/
lang = iter_lang->data;
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
- if (NULL != lang) {
+ SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
+ if (NULL != lang && NULL != g_config_info->language) {
if (0 == strcmp(lang, g_config_info->language)) {
/* language is valid */
is_valid_lang = true;
- if (NULL != g_config_info->language) {
- free(g_config_info->language);
+ free(g_config_info->language);
+ g_config_info->language = strdup(lang);
- g_config_info->language = strdup(lang);
- }
break;
}
}
if (false == is_valid_lang) {
if (NULL != g_config_info->language) {
free(g_config_info->language);
+ g_config_info->language = NULL;
iter_lang = g_slist_nth(engine_info->languages, 0);
+ if (NULL == iter_lang) {
+ SLOG(LOG_ERROR, stt_tag(), "Fail to get default language");
+ break;
+ }
+
lang = iter_lang->data;
g_config_info->language = strdup(lang);
g_config_info->silence_detection = false;
}
+ if (false == engine_info->need_credential) {
+ if (true == g_config_info->credential)
+ g_config_info->credential = false;
+ }
+
is_valid_engine = true;
break;
}
if (true == is_valid_engine) {
SLOG(LOG_DEBUG, stt_tag(), "[Config] Engine changed");
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
-
- if ( 0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
- g_config_info->silence_detection)) {
+ SLOG(LOG_DEBUG, stt_tag(), " Engine : %s", g_config_info->engine_id);
+ SLOG(LOG_DEBUG, stt_tag(), " Setting : %s", g_config_info->setting);
+ SLOG(LOG_DEBUG, stt_tag(), " language : %s", g_config_info->language);
+ SLOG(LOG_DEBUG, stt_tag(), " Silence detection : %s", g_config_info->silence_detection ? "on" : "off");
+ SLOG(LOG_DEBUG, stt_tag(), " Credential : %s", g_config_info->credential ? "true" : "false");
+
+ if (0 != stt_parser_set_engine(g_config_info->engine_id, g_config_info->setting, g_config_info->language,
+ g_config_info->silence_detection, g_config_info->credential)) {
SLOG(LOG_ERROR, stt_tag(), " Fail to save config");
return STT_CONFIG_ERROR_OPERATION_FAILED;
}
if (NULL == engine) {
current_engine = strdup(g_config_info->engine_id);
+ if (NULL == current_engine) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+ return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
+ }
} else {
current_engine = strdup(engine);
+ if (NULL == current_engine) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+ return STT_CONFIG_ERROR_OUT_OF_MEMORY;;
+ }
}
/* Get a first item */
SLOG(LOG_ERROR, stt_tag(), "Not initialized");
return STT_CONFIG_ERROR_INVALID_STATE;
}
-
+
if (0 >= g_slist_length(g_engine_list)) {
SLOG(LOG_ERROR, stt_tag(), "There is no engine");
return STT_CONFIG_ERROR_ENGINE_NOT_FOUND;
GSList *iter_lang = NULL;
char* lang;
-
+
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
/*Get handle data from list*/
lang = iter_lang->data;
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
if (NULL != lang) {
+ SLOG(LOG_DEBUG, stt_tag(), " %s", lang);
if (false == callback(engine_info->uuid, lang, user_data))
break;
}
-
+
/*Get next item*/
iter_lang = g_slist_next(iter_lang);
}
return false;
}
- if (0 >= g_slist_length(g_engine_list))
+ if (0 >= g_slist_length(g_engine_list))
return false;
GSList *iter = NULL;
return false;
}
- if (0 >= g_slist_length(g_engine_list))
+ if (0 >= g_slist_length(g_engine_list))
return false;
GSList *iter = NULL;
iter = g_slist_next(iter);
continue;
}
-
+
if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
iter = g_slist_next(iter);
continue;
while (NULL != iter_lang) {
lang = iter_lang->data;
-
+
if (0 == strcmp(language, lang))
return true;
SLOG(LOG_DEBUG, stt_tag(), "--------------- engine list -----------------");
- int i = 1;
+ int i = 1;
while (NULL != iter) {
engine_info = iter->data;
- SECURE_SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
+ SLOG(LOG_DEBUG, stt_tag(), "[%dth]", i);
+ SLOG(LOG_DEBUG, stt_tag(), " name : %s", engine_info->name);
+ SLOG(LOG_DEBUG, stt_tag(), " id : %s", engine_info->uuid);
+ SLOG(LOG_DEBUG, stt_tag(), " setting : %s", engine_info->setting);
+ SLOG(LOG_DEBUG, stt_tag(), " agreement : %s", engine_info->agreement);
SLOG(LOG_DEBUG, stt_tag(), " languages");
GSList *iter_lang = NULL;
/* Get a first item */
iter_lang = g_slist_nth(engine_info->languages, 0);
- int j = 1;
+ int j = 1;
while (NULL != iter_lang) {
/*Get handle data from list*/
lang = iter_lang->data;
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
+ SLOG(LOG_DEBUG, stt_tag(), " [%dth] %s", j, lang);
/*Get next item*/
iter_lang = g_slist_next(iter_lang);
} else {
SLOG(LOG_ERROR, stt_tag(), " language is NONE");
}
- SECURE_SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
+ SLOG(LOG_DEBUG, stt_tag(), " silence support : %s",
engine_info->support_silence_detection ? "true" : "false");
iter = g_slist_next(iter);
i++;
g_time_list = g_slist_remove(g_time_list, data);
if (NULL != data) {
- if (NULL == data->text) free(data->text);
+ if (NULL != data->text) {
+ free(data->text);
+ data->text = NULL;
+ }
free(data);
+ data = NULL;
}
/*Get next item*/
}
stt_result_time_info_s *info = (stt_result_time_info_s*)calloc(1, sizeof(stt_result_time_info_s));
-
+ if (NULL == info) {
+ SLOG(LOG_ERROR, stt_tag(), "[ERROR] Fail to allocate memory");
+ return STT_CONFIG_ERROR_OUT_OF_MEMORY;
+ }
info->index = index;
info->event = event;
if (NULL != text) {
info->start_time = start_time;
info->end_time = end_time;
+ SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: index(%d), text(%s), start time(%ld), end_time(%ld)", info->index, (NULL == info->text) ? "NULL" : info->text, info->start_time, info->end_time);
+
/* Add item to global list */
g_time_list = g_slist_append(g_time_list, info);
+ SLOG(LOG_DEBUG, stt_tag(), "[DEBUG] inside stt_config_mgr_add_time_info: g_time_list length(%d)", g_slist_length(g_time_list));
+
return 0;
}
ret = stt_parser_get_time_info(&temp_time);
if (0 != ret) {
SLOG(LOG_WARN, stt_tag(), "[WARNING] Fail to get time info : %d", ret);
- return STT_CONFIG_ERROR_OPERATION_FAILED;
+ return STT_CONFIG_ERROR_NONE;
}
GSList *iter = NULL;
if (NULL != data) {
temp_time = g_slist_remove(temp_time, data);
- if (NULL == data->text) free(data->text);
+ if (NULL != data->text) {
+ free(data->text);
+ data->text = NULL;
+ }
free(data);
+ data = NULL;
}
/*Get next item*/
stt_parser_clear_time_info();
return STT_CONFIG_ERROR_NONE;
-}
\ No newline at end of file
+}
projects / platform / core / uifw / stt.git / blobdiff