common/tts_config_mgr.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <dirent.h>
  15 #include <dlfcn.h>
  16 #include <dlog.h>
  17 #include <Ecore.h>
  18 #include <fcntl.h>
  19 #include <glib.h>
  20 #include <unistd.h>
  21 #include <sys/inotify.h>
  22 #include <vconf.h>
  23 #include <buxton2.h>
  24
  25 #include "tts_config_mgr.h"
  26 #include "tts_config_parser.h"
  27 #include "tts_defs.h"
  28
  29
  30 const static int TTS_CONFIG_VOICE_TYPE_NONE = 0;
  31
  32
  33 typedef struct {
  34         unsigned int    uid;
  35         tts_config_engine_changed_cb            engine_cb;
  36         tts_config_voice_changed_cb             voice_cb;
  37         tts_config_speech_rate_changed_cb       speech_cb;
  38         tts_config_screen_reader_changed_cb     screen_cb;
  39         tts_config_pitch_changed_cb             pitch_cb;
  40         tts_config_bg_volume_ratio_changed_cb bg_volume_ratio_cb;
  41         void*   user_data;
  42         void*   screen_user_data;
  43 } tts_config_client_s;
  44
  45 typedef struct {
  46         const char* engine_id;
  47         const char* setting;
  48         const char* language;
  49         int voice_type;
  50         bool auto_voice;
  51         bool need_credential;
  52 } engine_changed_cb_parameter_s;
  53
  54 typedef struct {
  55         const char* before_language;
  56         int before_voice_type;
  57         const char* current_language;
  58         int current_voice_type;
  59         bool auto_voice;
  60 } voice_changed_cb_parameter_s;
  61
  62
  63 static GSList* g_engine_list = NULL;
  64
  65 static GSList* g_config_client_list = NULL;
  66
  67 extern char g_engine_id[128];
  68 extern char g_setting[128];
  69 extern char g_language[128];
  70
  71 static Ecore_Fd_Handler* g_config_fd_handler_noti = NULL;
  72 static int g_config_fd_noti;
  73 static int g_config_wd_noti;
  74
  75 static int g_client_type = 0x0;
  76
  77 /* For engine directory monitoring */
  78 typedef struct {
  79         Ecore_Fd_Handler* dir_fd_handler;
  80         int dir_fd;
  81         int dir_wd;
  82 } tts_engine_inotify_s;
  83
  84 static GList* g_ino_list = NULL;
  85
  86 int __tts_config_mgr_print_engine_info();
  87 static int __tts_config_mgr_register_engine_config_updated_event(const char* path);
  88 static int __tts_config_mgr_unregister_engine_config_updated_event();
  89
  90 static char* __get_default_engine_app_id()
  91 {
  92         char* engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
  93         if (NULL == engine_name) {
  94                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine name");
  95                 engine_name = strdup(TTS_SERVER_ENGINE_DEFAULT);
  96         }
  97
  98         return engine_name;
  99 }
 100
 101 static tts_engine_info_s* __get_engine_info(const char* engine_id)
 102 {
 103         if (NULL == engine_id) {
 104                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine_id is NULL");
 105                 return NULL;
 106         }
 107
 108         for (GSList* iter = g_slist_nth(g_engine_list, 0); NULL != iter; iter = g_slist_next(iter)) {
 109                 tts_engine_info_s* engine_info = iter->data;
 110                 if (NULL == engine_info) {
 111                         SLOG(LOG_WARN, TAG_TTSCONFIG, "engine info is NULL");
 112                         continue;
 113                 }
 114
 115                 if (NULL != engine_info->uuid && 0 == strcmp(engine_id, engine_info->uuid)) {
 116                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to find engine info : %s", engine_id);
 117                         return engine_info;
 118                 }
 119         }
 120
 121         return NULL;
 122 }
 123
 124 static tts_config_voice_s* __get_voice_info(tts_engine_info_s* engine_info, const char* language, int voice_type)
 125 {
 126         if (NULL == engine_info) {
 127                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine_info is NULL");
 128                 return NULL;
 129         }
 130
 131         if (NULL == language) {
 132                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "language is NULL");
 133                 return NULL;
 134         }
 135
 136         for (GSList* iter = g_slist_nth(engine_info->voices, 0); NULL != iter; iter = g_slist_next(iter)) {
 137                 tts_config_voice_s* voice = iter->data;
 138                 if (NULL == voice) {
 139                         SLOG(LOG_WARN, TAG_TTSCONFIG, "voice is NULL");
 140                         continue;
 141                 }
 142
 143                 if (0 != strcmp(language, voice->language)) {
 144                         continue;
 145                 }
 146
 147                 if (TTS_CONFIG_VOICE_TYPE_NONE == voice_type || voice_type == voice->type) {
 148                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to find voice : %s, %d", language, voice_type);
 149                         return voice;
 150                 }
 151         }
 152
 153         return NULL;
 154 }
 155
 156 static bool __is_client_type(int type_flag)
 157 {
 158         if (type_flag & g_client_type) {
 159                 return true;
 160         }
 161
 162         return false;
 163 }
 164
 165 static void __set_language_into_config(tts_config_s* config_info, const char* language)
 166 {
 167         if (NULL == config_info) {
 168                 return;
 169         }
 170
 171         memset(g_language, '\0', sizeof(g_language));
 172         config_info->language = g_language;
 173
 174         if (NULL != language) {
 175                 strncpy(config_info->language, language, sizeof(g_language) - 1);
 176         }
 177 }
 178
 179 int __tts_config_mgr_check_engine_is_valid(const char* engine_id)
 180 {
 181         if (NULL == engine_id) {
 182                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
 183                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 184         }
 185
 186         if (0 >= g_slist_length(g_engine_list)) {
 187                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
 188                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
 189         }
 190
 191         if (NULL != __get_engine_info(engine_id)) {
 192                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is valid : %s", engine_id);
 193                 return TTS_CONFIG_ERROR_NONE;
 194         }
 195
 196         /* Change default engine */
 197         char* default_engine = __get_default_engine_app_id();
 198         tts_engine_info_s *engine_info = __get_engine_info(default_engine);
 199         free(default_engine);
 200
 201         if (NULL == engine_info) {
 202                 GSList* iter = g_slist_nth(g_engine_list, 0);
 203                 if (NULL == iter) {
 204                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine in list");
 205                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 206                 }
 207
 208                 engine_info = iter->data;
 209                 if (NULL == engine_info) {
 210                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Invalid engine info in list");
 211                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 212                 }
 213
 214                 if (NULL != engine_info->uuid) {
 215                         vconf_set_str(TTS_ENGINE_DB_DEFAULT, engine_info->uuid);
 216                 }
 217         }
 218
 219         tts_config_s config_info;
 220         if (0 != tts_parser_get_config_info(&config_info)){
 221                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 222                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 223         }
 224
 225         if (NULL != engine_info->uuid) {
 226                 memset(g_engine_id, '\0', sizeof(g_engine_id));
 227                 config_info.engine_id = g_engine_id;
 228                 strncpy(config_info.engine_id, engine_info->uuid, sizeof(g_engine_id) - 1);
 229         }
 230         if (NULL != engine_info->setting) {
 231                 memset(g_setting, '\0', sizeof(g_setting));
 232                 config_info.setting = g_setting;
 233                 strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
 234         }
 235
 236         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default engine is changed : %s", config_info.engine_id);
 237
 238         /* Change is default voice */
 239         bool is_valid_voice = false;
 240         tts_config_voice_s* voice = __get_voice_info(engine_info, config_info.language, config_info.type);
 241         if (NULL != voice) {
 242                 is_valid_voice = true;
 243
 244                 __set_language_into_config(&config_info, voice->language);
 245                 config_info.type = voice->type;
 246
 247                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
 248         }
 249
 250         if (false == is_valid_voice) {
 251                 GSList *iter_voice = g_slist_nth(engine_info->voices, 0);
 252                 if (NULL == iter_voice) {
 253                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice list");
 254                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 255                 }
 256                 voice = iter_voice->data;
 257
 258                 if (NULL == voice || NULL == voice->language) {
 259                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to get voice info from list");
 260                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 261                 }
 262                 /* Select first voice as default */
 263                 __set_language_into_config(&config_info, voice->language);
 264
 265                 config_info.type = voice->type;
 266                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Default voice is changed : lang(%s) type(%d)", voice->language, voice->type);
 267         }
 268
 269         if (0 != tts_parser_set_config_info(&config_info)){
 270                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
 271                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 272         }
 273
 274         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
 275                 if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting, config_info.language, config_info.type)) {
 276                         SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
 277                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 278                 }
 279         } else {
 280                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
 281         }
 282
 283
 284         return TTS_CONFIG_ERROR_NONE;
 285 }
 286
 287 bool __tts_config_mgr_check_lang_is_valid(const char* engine_id, const char* language, int type)
 288 {
 289         if (NULL == engine_id || NULL == language) {
 290                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
 291                 return false;
 292         }
 293
 294         if (0 >= g_slist_length(g_engine_list)) {
 295                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
 296                 return false;
 297         }
 298
 299         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
 300         if (NULL == engine_info) {
 301                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
 302                 return false;
 303         }
 304
 305         tts_config_voice_s* voice = __get_voice_info(engine_info, language, type);
 306         if (NULL != voice) {
 307                 return true;
 308         }
 309
 310         return false;
 311 }
 312
 313 int __tts_config_mgr_select_lang(const char* engine_id, char** language, int* type)
 314 {
 315         if (NULL == engine_id || NULL == language) {
 316                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
 317                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 318         }
 319
 320         if (0 >= g_slist_length(g_engine_list)) {
 321                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no engine!!");
 322                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
 323         }
 324
 325         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
 326         if (NULL == engine_info) {
 327                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
 328                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
 329         }
 330
 331         if (g_slist_length(engine_info->voices) <= 0) {
 332                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "There is no voice : %s", engine_info->uuid);
 333                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 334         }
 335
 336         tts_config_voice_s* voice = __get_voice_info(engine_info, TTS_BASE_LANGUAGE, TTS_CONFIG_VOICE_TYPE_NONE);
 337         if (NULL == voice) {
 338                 /* Not support base language */
 339                 GSList *iter_voice = g_slist_nth(engine_info->voices, 0);
 340                 if (NULL != iter_voice) {
 341                         voice = iter_voice->data;
 342                 }
 343         }
 344
 345         if (NULL != voice) {
 346                 *language = strdup(voice->language);
 347                 *type = voice->type;
 348
 349                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Selected language(%s) type(%d)", *language, *type);
 350                 return TTS_CONFIG_ERROR_NONE;
 351         }
 352
 353         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 354 }
 355
 356 static void __invoke_engine_changed_cb(gpointer data, gpointer user_data)
 357 {
 358         tts_config_client_s* client = (tts_config_client_s*)data;
 359         engine_changed_cb_parameter_s* params = (engine_changed_cb_parameter_s*)user_data;
 360
 361         if (NULL == client || NULL == params) {
 362                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] parmeter is NULL. client(%p), params(%p)", client, params);
 363                 return;
 364         }
 365
 366         if (NULL != client->engine_cb) {
 367                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine changed callback : uid(%u)", client->uid);
 368                 client->engine_cb(params->engine_id, params->setting, params->language, params->voice_type,
 369                                 params->auto_voice, params->need_credential, client->user_data);
 370         }
 371 }
 372
 373 static void __invoke_voice_changed_cb(gpointer data, gpointer user_data)
 374 {
 375         tts_config_client_s* client = (tts_config_client_s*)data;
 376         voice_changed_cb_parameter_s* params = (voice_changed_cb_parameter_s*)user_data;
 377
 378         if (NULL == client || NULL == params) {
 379                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] parmeter is NULL. client(%p), params(%p)", client, params);
 380                 return;
 381         }
 382
 383         if (NULL != client->voice_cb) {
 384                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice changed callback : uid(%u)", client->uid);
 385                 client->voice_cb(params->before_language, params->before_voice_type, params->current_language,
 386                                 params->current_voice_type, params->auto_voice, client->user_data);
 387         }
 388 }
 389
 390 Eina_Bool tts_config_mgr_inotify_event_cb(void* data, Ecore_Fd_Handler *fd_handler)
 391 {
 392         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Config changed callback event");
 393
 394         int length;
 395         struct inotify_event event;
 396         memset(&event, '\0', sizeof(struct inotify_event));
 397
 398         length = read(g_config_fd_noti, &event, sizeof(struct inotify_event));
 399         if (0 > length) {
 400                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty Inotify event");
 401                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 402                 return ECORE_CALLBACK_DONE;
 403         }
 404
 405         tts_config_s config_info;
 406         if (0 != tts_parser_get_config_info(&config_info)){
 407                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 408                 return ECORE_CALLBACK_PASS_ON;
 409         }
 410
 411         if (IN_CLOSE_WRITE == event.mask) {
 412                 /* check config changed state */
 413                 char* engine = NULL;
 414                 char* setting = NULL;
 415                 char* lang = NULL;
 416                 bool auto_voice = config_info.auto_voice;
 417                 int voice_type = -1;
 418                 int speech_rate = -1;
 419                 int pitch = -1;
 420                 double bg_volume_ratio = -1;
 421
 422                 GSList *iter = NULL;
 423                 tts_config_client_s* temp_client = NULL;
 424
 425                 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch, &bg_volume_ratio))
 426                         return ECORE_CALLBACK_PASS_ON;
 427
 428                 /* engine changed */
 429                 if (NULL != engine || NULL != setting) {
 430                         if (NULL != engine) {
 431                                 memset(g_engine_id, '\0', sizeof(g_engine_id));
 432                                 config_info.engine_id = g_engine_id;
 433                                 strncpy(config_info.engine_id, engine, sizeof(g_engine_id) - 1);
 434                         }
 435                         if (NULL != setting) {
 436                                 memset(g_setting, '\0', sizeof(g_setting));
 437                                 config_info.setting = g_setting;
 438                                 strncpy(config_info.setting, setting, sizeof(g_setting) - 1);
 439                         }
 440
 441                         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Engine change(%s)", config_info.engine_id);
 442
 443                         /* Call all callbacks of client*/
 444                         engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
 445                                         config_info.type, config_info.auto_voice, config_info.credential};
 446                         g_slist_foreach(g_config_client_list, __invoke_engine_changed_cb, &params);
 447                 }
 448
 449                 if (auto_voice != config_info.auto_voice) {
 450                         config_info.auto_voice = auto_voice;
 451                 }
 452
 453                 if (NULL != lang || -1 != voice_type) {
 454                         char* before_lang = NULL;
 455                         int before_type;
 456
 457                         before_lang = strdup(config_info.language);
 458                         before_type = config_info.type;
 459
 460                         if (NULL != lang) {
 461                                 __set_language_into_config(&config_info, lang);
 462                         }
 463                         if (-1 != voice_type) {
 464                                 config_info.type = voice_type;
 465                         }
 466
 467                         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Voice change(%s, %d)", config_info.language, config_info.type);
 468
 469                         /* Call all callbacks of client*/
 470                         voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language,
 471                                         config_info.type, config_info.auto_voice};
 472                         g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 473
 474                         if (NULL != before_lang) {
 475                                 free(before_lang);
 476                                 before_lang = NULL;
 477                         }
 478                 }
 479
 480                 if (-1 != speech_rate) {
 481                         config_info.speech_rate = speech_rate;
 482
 483                         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate change(%d)", config_info.speech_rate);
 484
 485                         /* Call all callbacks of client*/
 486                         iter = g_slist_nth(g_config_client_list, 0);
 487
 488                         while (NULL != iter) {
 489                                 temp_client = iter->data;
 490
 491                                 if (NULL != temp_client) {
 492                                         if (NULL != temp_client->speech_cb) {
 493                                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Speech rate changed callback : uid(%u)", temp_client->uid);
 494                                                 temp_client->speech_cb(config_info.speech_rate, temp_client->user_data);
 495                                         }
 496                                 }
 497
 498                                 iter = g_slist_next(iter);
 499                         }
 500                 }
 501
 502                 if (-1 != pitch) {
 503                         config_info.pitch = pitch;
 504
 505                         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "pitch change(%d)", config_info.pitch);
 506
 507                         /* Call all callbacks of client*/
 508                         iter = g_slist_nth(g_config_client_list, 0);
 509
 510                         while (NULL != iter) {
 511                                 temp_client = iter->data;
 512
 513                                 if (NULL != temp_client) {
 514                                         if (NULL != temp_client->pitch_cb) {
 515                                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Pitch changed callback : uid(%u)", temp_client->uid);
 516                                                 temp_client->pitch_cb(config_info.pitch, temp_client->user_data);
 517                                         }
 518                                 }
 519
 520                                 iter = g_slist_next(iter);
 521                         }
 522                 }
 523
 524                 if (0.0 <= bg_volume_ratio) {
 525                         config_info.bg_volume_ratio = bg_volume_ratio;
 526
 527                         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio change(%lf)", config_info.bg_volume_ratio);
 528
 529                         /* Call all callbacks of client*/
 530                         iter = g_slist_nth(g_config_client_list, 0);
 531
 532                         while (NULL != iter) {
 533                                 temp_client = iter->data;
 534
 535                                 if (NULL != temp_client) {
 536                                         if (NULL != temp_client->bg_volume_ratio_cb) {
 537                                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "background volume ratio changed callback : uid(%u)", temp_client->uid);
 538                                                 temp_client->bg_volume_ratio_cb(config_info.bg_volume_ratio, temp_client->user_data);
 539                                         }
 540                                 }
 541
 542                                 iter = g_slist_next(iter);
 543                         }
 544                 }
 545
 546                 if (NULL != engine) {
 547                         free(engine);
 548                         engine = NULL;
 549                 }
 550                 if (NULL != setting) {
 551                         free(setting);
 552                         setting = NULL;
 553                 }
 554                 if (NULL != lang) {
 555                         free(lang);
 556                         lang = NULL;
 557                 }
 558
 559                 if (0 != tts_parser_set_config_info(&config_info)){
 560                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
 561                         return ECORE_CALLBACK_PASS_ON;
 562                 }
 563         } else if (IN_DELETE_SELF == event.mask) {
 564                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] IN_DELETE_SELF event");
 565
 566                 tts_parser_unload_config();
 567                 tts_parser_reset();
 568                 tts_parser_load_config();
 569         } else {
 570                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event (0x%x)", event.mask);
 571         }
 572
 573         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 574
 575         return ECORE_CALLBACK_PASS_ON;
 576 }
 577
 578 int __tts_config_mgr_register_config_event()
 579 {
 580         /* get file notification handler */
 581         int fd;
 582         int wd;
 583
 584         fd = inotify_init();
 585         if (fd < 0) {
 586                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail get inotify fd");
 587                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 588         }
 589         g_config_fd_noti = fd;
 590
 591         wd = inotify_add_watch(fd, TTS_CONFIG, IN_CLOSE_WRITE|IN_DELETE_SELF);
 592         g_config_wd_noti = wd;
 593
 594         g_config_fd_handler_noti = ecore_main_fd_handler_add(fd, ECORE_FD_READ,
 595                 (Ecore_Fd_Cb)tts_config_mgr_inotify_event_cb, NULL, NULL, NULL);
 596         if (NULL == g_config_fd_handler_noti) {
 597                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get handler_noti");
 598                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 599         }
 600
 601         /* Set non-blocking mode of file */
 602         int value;
 603         value = fcntl(fd, F_GETFL, 0);
 604         value |= O_NONBLOCK;
 605
 606         if (0 > fcntl(fd, F_SETFL, value)) {
 607                 SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
 608         }
 609
 610         return TTS_CONFIG_ERROR_NONE;
 611 }
 612
 613 int __tts_config_mgr_unregister_config_event()
 614 {
 615         /* delete inotify variable */
 616         ecore_main_fd_handler_del(g_config_fd_handler_noti);
 617         inotify_rm_watch(g_config_fd_noti, g_config_wd_noti);
 618         close(g_config_fd_noti);
 619
 620         return TTS_CONFIG_ERROR_NONE;
 621 }
 622
 623 int __tts_config_set_auto_language()
 624 {
 625         char* value = NULL;
 626         value = vconf_get_str(TTS_LANGSET_KEY);
 627         if (NULL == value) {
 628                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get display language");
 629                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 630         }
 631
 632         char temp_lang[6] = {'\0', };
 633         strncpy(temp_lang, value, 5);
 634         free(value);
 635         value = NULL;
 636
 637         tts_config_s config_info;
 638         if (0 != tts_parser_get_config_info(&config_info)){
 639                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 640                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 641         }
 642
 643         if (true == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, temp_lang, config_info.type)) {
 644                 /* tts default voice change */
 645                 if (NULL == config_info.language) {
 646                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Current config language is NULL");
 647                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 648                 }
 649
 650                 char* before_lang = NULL;
 651                 int before_type;
 652
 653                 before_lang = strdup(config_info.language);
 654                 before_type = config_info.type;
 655
 656                 __set_language_into_config(&config_info, temp_lang);
 657
 658                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)",
 659                         config_info.language, config_info.type);
 660
 661                 /* Call all callbacks of client*/
 662                 voice_changed_cb_parameter_s params = {before_lang, before_type, config_info.language,
 663                                 config_info.type, config_info.auto_voice};
 664                 g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 665
 666                 if (NULL != before_lang) {
 667                         free(before_lang);
 668                         before_lang = NULL;
 669                 }
 670         } else {
 671                 /* Display language is not valid */
 672                 char* tmp_language = NULL;
 673                 int tmp_type = -1;
 674                 if (0 != __tts_config_mgr_select_lang(config_info.engine_id, &tmp_language, &tmp_type)) {
 675                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
 676                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 677                 }
 678
 679                 if (NULL == tmp_language) {
 680                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] language is NULL");
 681                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 682                 }
 683
 684                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Default voice : lang(%s) type(%d)", tmp_language, tmp_type);
 685
 686                 /* Call all callbacks of client*/
 687                 voice_changed_cb_parameter_s params = {config_info.language, config_info.type, tmp_language, tmp_type,
 688                                 config_info.auto_voice};
 689                 g_slist_foreach(g_config_client_list, __invoke_voice_changed_cb, &params);
 690
 691                 __set_language_into_config(&config_info, tmp_language);
 692                 config_info.type = tmp_type;
 693
 694                 free(tmp_language);
 695                 tmp_language = NULL;
 696         }
 697
 698         if (0 != tts_parser_set_config_info(&config_info)){
 699                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
 700                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
 701         }
 702
 703         return TTS_CONFIG_ERROR_NONE;
 704 }
 705
 706 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
 707 {
 708         tts_config_s config_info;
 709         if (0 != tts_parser_get_config_info(&config_info)){
 710                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 711                 return;
 712         }
 713         if (true == config_info.auto_voice) {
 714                 __tts_config_set_auto_language();
 715
 716                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SERVER)) {
 717                         if (0 != tts_parser_get_config_info(&config_info)){
 718                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 719                                 return;
 720                         }
 721
 722                         if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
 723                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
 724                                 return;
 725                         }
 726                 }
 727         }
 728
 729         return;
 730 }
 731
 732 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
 733 {
 734         int ret;
 735         int screen_reader;
 736         ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 737         if (0 != ret) {
 738                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Fail to get screen reader");
 739                 return;
 740         }
 741
 742         GSList *iter = NULL;
 743         tts_config_client_s* temp_client = NULL;
 744
 745         /* Call all callbacks of client*/
 746         iter = g_slist_nth(g_config_client_list, 0);
 747
 748         while (NULL != iter) {
 749                 temp_client = iter->data;
 750
 751                 if (NULL != temp_client) {
 752                         if (NULL != temp_client->screen_cb) {
 753                                 temp_client->screen_cb((bool)screen_reader, temp_client->screen_user_data);
 754                         }
 755                 }
 756
 757                 iter = g_slist_next(iter);
 758         }
 759 }
 760
 761 static inline void free_config_client(tts_config_client_s* client)
 762 {
 763         if (NULL != client) {
 764                 client->uid = TTS_INVALID_UID;
 765                 client->engine_cb = NULL;
 766                 client->voice_cb = NULL;
 767                 client->speech_cb = NULL;
 768                 client->screen_cb = NULL;
 769                 client->pitch_cb = NULL;
 770                 client->bg_volume_ratio_cb = NULL;
 771                 client->user_data = NULL;
 772                 client->screen_user_data = NULL;
 773
 774                 free(client);
 775         }
 776 }
 777
 778 static gint compare_config_client_and_uid(gconstpointer a, gconstpointer b)
 779 {
 780         const tts_config_client_s *client = (const tts_config_client_s *)a;
 781         const unsigned int *uid = (const unsigned int *)b;
 782
 783         if (NULL != client && NULL != uid && client->uid == *uid) {
 784                 return 0;
 785         }
 786
 787         return -1;
 788 }
 789
 790 static int release_config_client(unsigned int uid)
 791 {
 792         GSList *iter = g_slist_find_custom(g_config_client_list, &uid, compare_config_client_and_uid);
 793         if (NULL != iter) {
 794                 tts_config_client_s *client = (tts_config_client_s *)iter->data;
 795                 g_config_client_list = g_slist_delete_link(g_config_client_list, iter);
 796
 797                 free_config_client(client);
 798         }
 799
 800         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Client count (%d)", g_slist_length(g_config_client_list));
 801         return g_slist_length(g_config_client_list);
 802 }
 803
 804 void __tts_config_release_engine()
 805 {
 806         GSList *iter = NULL;
 807         tts_engine_info_s *engine_info = NULL;
 808
 809         if (0 < g_slist_length(g_engine_list)) {
 810
 811                 /* Get a first item */
 812                 iter = g_slist_nth(g_engine_list, 0);
 813
 814                 while (NULL != iter) {
 815                         engine_info = iter->data;
 816
 817                         if (NULL != engine_info) {
 818                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 819
 820                                 tts_parser_free_engine_info(engine_info);
 821                         }
 822
 823                         iter = g_slist_nth(g_engine_list, 0);
 824                 }
 825         }
 826
 827         return;
 828 }
 829
 830 int __tts_config_mgr_get_engine_info()
 831 {
 832         DIR *dp = NULL;
 833         struct dirent *dirp = NULL;
 834
 835         char filepath[512] = {'\0',};
 836         int filesize;
 837         tts_engine_info_s* info = NULL;
 838
 839         __tts_config_release_engine();
 840         g_engine_list = NULL;
 841         __tts_config_mgr_unregister_engine_config_updated_event();
 842
 843         /* Copy default info directory to download directory */
 844         dp  = opendir(TTS_DEFAULT_ENGINE_INFO);
 845         if (NULL == dp) {
 846                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
 847         } else {
 848                 do {
 849                         dirp = readdir(dp);
 850
 851                         if (NULL != dirp) {
 852                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 853                                         continue;
 854
 855                                 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 856                                 if (filesize >= 512) {
 857                                         SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 858                                         closedir(dp);
 859                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 860                                 }
 861
 862                                 memset(filepath, '\0', 512);
 863                                 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
 864
 865                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
 866
 867                                 char dest[512] = {'\0',};
 868                                 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
 869
 870                                 if (0 != access(dest, F_OK)) {
 871                                         if (0 != tts_parser_copy_xml(filepath, dest)) {
 872                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] Fail to copy engine info");
 873                                         }
 874                                 }
 875                         }
 876                 } while (NULL != dirp);
 877
 878                 closedir(dp);
 879         }
 880
 881         /* Get engine info from default engine directory */
 882         dp  = opendir(TTS_DOWNLOAD_ENGINE_INFO);
 883         if (NULL == dp) {
 884                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
 885         } else {
 886                 do {
 887                         dirp = readdir(dp);
 888
 889                         if (NULL != dirp) {
 890                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 891                                         continue;
 892
 893                                 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 894                                 if (filesize >= 512) {
 895                                         SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 896                                         closedir(dp);
 897                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 898                                 }
 899
 900                                 memset(filepath, '\0', 512);
 901                                 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
 902
 903                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
 904
 905                                 if (0 == tts_parser_get_engine_info(filepath, &info)) {
 906                                         g_engine_list = g_slist_append(g_engine_list, info);
 907                                         if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
 908                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
 909                                         }
 910                                 }
 911                         }
 912                 } while (NULL != dirp);
 913
 914                 closedir(dp);
 915         }
 916
 917         if (0 >= g_slist_length(g_engine_list)) {
 918                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine");
 919                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
 920         }
 921
 922         return TTS_CONFIG_ERROR_NONE;
 923 }
 924
 925 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 926 {
 927         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Engine config updated callback event");
 928
 929         tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
 930         int dir_fd = ino->dir_fd;
 931
 932         int length;
 933         struct inotify_event event;
 934         memset(&event, '\0', sizeof(struct inotify_event));
 935
 936         length = read(dir_fd, &event, sizeof(struct inotify_event));
 937         if (0 > length) {
 938                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty Inotify event");
 939                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 940                 return ECORE_CALLBACK_DONE;
 941         }
 942
 943         if (IN_CLOSE_WRITE == event.mask) {
 944                 int ret = __tts_config_mgr_get_engine_info();
 945                 if (0 != ret) {
 946                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info when config updated");
 947                 }
 948                 __tts_config_mgr_print_engine_info();
 949                 tts_config_s config_info;
 950                 if (0 != tts_parser_get_config_info(&config_info)){
 951                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 952                         return ECORE_CALLBACK_PASS_ON;
 953                 }
 954                 bool support = tts_config_check_default_voice_is_valid(config_info.language, config_info.type);
 955                 if (false == support) {
 956                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[ERROR] Default voice is valid");
 957                         char* temp_lang = NULL;
 958                         int temp_type;
 959                         ret = __tts_config_mgr_select_lang(config_info.engine_id, &temp_lang, &temp_type);
 960                         if (0 != ret) {
 961                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get voice");
 962                         }
 963
 964                         ret = tts_config_mgr_set_voice(temp_lang, temp_type);
 965                         if (0 != ret) {
 966                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set voice");
 967                         } else {
 968                                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", temp_lang, temp_type);
 969                         }
 970                         if (NULL != temp_lang) {
 971                                 free(temp_lang);
 972                                 temp_lang = NULL;
 973                         }
 974                 }
 975
 976                 if (0 != tts_parser_get_config_info(&config_info)){
 977                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 978                         return ECORE_CALLBACK_PASS_ON;
 979                 }
 980
 981                 /* Call all callbacks of client*/
 982                 engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
 983                                 config_info.type, config_info.auto_voice, config_info.credential};
 984                 g_slist_foreach(g_config_client_list, __invoke_engine_changed_cb, &params);
 985         } else {
 986                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event");
 987         }
 988
 989         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 990
 991         return ECORE_CALLBACK_PASS_ON;
 992 }
 993
 994 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
 995 {
 996         if (NULL == path) {
 997                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Path is NULL");
 998                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 999         }
1000
1001         /* For engine directory monitoring */
1002         tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
1003         if (NULL == ino) {
1004                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
1005                 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1006         }
1007
1008         ino->dir_fd = inotify_init();
1009         if (ino->dir_fd < 0) {
1010                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to init inotify");
1011                 free(ino);
1012                 ino = NULL;
1013
1014                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1015         }
1016
1017         ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
1018         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Add inotify watch(%s)", path);
1019         if (ino->dir_wd < 0) {
1020                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add watch");
1021                 free(ino);
1022                 ino = NULL;
1023                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1024         }
1025
1026         ino->dir_fd_handler = ecore_main_fd_handler_add(ino->dir_fd, ECORE_FD_READ, (Ecore_Fd_Cb)__tts_config_mgr_engine_config_inotify_event_callback, (void *)ino, NULL, NULL);
1027         if (NULL == ino->dir_fd_handler) {
1028                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add fd handler");
1029                 free(ino);
1030                 ino = NULL;
1031                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1032         }
1033
1034         /* Set non-blocking mode of file */
1035         int value;
1036         value = fcntl(ino->dir_fd, F_GETFL, 0);
1037         value |= O_NONBLOCK;
1038
1039         if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
1040                 SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
1041         }
1042
1043         g_ino_list = g_list_append(g_ino_list, ino);
1044
1045         return TTS_CONFIG_ERROR_NONE;
1046 }
1047
1048 static int __tts_config_mgr_unregister_engine_config_updated_event()
1049 {
1050         /* delete all inotify variable */
1051         if (0 < g_list_length(g_ino_list)) {
1052                 GList *iter = NULL;
1053                 iter = g_list_first(g_ino_list);
1054
1055                 while (NULL != iter) {
1056                         tts_engine_inotify_s *tmp = iter->data;
1057
1058                         if (NULL != tmp) {
1059                                 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1060                                 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1061                                 close(tmp->dir_fd);
1062
1063                                 free(tmp);
1064                                 tmp = NULL;
1065                         }
1066
1067                         g_ino_list = g_list_delete_link(g_ino_list, iter);
1068                         iter = g_list_first(g_ino_list);
1069                 }
1070         }
1071
1072         return TTS_CONFIG_ERROR_NONE;
1073 }
1074
1075 static int __add_new_config_client(unsigned int uid)
1076 {
1077         tts_config_client_s* new_client = NULL;
1078         new_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1079         if (NULL == new_client) {
1080                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
1081                 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1082         }
1083         new_client->uid = uid;
1084
1085         g_config_client_list = g_slist_append(g_config_client_list, new_client);
1086         return TTS_CONFIG_ERROR_NONE;
1087 }
1088
1089 int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
1090 {
1091         /* Register uid */
1092         if (0 < g_slist_length(g_config_client_list)) {
1093                 /* Check uid */
1094                 GSList *iter = g_slist_nth(g_config_client_list, 0);
1095
1096                 while (NULL != iter) {
1097                         tts_config_client_s* client = (tts_config_client_s*)iter->data;
1098
1099                         if (NULL != client && uid == client->uid) {
1100                                 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] uid(%u) has already registered", uid);
1101                                 return TTS_CONFIG_ERROR_NONE;
1102                         }
1103
1104                         iter = g_slist_next(iter);
1105                 }
1106
1107                 int ret = __add_new_config_client(uid);
1108                 if (TTS_CONFIG_ERROR_NONE != ret) {
1109                         return ret;
1110                 }
1111
1112                 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
1113                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1114                 g_client_type |= client_type;
1115
1116                 return TTS_CONFIG_ERROR_NONE;
1117         } else {
1118                 int ret = __add_new_config_client(uid);
1119                 if (TTS_CONFIG_ERROR_NONE != ret) {
1120                         return ret;
1121                 }
1122         }
1123
1124         if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1125                 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1126                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1127                         release_config_client(uid);
1128                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1129                 } else {
1130                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_CONFIG_BASE);
1131                 }
1132         }
1133
1134         if (0 != access(TTS_HOME, F_OK)) {
1135                 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1136                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_HOME);
1137                         release_config_client(uid);
1138                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1139                 } else {
1140                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_HOME);
1141                 }
1142         }
1143
1144         if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1145                 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1146                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1147                         release_config_client(uid);
1148                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1149                 } else {
1150                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1151                 }
1152         }
1153
1154         if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1155                 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1156                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1157                         release_config_client(uid);
1158                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1159                 } else {
1160                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1161                 }
1162         }
1163
1164         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1165         g_client_type |= client_type;
1166
1167         if (0 != __tts_config_mgr_get_engine_info()) {
1168                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info");
1169                 release_config_client(uid);
1170                 __tts_config_release_engine();
1171                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1172         }
1173
1174         __tts_config_mgr_print_engine_info();
1175
1176         if (0 != tts_parser_load_config()) {
1177                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to parse configure information");
1178                 release_config_client(uid);
1179                 __tts_config_release_engine();
1180                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1181         }
1182         tts_config_s config_info;
1183         if (0 != tts_parser_get_config_info(&config_info)) {
1184                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1185                 release_config_client(uid);
1186                 __tts_config_release_engine();
1187                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1188         }
1189
1190         /* Check whether engine id is valid */
1191         if (0 != __tts_config_mgr_check_engine_is_valid(config_info.engine_id)) {
1192                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get default engine");
1193                 release_config_client(uid);
1194                 __tts_config_release_engine();
1195                 tts_parser_unload_config();
1196                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1197         }
1198
1199         if (true == config_info.auto_voice) {
1200                 /* Check language with display language */
1201                 __tts_config_set_auto_language();
1202
1203                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1204                         if (0 != tts_parser_get_config_info(&config_info)){
1205                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1206                         }
1207
1208                         if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1209                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1210                         }
1211                 }
1212         } else {
1213                 if (false == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, config_info.language, config_info.type)) {
1214                         /* Default language is not valid */
1215                         char* tmp_language = NULL;
1216                         int tmp_type = -1;
1217                         if (0 != __tts_config_mgr_select_lang(config_info.engine_id, &tmp_language, &tmp_type)) {
1218                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
1219                                 release_config_client(uid);
1220                                 __tts_config_release_engine();
1221                                 tts_parser_unload_config();
1222                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1223                         }
1224
1225                         if (NULL != tmp_language) {
1226                                 __set_language_into_config(&config_info, tmp_language);
1227                                 config_info.type = tmp_type;
1228
1229                                 free(tmp_language);
1230                                 tmp_language = NULL;
1231
1232                                 if (0 != tts_parser_set_config_info(&config_info)) {
1233                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1234                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1235                                 }
1236
1237                                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1238                                         if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1239                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1240                                                 release_config_client(uid);
1241                                                 __tts_config_release_engine();
1242                                                 tts_parser_unload_config();
1243                                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1244                                         }
1245                                 } else {
1246                                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1247                                 }
1248                         }
1249                 }
1250         }
1251
1252         /* print daemon config */
1253         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ TTS config @@@");
1254         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " engine : %s", config_info.engine_id);
1255         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", config_info.setting);
1256         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " auto voice : %s", config_info.auto_voice ? "on" : "off");
1257         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " language : %s", config_info.language);
1258         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " voice type : %d", config_info.type);
1259         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " speech rate : %d", config_info.speech_rate);
1260         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " pitch : %d", config_info.pitch);
1261         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " bg volume ratio : %lf", config_info.bg_volume_ratio);
1262         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@@@");
1263
1264         if (0 != __tts_config_mgr_register_config_event()) {
1265                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register config event");
1266                 release_config_client(uid);
1267                 __tts_config_release_engine();
1268                 tts_parser_unload_config();
1269                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1270         }
1271
1272         /* Register to detect display language change */
1273         vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1274         vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1275
1276         /* For engine directory monitoring */
1277         //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1278         //      SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
1279         //      release_config_client(uid);
1280         //      __tts_config_release_engine();
1281         //      tts_parser_unload_config();
1282         //      __tts_config_mgr_unregister_config_event();
1283         //      return TTS_CONFIG_ERROR_OPERATION_FAILED;
1284         //}
1285
1286         return TTS_CONFIG_ERROR_NONE;
1287 }
1288
1289 int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_type)
1290 {
1291         if (0 < release_config_client(uid)) {
1292                 g_client_type &= ~client_type;
1293                 return TTS_CONFIG_ERROR_NONE;
1294         }
1295
1296         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1297         g_client_type &= ~client_type;
1298
1299         __tts_config_release_engine();
1300
1301         tts_parser_unload_config();
1302
1303         __tts_config_mgr_unregister_engine_config_updated_event();
1304
1305         __tts_config_mgr_unregister_config_event();
1306
1307         vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1308         vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1309
1310         return TTS_CONFIG_ERROR_NONE;
1311 }
1312
1313 int tts_config_mgr_set_callback(unsigned int uid,
1314                                 tts_config_engine_changed_cb engine_cb,
1315                                 tts_config_voice_changed_cb voice_cb,
1316                                 tts_config_speech_rate_changed_cb speech_cb,
1317                                 tts_config_pitch_changed_cb pitch_cb,
1318                                 tts_config_bg_volume_ratio_changed_cb bg_volume_ratio_cb,
1319                                 void* user_data)
1320 {
1321         GSList *iter = NULL;
1322         tts_config_client_s* temp_client = NULL;
1323
1324         /* Call all callbacks of client*/
1325         iter = g_slist_nth(g_config_client_list, 0);
1326
1327         while (NULL != iter) {
1328                 temp_client = iter->data;
1329
1330                 if (NULL != temp_client) {
1331                         if (uid == temp_client->uid) {
1332                                 temp_client->engine_cb = engine_cb;
1333                                 temp_client->voice_cb = voice_cb;
1334                                 temp_client->speech_cb = speech_cb;
1335                                 temp_client->pitch_cb = pitch_cb;
1336                                 temp_client->bg_volume_ratio_cb = bg_volume_ratio_cb;
1337                                 temp_client->user_data = user_data;
1338                         }
1339                 }
1340
1341                 iter = g_slist_next(iter);
1342         }
1343         return TTS_CONFIG_ERROR_NONE;
1344 }
1345
1346 int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_screen_reader_changed_cb callback, void* user_data)
1347 {
1348         if (NULL == callback) {
1349                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
1350                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1351         }
1352
1353         GSList *iter = NULL;
1354         tts_config_client_s* temp_client = NULL;
1355
1356         /* Call all callbacks of client*/
1357         iter = g_slist_nth(g_config_client_list, 0);
1358
1359         while (NULL != iter) {
1360                 temp_client = iter->data;
1361
1362                 if (NULL != temp_client) {
1363                         if (uid == temp_client->uid) {
1364                                 temp_client->screen_cb = callback;
1365                                 temp_client->screen_user_data = user_data;
1366                         }
1367                 }
1368
1369                 iter = g_slist_next(iter);
1370         }
1371         return TTS_CONFIG_ERROR_NONE;
1372 }
1373
1374 int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
1375 {
1376         GSList *iter = NULL;
1377         tts_config_client_s* temp_client = NULL;
1378
1379         /* Call all callbacks of client*/
1380         iter = g_slist_nth(g_config_client_list, 0);
1381
1382         while (NULL != iter) {
1383                 temp_client = iter->data;
1384
1385                 if (NULL != temp_client) {
1386                         if (uid == temp_client->uid) {
1387                                 temp_client->screen_cb = NULL;
1388                                 temp_client->screen_user_data = NULL;
1389                         }
1390                 }
1391
1392                 iter = g_slist_next(iter);
1393         }
1394         return TTS_CONFIG_ERROR_NONE;
1395 }
1396
1397 static int __check_precondition()
1398 {
1399         if (0 >= g_slist_length(g_config_client_list)) {
1400                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Not initialized");
1401                 return TTS_CONFIG_ERROR_INVALID_STATE;
1402         }
1403
1404         if (0 >= g_slist_length(g_engine_list)) {
1405                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1406                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1407         }
1408
1409         return TTS_CONFIG_ERROR_NONE;
1410 }
1411
1412
1413 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1414 {
1415         int ret = __check_precondition();
1416         if (TTS_CONFIG_ERROR_NONE != ret) {
1417                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1418                 return ret;
1419         }
1420
1421         GSList *iter = NULL;
1422         tts_engine_info_s *engine_info = NULL;
1423
1424         /* Get a first item */
1425         iter = g_slist_nth(g_engine_list, 0);
1426
1427         while (NULL != iter) {
1428                 engine_info = iter->data;
1429
1430                 if (NULL != engine_info) {
1431                         if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1432                                 break;
1433                         }
1434                 }
1435
1436                 iter = g_slist_next(iter);
1437         }
1438
1439         return TTS_CONFIG_ERROR_NONE;
1440 }
1441
1442 int tts_config_mgr_get_engine(char** engine)
1443 {
1444         int ret = __check_precondition();
1445         if (TTS_CONFIG_ERROR_NONE != ret) {
1446                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1447                 return ret;
1448         }
1449
1450         if (NULL == engine) {
1451                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1452                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1453         }
1454
1455         tts_config_s config_info;
1456         if (0 != tts_parser_get_config_info(&config_info)){
1457                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1458                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1459         }
1460
1461         tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
1462         if (NULL == engine_info) {
1463                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] engine info is NULL");
1464                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1465         }
1466
1467         *engine = strdup(config_info.engine_id);
1468         return TTS_CONFIG_ERROR_NONE;
1469 }
1470
1471 int __tts_set_buxtonkey(const char* engine)
1472 {
1473         /* Set vconfkey */
1474         struct buxton_client * bux_cli;
1475         struct buxton_layer * bux_layer;
1476         struct buxton_value * bux_val;
1477
1478         int ret = buxton_open(&bux_cli, NULL, NULL);
1479         if (0 != ret) {
1480                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1481                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1482         }
1483         bux_layer = buxton_create_layer("system");
1484         if (NULL == bux_layer) {
1485                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_create_layer FAIL");
1486                 buxton_close(bux_cli);
1487                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1488         }
1489         bux_val = buxton_value_create_string(engine);
1490         if (NULL == bux_val) {
1491                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1492                 buxton_free_layer(bux_layer);
1493                 buxton_close(bux_cli);
1494                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1495         } else {
1496                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1497         }
1498
1499         ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1500         if (0 != ret) {
1501                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1502                 buxton_value_free(bux_val);
1503                 buxton_free_layer(bux_layer);
1504                 buxton_close(bux_cli);
1505
1506                 bux_cli = NULL;
1507                 bux_layer = NULL;
1508                 bux_val = NULL;
1509
1510                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1511         } else {
1512                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1513         }
1514
1515         buxton_value_free(bux_val);
1516         buxton_free_layer(bux_layer);
1517         buxton_close(bux_cli);
1518
1519         bux_cli = NULL;
1520         bux_layer = NULL;
1521         bux_val = NULL;
1522
1523         return TTS_CONFIG_ERROR_NONE;
1524 }
1525
1526 int tts_config_mgr_set_engine(const char* engine)
1527 {
1528         int ret = __check_precondition();
1529         if (TTS_CONFIG_ERROR_NONE != ret) {
1530                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1531                 return ret;
1532         }
1533
1534         if (NULL == engine)
1535                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1536
1537         tts_config_s config_info;
1538         if (0 != tts_parser_get_config_info(&config_info)){
1539                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1540                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1541         }
1542
1543         /* Check current engine id with new engine id */
1544         if (0 == strcmp(config_info.engine_id, engine))
1545                 return TTS_CONFIG_ERROR_NONE;
1546
1547         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "New engine id : %s", engine);
1548
1549         ret = __tts_set_buxtonkey(engine);
1550         if (0 != ret) {
1551                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] set_buxtonkey Fail!!");
1552                 return ret;
1553         }
1554
1555         bool is_valid_engine = false;
1556         tts_engine_info_s *engine_info = __get_engine_info(engine);
1557         if (NULL != engine_info) {
1558                 memset(g_engine_id, '\0', sizeof(g_engine_id));
1559                 config_info.engine_id = g_engine_id;
1560                 strncpy(config_info.engine_id, engine, sizeof(g_engine_id) - 1);
1561
1562                 if (NULL != engine_info->setting) {
1563                         memset(g_setting, '\0', sizeof(g_setting));
1564                         config_info.setting = g_setting;
1565                         strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
1566                 }
1567
1568                 /* Engine is valid*/
1569                 bool is_valid_voice = false;
1570                 tts_config_voice_s* voice = __get_voice_info(engine_info, config_info.language, config_info.type);
1571                 if (NULL != voice) {
1572                         /* language is valid */
1573                         is_valid_voice = true;
1574                         config_info.type = voice->type;
1575                 }
1576
1577                 if (false == is_valid_voice) {
1578                         __set_language_into_config(&config_info, NULL);
1579
1580                         GSList *iter_voice = g_slist_nth(engine_info->voices, 0);
1581                         if (NULL != iter_voice) {
1582                                 voice = iter_voice->data;
1583                                 if (NULL != voice) {
1584                                         if (NULL != voice->language)
1585                                                 strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
1586
1587                                         config_info.type = voice->type;
1588                                 }
1589                         }
1590                 }
1591
1592                 is_valid_engine = true;
1593         }
1594
1595         if (0 != tts_parser_set_config_info(&config_info)) {
1596                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1597                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1598         }
1599
1600         if (true == is_valid_engine) {
1601                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Engine changed");
1602                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Engine : %s", config_info.engine_id);
1603                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Setting : %s", config_info.setting);
1604                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Language : %s", config_info.language);
1605                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Type : %d", config_info.type);
1606
1607                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1608                         if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting,
1609                                 config_info.language, config_info.type)) {
1610                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
1611                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1612                         }
1613                 } else {
1614                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1615                 }
1616         } else {
1617                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine id is not valid");
1618                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1619         }
1620
1621         return TTS_CONFIG_ERROR_NONE;
1622 }
1623
1624 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1625 {
1626         int ret = __check_precondition();
1627         if (TTS_CONFIG_ERROR_NONE != ret) {
1628                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1629                 return ret;
1630         }
1631
1632         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
1633         if (NULL == engine_info) {
1634                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] engine info is NULL");
1635                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1636         }
1637
1638         GSList *iter_voice = NULL;
1639         tts_config_voice_s* voice = NULL;
1640
1641         /* Get a first item */
1642         iter_voice = g_slist_nth(engine_info->voices, 0);
1643
1644         while (NULL != iter_voice) {
1645                 /*Get handle data from list*/
1646                 voice = iter_voice->data;
1647
1648                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " lang(%s) type(%d)", voice->language, voice->type);
1649                 if (NULL != voice->language) {
1650                         if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1651                                 break;
1652                 }
1653
1654                 /*Get next item*/
1655                 iter_voice = g_slist_next(iter_voice);
1656         }
1657
1658         return TTS_CONFIG_ERROR_NONE;
1659 }
1660
1661 int tts_config_mgr_get_voice(char** language, int* type)
1662 {
1663         int ret = __check_precondition();
1664         if (TTS_CONFIG_ERROR_NONE != ret) {
1665                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1666                 return ret;
1667         }
1668
1669         if (NULL == language || NULL == type)
1670                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1671
1672         tts_config_s config_info;
1673         if (0 != tts_parser_get_config_info(&config_info)){
1674                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1675                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1676         }
1677
1678         if (0 != strlen(config_info.language)) {
1679                 *language = strdup(config_info.language);
1680                 *type = config_info.type;
1681         } else {
1682                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "language is NULL");
1683                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1684         }
1685
1686         return TTS_CONFIG_ERROR_NONE;
1687 }
1688
1689 int tts_config_mgr_set_voice(const char* language, int type)
1690 {
1691         int ret = __check_precondition();
1692         if (TTS_CONFIG_ERROR_NONE != ret) {
1693                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1694                 return ret;
1695         }
1696
1697         if (NULL == language) {
1698                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1699                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1700         }
1701
1702         tts_config_s config_info;
1703         if (0 != tts_parser_get_config_info(&config_info)){
1704                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1705                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1706         }
1707
1708         /* Check language is valid */
1709         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1710                 if (0 != tts_parser_set_voice(language, type)) {
1711                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
1712                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1713                 }
1714         } else {
1715                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1716         }
1717
1718         __set_language_into_config(&config_info, language);
1719         config_info.type = type;
1720
1721         if (0 != tts_parser_set_config_info(&config_info)){
1722                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1723                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1724         }
1725
1726         return TTS_CONFIG_ERROR_NONE;
1727 }
1728
1729 int tts_config_mgr_get_auto_voice(bool* value)
1730 {
1731         if (0 >= g_slist_length(g_config_client_list)) {
1732                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1733                 return TTS_CONFIG_ERROR_INVALID_STATE;
1734         }
1735
1736         if (NULL == value)
1737                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1738
1739         tts_config_s config_info;
1740         if (0 != tts_parser_get_config_info(&config_info)){
1741                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1742                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1743         }
1744
1745         *value = config_info.auto_voice;
1746
1747         return TTS_CONFIG_ERROR_NONE;
1748 }
1749
1750 int tts_config_mgr_set_auto_voice(bool value)
1751 {
1752         if (0 >= g_slist_length(g_config_client_list)) {
1753                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1754                 return TTS_CONFIG_ERROR_INVALID_STATE;
1755         }
1756
1757         tts_config_s config_info;
1758         if (0 != tts_parser_get_config_info(&config_info)){
1759                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1760                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1761         }
1762
1763         if (config_info.auto_voice != value) {
1764                 /* Check language is valid */
1765                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1766                         if (0 != tts_parser_set_auto_voice(value)) {
1767                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save auto voice option");
1768                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1769                         }
1770                 } else {
1771                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1772                 }
1773
1774                 config_info.auto_voice = value;
1775                 if (0 != tts_parser_set_config_info(&config_info)) {
1776                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1777                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1778                 }
1779
1780                 if (true == config_info.auto_voice) {
1781                         __tts_config_set_auto_language();
1782
1783                         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1784                                 if (0 != tts_parser_get_config_info(&config_info)){
1785                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1786                                 }
1787
1788                                 if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1789                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1790                                 }
1791                         }
1792                 }
1793         }
1794
1795         return TTS_CONFIG_ERROR_NONE;
1796 }
1797
1798 int tts_config_mgr_get_speech_rate(int* value)
1799 {
1800         if (0 >= g_slist_length(g_config_client_list)) {
1801                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1802                 return TTS_CONFIG_ERROR_INVALID_STATE;
1803         }
1804
1805         if (NULL == value) {
1806                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1807         }
1808
1809         tts_config_s config_info;
1810         if (0 != tts_parser_get_config_info(&config_info)){
1811                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1812                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1813         }
1814
1815         *value = config_info.speech_rate;
1816
1817         return TTS_CONFIG_ERROR_NONE;
1818 }
1819
1820 int tts_config_mgr_set_speech_rate(int value)
1821 {
1822         if (0 >= g_slist_length(g_config_client_list)) {
1823                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1824                 return TTS_CONFIG_ERROR_INVALID_STATE;
1825         }
1826
1827         if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1828                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set speech rate : %d", value);
1829                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1830                         if (0 != tts_parser_set_speech_rate(value)) {
1831                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1832                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1833                         }
1834                 } else {
1835                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1836                 }
1837
1838                 tts_config_s config_info;
1839                 if (0 != tts_parser_get_config_info(&config_info)){
1840                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1841                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1842                 }
1843                 config_info.speech_rate = value;
1844                 if (0 != tts_parser_set_config_info(&config_info)){
1845                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1846                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1847                 }
1848         } else {
1849                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Speech rate is invalid : %d", value);
1850         }
1851
1852         return TTS_CONFIG_ERROR_NONE;
1853 }
1854
1855 static int __check_engine_support_pitch(const char* engine_id)
1856 {
1857         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
1858         if (NULL == engine_info) {
1859                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
1860                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1861         }
1862
1863         if (false == engine_info->pitch_support) {
1864                 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1865         }
1866
1867         return TTS_CONFIG_ERROR_NONE;
1868 }
1869
1870 int tts_config_mgr_get_pitch(int* value)
1871 {
1872         int ret = __check_precondition();
1873         if (TTS_CONFIG_ERROR_NONE != ret) {
1874                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1875                 return ret;
1876         }
1877
1878         if (NULL == value) {
1879                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1880         }
1881
1882         tts_config_s config_info;
1883         if (0 != tts_parser_get_config_info(&config_info)){
1884                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1885                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1886         }
1887
1888         ret = __check_engine_support_pitch(config_info.engine_id);
1889         if (TTS_CONFIG_ERROR_NONE != ret) {
1890                 return ret;
1891         }
1892
1893         *value = config_info.pitch;
1894
1895         return TTS_CONFIG_ERROR_NONE;
1896 }
1897
1898 int tts_config_mgr_set_pitch(int value)
1899 {
1900         int ret = __check_precondition();
1901         if (TTS_CONFIG_ERROR_NONE != ret) {
1902                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1903                 return ret;
1904         }
1905
1906         tts_config_s config_info;
1907         if (0 != tts_parser_get_config_info(&config_info)){
1908                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1909                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1910         }
1911
1912         ret = __check_engine_support_pitch(config_info.engine_id);
1913         if (TTS_CONFIG_ERROR_NONE != ret) {
1914                 return ret;
1915         }
1916
1917         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1918                 if (0 != tts_parser_set_pitch(value)) {
1919                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1920                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1921                 }
1922         } else {
1923                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1924         }
1925
1926         config_info.pitch = value;
1927
1928         if (0 != tts_parser_set_config_info(&config_info)){
1929                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1930                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1931         }
1932         return TTS_CONFIG_ERROR_NONE;
1933 }
1934
1935 int tts_config_mgr_get_bg_volume_ratio(double *value)
1936 {
1937         if (0 >= g_slist_length(g_config_client_list)) {
1938                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1939                 return TTS_CONFIG_ERROR_INVALID_STATE;
1940         }
1941
1942         if (NULL == value)
1943                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1944
1945         tts_config_s config_info;
1946         if (0 != tts_parser_get_config_info(&config_info)){
1947                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1948                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1949         }
1950
1951         *value = config_info.bg_volume_ratio;
1952
1953         return TTS_CONFIG_ERROR_NONE;
1954 }
1955
1956 int tts_config_mgr_set_bg_volume_ratio(double value)
1957 {
1958         if (0 >= g_slist_length(g_config_client_list)) {
1959                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1960                 return TTS_CONFIG_ERROR_INVALID_STATE;
1961         }
1962
1963         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set bg volume ratio : %lf", value);
1964         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1965                 if (0 != tts_parser_set_bg_volume_ratio(value)) {
1966                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save bg volume ratio");
1967                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1968                 }
1969         } else {
1970                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1971         }
1972
1973         tts_config_s config_info;
1974         if (0 != tts_parser_get_config_info(&config_info)){
1975                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1976                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1977         }
1978
1979         config_info.bg_volume_ratio = value;
1980
1981         if (0 != tts_parser_set_config_info(&config_info)){
1982                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1983                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1984         }
1985
1986         return TTS_CONFIG_ERROR_NONE;
1987 }
1988
1989 bool tts_config_check_default_engine_is_valid(const char* engine)
1990 {
1991         int ret = __check_precondition();
1992         if (TTS_CONFIG_ERROR_NONE != ret) {
1993                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1994                 return false;
1995         }
1996
1997         if (NULL == engine)
1998                 return false;
1999
2000         tts_engine_info_s *engine_info = __get_engine_info(engine);
2001         if (NULL == engine_info) {
2002                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2003                 return false;
2004         }
2005
2006         return true;
2007 }
2008
2009 bool tts_config_check_default_voice_is_valid(const char* language, int type)
2010 {
2011         if (0 >= g_slist_length(g_config_client_list)) {
2012                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
2013                 return false;
2014         }
2015
2016         tts_config_s config_info;
2017         if (0 != tts_parser_get_config_info(&config_info)){
2018                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
2019                 return false;
2020         }
2021
2022         if (0 == strlen(config_info.engine_id)) {
2023                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Default engine id is NULL");
2024                 return false;
2025         }
2026
2027         return __tts_config_mgr_check_lang_is_valid(config_info.engine_id, language, type);
2028 }
2029
2030
2031 int __tts_config_mgr_print_engine_info()
2032 {
2033         GSList *iter = NULL;
2034         tts_engine_info_s *engine_info = NULL;
2035
2036         if (0 >= g_slist_length(g_engine_list)) {
2037                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "-------------- engine list -----------------");
2038                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  No Engine in engine directory");
2039                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2040                 return TTS_CONFIG_ERROR_NONE;
2041         }
2042
2043         /* Get a first item */
2044         iter = g_slist_nth(g_engine_list, 0);
2045
2046         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------- engine list -----------------");
2047
2048         int i = 1;
2049         while (NULL != iter) {
2050                 engine_info = iter->data;
2051
2052                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[%dth]", i);
2053                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " name : %s", engine_info->name);
2054                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " id   : %s", engine_info->uuid);
2055                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", engine_info->setting);
2056
2057                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Voices");
2058                 GSList *iter_voice = NULL;
2059                 tts_config_voice_s* voice = NULL;
2060
2061                 if (g_slist_length(engine_info->voices) > 0) {
2062                         /* Get a first item */
2063                         iter_voice = g_slist_nth(engine_info->voices, 0);
2064
2065                         int j = 1;
2066                         while (NULL != iter_voice) {
2067                                 /*Get handle data from list*/
2068                                 voice = iter_voice->data;
2069
2070                                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2071
2072                                 /*Get next item*/
2073                                 iter_voice = g_slist_next(iter_voice);
2074                                 j++;
2075                         }
2076                 } else {
2077                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "  Voice is NONE");
2078                 }
2079                 iter = g_slist_next(iter);
2080                 i++;
2081         }
2082         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2083
2084         return TTS_CONFIG_ERROR_NONE;
2085 }
2086
2087 int tts_config_mgr_get_max_text_size(unsigned int* size)
2088 {
2089         int ret = __check_precondition();
2090         if (TTS_CONFIG_ERROR_NONE != ret) {
2091                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
2092                 return ret;
2093         }
2094
2095         if (NULL == size) {
2096                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2097         }
2098
2099         tts_config_s config_info;
2100         if (0 != tts_parser_get_config_info(&config_info)){
2101                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
2102                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2103         }
2104
2105         tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
2106         if (NULL == engine_info) {
2107                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2108                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
2109         }
2110
2111         *size = engine_info->text_size;
2112         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);
2113
2114         return TTS_CONFIG_ERROR_NONE;
2115 }
2116
2117 int tts_config_mgr_get_instant_reprepare_client(unsigned int *uid)
2118 {
2119         struct buxton_client *bux_cli = NULL;
2120         int ret = buxton_open(&bux_cli, NULL, NULL);
2121         if (0 != ret) {
2122                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_open failed!! (%d)", ret);
2123                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2124         }
2125
2126         struct buxton_layer *bux_layer = buxton_create_layer("system");
2127         if (NULL == bux_layer) {
2128                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_create_layer FAIL");
2129                 buxton_close(bux_cli);
2130                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2131         }
2132
2133         struct buxton_value *bux_val = NULL;
2134         ret = buxton_get_value_sync(bux_cli, bux_layer, TTS_VCONF_INSTANT_REPREPARE_CLIENT, &bux_val);
2135         if (0 != ret || NULL == bux_val) {
2136                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_get_value_sync failed!! (%d)", ret);
2137                 buxton_free_layer(bux_layer);
2138                 buxton_close(bux_cli);
2139                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2140         }
2141
2142         unsigned int specified_uid = TTS_INVALID_UID;
2143         ret = buxton_value_get_uint32(bux_val, &specified_uid);
2144         if (0 != ret) {
2145                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_value_get_uint32 failed!! (%d)", ret);
2146                 *uid = TTS_INVALID_UID;
2147                 ret = TTS_CONFIG_ERROR_OPERATION_FAILED;
2148         } else {
2149                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[BUXTON2] buxton_value_get_uint32: ret(%d), key(%s), uid(%u)", ret, TTS_VCONF_INSTANT_REPREPARE_CLIENT, specified_uid);
2150                 *uid = specified_uid;
2151                 ret = TTS_CONFIG_ERROR_NONE;
2152         }
2153
2154         buxton_value_free(bux_val);
2155         buxton_free_layer(bux_layer);
2156         buxton_close(bux_cli);
2157
2158         return ret;
2159 }
2160
2161 int tts_config_mgr_set_instant_reprepare_client(const unsigned int uid)
2162 {
2163         struct buxton_client *bux_cli = NULL;
2164         int ret = buxton_open(&bux_cli, NULL, NULL);
2165         if (0 != ret) {
2166                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_open failed!! (%d)", ret);
2167                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2168         }
2169
2170         struct buxton_layer *bux_layer = buxton_create_layer("system");
2171         if (NULL == bux_layer) {
2172                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_create_layer FAIL");
2173                 buxton_close(bux_cli);
2174                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2175         }
2176
2177         struct buxton_value *bux_val = buxton_value_create_uint32(uid);
2178         if (NULL == bux_val) {
2179                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_value_create_uint32 FAIL");
2180                 buxton_free_layer(bux_layer);
2181                 buxton_close(bux_cli);
2182                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2183         }
2184
2185         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
2186         ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_VCONF_INSTANT_REPREPARE_CLIENT, bux_val);
2187         if (0 != ret) {
2188                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
2189                 ret = TTS_CONFIG_ERROR_OPERATION_FAILED;
2190         } else {
2191                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[BUXTON2] buxton_set_value_sync: ret(%d), key(%s), uid(%u)", ret, TTS_VCONF_INSTANT_REPREPARE_CLIENT, uid);
2192                 ret = TTS_CONFIG_ERROR_NONE;
2193         }
2194
2195         buxton_value_free(bux_val);
2196         buxton_free_layer(bux_layer);
2197         buxton_close(bux_cli);
2198
2199         return ret;
2200 }