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 (-1 != 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 int __tts_config_release_client(unsigned int uid)
 762 {
 763         GSList *iter = NULL;
 764         tts_config_client_s* temp_client = NULL;
 765
 766         if (0 < g_slist_length(g_config_client_list)) {
 767                 /* Check uid */
 768                 iter = g_slist_nth(g_config_client_list, 0);
 769
 770                 while (NULL != iter) {
 771                         temp_client = iter->data;
 772
 773                         if (NULL != temp_client) {
 774                                 if (uid == temp_client->uid) {
 775                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 776                                         free(temp_client);
 777                                         temp_client = NULL;
 778                                         break;
 779                                 }
 780                         }
 781
 782                         iter = g_slist_next(iter);
 783                 }
 784         }
 785
 786         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Client count (%d)", g_slist_length(g_config_client_list));
 787
 788         return g_slist_length(g_config_client_list);
 789 }
 790
 791 void __tts_config_release_engine()
 792 {
 793         GSList *iter = NULL;
 794         tts_engine_info_s *engine_info = NULL;
 795
 796         if (0 < g_slist_length(g_engine_list)) {
 797
 798                 /* Get a first item */
 799                 iter = g_slist_nth(g_engine_list, 0);
 800
 801                 while (NULL != iter) {
 802                         engine_info = iter->data;
 803
 804                         if (NULL != engine_info) {
 805                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 806
 807                                 tts_parser_free_engine_info(engine_info);
 808                         }
 809
 810                         iter = g_slist_nth(g_engine_list, 0);
 811                 }
 812         }
 813
 814         return;
 815 }
 816
 817 int __tts_config_mgr_get_engine_info()
 818 {
 819         DIR *dp = NULL;
 820         struct dirent *dirp = NULL;
 821
 822         char filepath[512] = {'\0',};
 823         int filesize;
 824         tts_engine_info_s* info = NULL;
 825
 826         __tts_config_release_engine();
 827         g_engine_list = NULL;
 828         __tts_config_mgr_unregister_engine_config_updated_event();
 829
 830         /* Copy default info directory to download directory */
 831         dp  = opendir(TTS_DEFAULT_ENGINE_INFO);
 832         if (NULL == dp) {
 833                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No default directory : %s", TTS_DEFAULT_ENGINE_INFO);
 834         } else {
 835                 do {
 836                         dirp = readdir(dp);
 837
 838                         if (NULL != dirp) {
 839                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 840                                         continue;
 841
 842                                 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 843                                 if (filesize >= 512) {
 844                                         SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 845                                         closedir(dp);
 846                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 847                                 }
 848
 849                                 memset(filepath, '\0', 512);
 850                                 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
 851
 852                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
 853
 854                                 char dest[512] = {'\0',};
 855                                 snprintf(dest, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
 856
 857                                 if (0 != access(dest, F_OK)) {
 858                                         if (0 != tts_parser_copy_xml(filepath, dest)) {
 859                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] Fail to copy engine info");
 860                                         }
 861                                 }
 862                         }
 863                 } while (NULL != dirp);
 864
 865                 closedir(dp);
 866         }
 867
 868         /* Get engine info from default engine directory */
 869         dp  = opendir(TTS_DOWNLOAD_ENGINE_INFO);
 870         if (NULL == dp) {
 871                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
 872         } else {
 873                 do {
 874                         dirp = readdir(dp);
 875
 876                         if (NULL != dirp) {
 877                                 if (!strcmp(".", dirp->d_name) || !strcmp("..", dirp->d_name))
 878                                         continue;
 879
 880                                 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 881                                 if (filesize >= 512) {
 882                                         SECURE_SLOG(LOG_ERROR, TAG_TTSCONFIG, "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 883                                         closedir(dp);
 884                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
 885                                 }
 886
 887                                 memset(filepath, '\0', 512);
 888                                 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
 889
 890                                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[CONFIG] Filepath(%s)", filepath);
 891
 892                                 if (0 == tts_parser_get_engine_info(filepath, &info)) {
 893                                         g_engine_list = g_slist_append(g_engine_list, info);
 894                                         if (0 != __tts_config_mgr_register_engine_config_updated_event(filepath)) {
 895                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
 896                                         }
 897                                 }
 898                         }
 899                 } while (NULL != dirp);
 900
 901                 closedir(dp);
 902         }
 903
 904         if (0 >= g_slist_length(g_engine_list)) {
 905                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] No engine");
 906                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
 907         }
 908
 909         return TTS_CONFIG_ERROR_NONE;
 910 }
 911
 912 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 913 {
 914         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ Engine config updated callback event");
 915
 916         tts_engine_inotify_s *ino = (tts_engine_inotify_s *)data;
 917         int dir_fd = ino->dir_fd;
 918
 919         int length;
 920         struct inotify_event event;
 921         memset(&event, '\0', sizeof(struct inotify_event));
 922
 923         length = read(dir_fd, &event, sizeof(struct inotify_event));
 924         if (0 > length) {
 925                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Empty Inotify event");
 926                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 927                 return ECORE_CALLBACK_DONE;
 928         }
 929
 930         if (IN_CLOSE_WRITE == event.mask) {
 931                 int ret = __tts_config_mgr_get_engine_info();
 932                 if (0 != ret) {
 933                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info when config updated");
 934                 }
 935                 __tts_config_mgr_print_engine_info();
 936                 tts_config_s config_info;
 937                 if (0 != tts_parser_get_config_info(&config_info)){
 938                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 939                         return ECORE_CALLBACK_PASS_ON;
 940                 }
 941                 bool support = tts_config_check_default_voice_is_valid(config_info.language, config_info.type);
 942                 if (false == support) {
 943                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[ERROR] Default voice is valid");
 944                         char* temp_lang = NULL;
 945                         int temp_type;
 946                         ret = __tts_config_mgr_select_lang(config_info.engine_id, &temp_lang, &temp_type);
 947                         if (0 != ret) {
 948                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get voice");
 949                         }
 950
 951                         ret = tts_config_mgr_set_voice(temp_lang, temp_type);
 952                         if (0 != ret) {
 953                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set voice");
 954                         } else {
 955                                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Saved default voice : lang(%s), type(%d)", temp_lang, temp_type);
 956                         }
 957                         if (NULL != temp_lang) {
 958                                 free(temp_lang);
 959                                 temp_lang = NULL;
 960                         }
 961                 }
 962
 963                 if (0 != tts_parser_get_config_info(&config_info)){
 964                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
 965                         return ECORE_CALLBACK_PASS_ON;
 966                 }
 967
 968                 /* Call all callbacks of client*/
 969                 engine_changed_cb_parameter_s params = {config_info.engine_id, config_info.setting,config_info.language,
 970                                 config_info.type, config_info.auto_voice, config_info.credential};
 971                 g_slist_foreach(g_config_client_list, __invoke_engine_changed_cb, &params);
 972         } else {
 973                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Undefined event");
 974         }
 975
 976         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@");
 977
 978         return ECORE_CALLBACK_PASS_ON;
 979 }
 980
 981 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
 982 {
 983         if (NULL == path) {
 984                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Path is NULL");
 985                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
 986         }
 987
 988         /* For engine directory monitoring */
 989         tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
 990         if (NULL == ino) {
 991                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
 992                 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
 993         }
 994
 995         ino->dir_fd = inotify_init();
 996         if (ino->dir_fd < 0) {
 997                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to init inotify");
 998                 free(ino);
 999                 ino = NULL;
1000
1001                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1002         }
1003
1004         ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
1005         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Add inotify watch(%s)", path);
1006         if (ino->dir_wd < 0) {
1007                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add watch");
1008                 free(ino);
1009                 ino = NULL;
1010                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1011         }
1012
1013         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);
1014         if (NULL == ino->dir_fd_handler) {
1015                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to add fd handler");
1016                 free(ino);
1017                 ino = NULL;
1018                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1019         }
1020
1021         /* Set non-blocking mode of file */
1022         int value;
1023         value = fcntl(ino->dir_fd, F_GETFL, 0);
1024         value |= O_NONBLOCK;
1025
1026         if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
1027                 SLOG(LOG_WARN, TAG_TTSCONFIG, "[WARNING] Fail to set non-block mode");
1028         }
1029
1030         g_ino_list = g_list_append(g_ino_list, ino);
1031
1032         return TTS_CONFIG_ERROR_NONE;
1033 }
1034
1035 static int __tts_config_mgr_unregister_engine_config_updated_event()
1036 {
1037         /* delete all inotify variable */
1038         if (0 < g_list_length(g_ino_list)) {
1039                 GList *iter = NULL;
1040                 iter = g_list_first(g_ino_list);
1041
1042                 while (NULL != iter) {
1043                         tts_engine_inotify_s *tmp = iter->data;
1044
1045                         if (NULL != tmp) {
1046                                 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1047                                 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1048                                 close(tmp->dir_fd);
1049
1050                                 free(tmp);
1051                                 tmp = NULL;
1052                         }
1053
1054                         g_ino_list = g_list_delete_link(g_ino_list, iter);
1055                         iter = g_list_first(g_ino_list);
1056                 }
1057         }
1058
1059         return TTS_CONFIG_ERROR_NONE;
1060 }
1061
1062 static int __add_new_config_client(unsigned int uid)
1063 {
1064         tts_config_client_s* new_client = NULL;
1065         new_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1066         if (NULL == new_client) {
1067                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to allocate memory");
1068                 return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1069         }
1070         new_client->uid = uid;
1071         new_client->engine_cb = NULL;
1072         new_client->voice_cb = NULL;
1073         new_client->speech_cb = NULL;
1074         new_client->pitch_cb = NULL;
1075         new_client->screen_cb = NULL;
1076         new_client->bg_volume_ratio_cb = NULL;
1077         new_client->user_data = NULL;
1078         new_client->screen_user_data = NULL;
1079
1080         g_config_client_list = g_slist_append(g_config_client_list, new_client);
1081
1082         return TTS_CONFIG_ERROR_NONE;
1083 }
1084
1085 int tts_config_mgr_initialize(unsigned int uid, tts_config_client_type_e client_type)
1086 {
1087         /* Register uid */
1088         if (0 < g_slist_length(g_config_client_list)) {
1089                 /* Check uid */
1090                 GSList *iter = g_slist_nth(g_config_client_list, 0);
1091
1092                 while (NULL != iter) {
1093                         tts_config_client_s* client = (tts_config_client_s*)iter->data;
1094
1095                         if (NULL != client && uid == client->uid) {
1096                                 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] uid(%u) has already registered", uid);
1097                                 return TTS_CONFIG_ERROR_NONE;
1098                         }
1099
1100                         iter = g_slist_next(iter);
1101                 }
1102
1103                 int ret = __add_new_config_client(uid);
1104                 if (TTS_CONFIG_ERROR_NONE != ret) {
1105                         return ret;
1106                 }
1107
1108                 SECURE_SLOG(LOG_WARN, TAG_TTSCONFIG, "[CONFIG] Add uid(%u) but config has already initialized", uid);
1109                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1110                 g_client_type |= client_type;
1111
1112                 return TTS_CONFIG_ERROR_NONE;
1113         } else {
1114                 int ret = __add_new_config_client(uid);
1115                 if (TTS_CONFIG_ERROR_NONE != ret) {
1116                         return ret;
1117                 }
1118         }
1119
1120         if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1121                 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1122                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1123                         __tts_config_release_client(uid);
1124                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1125                 } else {
1126                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_CONFIG_BASE);
1127                 }
1128         }
1129
1130         if (0 != access(TTS_HOME, F_OK)) {
1131                 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1132                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_HOME);
1133                         __tts_config_release_client(uid);
1134                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1135                 } else {
1136                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_HOME);
1137                 }
1138         }
1139
1140         if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1141                 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1142                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1143                         __tts_config_release_client(uid);
1144                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1145                 } else {
1146                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1147                 }
1148         }
1149
1150         if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1151                 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1152                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1153                         __tts_config_release_client(uid);
1154                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1155                 } else {
1156                         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1157                 }
1158         }
1159
1160         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1161         g_client_type |= client_type;
1162
1163         if (0 != __tts_config_mgr_get_engine_info()) {
1164                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get engine info");
1165                 __tts_config_release_client(uid);
1166                 __tts_config_release_engine();
1167                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1168         }
1169
1170         __tts_config_mgr_print_engine_info();
1171
1172         if (0 != tts_parser_load_config()) {
1173                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to parse configure information");
1174                 __tts_config_release_client(uid);
1175                 __tts_config_release_engine();
1176                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1177         }
1178         tts_config_s config_info;
1179         if (0 != tts_parser_get_config_info(&config_info)) {
1180                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1181                 __tts_config_release_client(uid);
1182                 __tts_config_release_engine();
1183                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1184         }
1185
1186         /* Check whether engine id is valid */
1187         if (0 != __tts_config_mgr_check_engine_is_valid(config_info.engine_id)) {
1188                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get default engine");
1189                 __tts_config_release_client(uid);
1190                 __tts_config_release_engine();
1191                 tts_parser_unload_config();
1192                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1193         }
1194
1195         if (true == config_info.auto_voice) {
1196                 /* Check language with display language */
1197                 __tts_config_set_auto_language();
1198
1199                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1200                         if (0 != tts_parser_get_config_info(&config_info)){
1201                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1202                         }
1203
1204                         if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1205                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1206                         }
1207                 }
1208         } else {
1209                 if (false == __tts_config_mgr_check_lang_is_valid(config_info.engine_id, config_info.language, config_info.type)) {
1210                         /* Default language is not valid */
1211                         char* tmp_language = NULL;
1212                         int tmp_type = -1;
1213                         if (0 != __tts_config_mgr_select_lang(config_info.engine_id, &tmp_language, &tmp_type)) {
1214                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to select language");
1215                                 __tts_config_release_client(uid);
1216                                 __tts_config_release_engine();
1217                                 tts_parser_unload_config();
1218                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1219                         }
1220
1221                         if (NULL != tmp_language) {
1222                                 __set_language_into_config(&config_info, tmp_language);
1223                                 config_info.type = tmp_type;
1224
1225                                 free(tmp_language);
1226                                 tmp_language = NULL;
1227
1228                                 if (0 != tts_parser_set_config_info(&config_info)) {
1229                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1230                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1231                                 }
1232
1233                                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1234                                         if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1235                                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1236                                                 __tts_config_release_client(uid);
1237                                                 __tts_config_release_engine();
1238                                                 tts_parser_unload_config();
1239                                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1240                                         }
1241                                 } else {
1242                                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1243                                 }
1244                         }
1245                 }
1246         }
1247
1248         /* print daemon config */
1249         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@ TTS config @@@");
1250         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " engine : %s", config_info.engine_id);
1251         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", config_info.setting);
1252         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " auto voice : %s", config_info.auto_voice ? "on" : "off");
1253         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " language : %s", config_info.language);
1254         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " voice type : %d", config_info.type);
1255         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " speech rate : %d", config_info.speech_rate);
1256         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " pitch : %d", config_info.pitch);
1257         SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, " bg volume ratio : %lf", config_info.bg_volume_ratio);
1258         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "@@@@@");
1259
1260         if (0 != __tts_config_mgr_register_config_event()) {
1261                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register config event");
1262                 __tts_config_release_client(uid);
1263                 __tts_config_release_engine();
1264                 tts_parser_unload_config();
1265                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1266         }
1267
1268         /* Register to detect display language change */
1269         vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1270         vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1271
1272         /* For engine directory monitoring */
1273         //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1274         //      SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to register engine config updated event");
1275         //      __tts_config_release_client(uid);
1276         //      __tts_config_release_engine();
1277         //      tts_parser_unload_config();
1278         //      __tts_config_mgr_unregister_config_event();
1279         //      return TTS_CONFIG_ERROR_OPERATION_FAILED;
1280         //}
1281
1282         return TTS_CONFIG_ERROR_NONE;
1283 }
1284
1285 int tts_config_mgr_finalize(unsigned int uid, tts_config_client_type_e client_type)
1286 {
1287         if (0 < __tts_config_release_client(uid)) {
1288                 g_client_type &= ~client_type;
1289                 return TTS_CONFIG_ERROR_NONE;
1290         }
1291
1292         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type : %d", client_type);
1293         g_client_type &= ~client_type;
1294
1295         tts_config_mgr_unset_callback(uid);
1296
1297         __tts_config_release_engine();
1298
1299         tts_parser_unload_config();
1300
1301         __tts_config_mgr_unregister_engine_config_updated_event();
1302
1303         __tts_config_mgr_unregister_config_event();
1304
1305         vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1306         vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1307
1308         return TTS_CONFIG_ERROR_NONE;
1309 }
1310
1311 int tts_config_mgr_set_callback(unsigned int uid,
1312                                 tts_config_engine_changed_cb engine_cb,
1313                                 tts_config_voice_changed_cb voice_cb,
1314                                 tts_config_speech_rate_changed_cb speech_cb,
1315                                 tts_config_pitch_changed_cb pitch_cb,
1316                                 tts_config_bg_volume_ratio_changed_cb bg_volume_ratio_cb,
1317                                 void* user_data)
1318 {
1319         GSList *iter = NULL;
1320         tts_config_client_s* temp_client = NULL;
1321
1322         /* Call all callbacks of client*/
1323         iter = g_slist_nth(g_config_client_list, 0);
1324
1325         while (NULL != iter) {
1326                 temp_client = iter->data;
1327
1328                 if (NULL != temp_client) {
1329                         if (uid == temp_client->uid) {
1330                                 temp_client->engine_cb = engine_cb;
1331                                 temp_client->voice_cb = voice_cb;
1332                                 temp_client->speech_cb = speech_cb;
1333                                 temp_client->pitch_cb = pitch_cb;
1334                                 temp_client->bg_volume_ratio_cb = bg_volume_ratio_cb;
1335                                 temp_client->user_data = user_data;
1336                         }
1337                 }
1338
1339                 iter = g_slist_next(iter);
1340         }
1341         return TTS_CONFIG_ERROR_NONE;
1342 }
1343
1344 int tts_config_mgr_unset_callback(unsigned int uid)
1345 {
1346         GSList *iter = NULL;
1347         tts_config_client_s* temp_client = NULL;
1348
1349         /* Call all callbacks of client*/
1350         iter = g_slist_nth(g_config_client_list, 0);
1351
1352         while (NULL != iter) {
1353                 temp_client = iter->data;
1354
1355                 if (NULL != temp_client) {
1356                         if (uid == temp_client->uid) {
1357                                 temp_client->engine_cb = NULL;
1358                                 temp_client->voice_cb = NULL;
1359                                 temp_client->speech_cb = NULL;
1360                                 temp_client->pitch_cb = NULL;
1361                                 temp_client->bg_volume_ratio_cb = NULL;
1362                                 temp_client->user_data = NULL;
1363                         }
1364                 }
1365
1366                 iter = g_slist_next(iter);
1367         }
1368
1369         return TTS_CONFIG_ERROR_NONE;
1370 }
1371
1372 int tts_config_mgr_set_screen_reader_callback(unsigned int uid, tts_config_screen_reader_changed_cb callback, void* user_data)
1373 {
1374         if (NULL == callback) {
1375                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Input parameter is NULL");
1376                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1377         }
1378
1379         GSList *iter = NULL;
1380         tts_config_client_s* temp_client = NULL;
1381
1382         /* Call all callbacks of client*/
1383         iter = g_slist_nth(g_config_client_list, 0);
1384
1385         while (NULL != iter) {
1386                 temp_client = iter->data;
1387
1388                 if (NULL != temp_client) {
1389                         if (uid == temp_client->uid) {
1390                                 temp_client->screen_cb = callback;
1391                                 temp_client->screen_user_data = user_data;
1392                         }
1393                 }
1394
1395                 iter = g_slist_next(iter);
1396         }
1397         return TTS_CONFIG_ERROR_NONE;
1398 }
1399
1400 int tts_config_mgr_unset_screen_reader_callback(unsigned int uid)
1401 {
1402         GSList *iter = NULL;
1403         tts_config_client_s* temp_client = NULL;
1404
1405         /* Call all callbacks of client*/
1406         iter = g_slist_nth(g_config_client_list, 0);
1407
1408         while (NULL != iter) {
1409                 temp_client = iter->data;
1410
1411                 if (NULL != temp_client) {
1412                         if (uid == temp_client->uid) {
1413                                 temp_client->screen_cb = NULL;
1414                                 temp_client->screen_user_data = NULL;
1415                         }
1416                 }
1417
1418                 iter = g_slist_next(iter);
1419         }
1420         return TTS_CONFIG_ERROR_NONE;
1421 }
1422
1423 static int __check_precondition()
1424 {
1425         if (0 >= g_slist_length(g_config_client_list)) {
1426                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Not initialized");
1427                 return TTS_CONFIG_ERROR_INVALID_STATE;
1428         }
1429
1430         if (0 >= g_slist_length(g_engine_list)) {
1431                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] There is no engine!!");
1432                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1433         }
1434
1435         return TTS_CONFIG_ERROR_NONE;
1436 }
1437
1438
1439 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1440 {
1441         int ret = __check_precondition();
1442         if (TTS_CONFIG_ERROR_NONE != ret) {
1443                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1444                 return ret;
1445         }
1446
1447         GSList *iter = NULL;
1448         tts_engine_info_s *engine_info = NULL;
1449
1450         /* Get a first item */
1451         iter = g_slist_nth(g_engine_list, 0);
1452
1453         while (NULL != iter) {
1454                 engine_info = iter->data;
1455
1456                 if (NULL != engine_info) {
1457                         if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1458                                 break;
1459                         }
1460                 }
1461
1462                 iter = g_slist_next(iter);
1463         }
1464
1465         return TTS_CONFIG_ERROR_NONE;
1466 }
1467
1468 int tts_config_mgr_get_engine(char** engine)
1469 {
1470         int ret = __check_precondition();
1471         if (TTS_CONFIG_ERROR_NONE != ret) {
1472                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1473                 return ret;
1474         }
1475
1476         if (NULL == engine) {
1477                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1478                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1479         }
1480
1481         tts_config_s config_info;
1482         if (0 != tts_parser_get_config_info(&config_info)){
1483                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1484                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1485         }
1486
1487         tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
1488         if (NULL == engine_info) {
1489                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] engine info is NULL");
1490                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1491         }
1492
1493         *engine = strdup(config_info.engine_id);
1494         return TTS_CONFIG_ERROR_NONE;
1495 }
1496
1497 int __tts_set_buxtonkey(const char* engine)
1498 {
1499         /* Set vconfkey */
1500         struct buxton_client * bux_cli;
1501         struct buxton_layer * bux_layer;
1502         struct buxton_value * bux_val;
1503
1504         int ret = buxton_open(&bux_cli, NULL, NULL);
1505         if (0 != ret) {
1506                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1507                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1508         }
1509         bux_layer = buxton_create_layer("system");
1510         if (NULL == bux_layer) {
1511                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_create_layer FAIL");
1512                 buxton_close(bux_cli);
1513                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1514         }
1515         bux_val = buxton_value_create_string(engine);
1516         if (NULL == bux_val) {
1517                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1518                 buxton_free_layer(bux_layer);
1519                 buxton_close(bux_cli);
1520                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1521         } else {
1522                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1523         }
1524
1525         ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1526         if (0 != ret) {
1527                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1528                 buxton_value_free(bux_val);
1529                 buxton_free_layer(bux_layer);
1530                 buxton_close(bux_cli);
1531
1532                 bux_cli = NULL;
1533                 bux_layer = NULL;
1534                 bux_val = NULL;
1535
1536                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1537         } else {
1538                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1539         }
1540
1541         buxton_value_free(bux_val);
1542         buxton_free_layer(bux_layer);
1543         buxton_close(bux_cli);
1544
1545         bux_cli = NULL;
1546         bux_layer = NULL;
1547         bux_val = NULL;
1548
1549         return TTS_CONFIG_ERROR_NONE;
1550 }
1551
1552 int tts_config_mgr_set_engine(const char* engine)
1553 {
1554         int ret = __check_precondition();
1555         if (TTS_CONFIG_ERROR_NONE != ret) {
1556                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1557                 return ret;
1558         }
1559
1560         if (NULL == engine)
1561                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1562
1563         tts_config_s config_info;
1564         if (0 != tts_parser_get_config_info(&config_info)){
1565                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1566                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1567         }
1568
1569         /* Check current engine id with new engine id */
1570         if (0 == strcmp(config_info.engine_id, engine))
1571                 return TTS_CONFIG_ERROR_NONE;
1572
1573         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "New engine id : %s", engine);
1574
1575         ret = __tts_set_buxtonkey(engine);
1576         if (0 != ret) {
1577                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] set_buxtonkey Fail!!");
1578                 return ret;
1579         }
1580
1581         bool is_valid_engine = false;
1582         tts_engine_info_s *engine_info = __get_engine_info(engine);
1583         if (NULL != engine_info) {
1584                 memset(g_engine_id, '\0', sizeof(g_engine_id));
1585                 config_info.engine_id = g_engine_id;
1586                 strncpy(config_info.engine_id, engine, sizeof(g_engine_id) - 1);
1587
1588                 if (NULL != engine_info->setting) {
1589                         memset(g_setting, '\0', sizeof(g_setting));
1590                         config_info.setting = g_setting;
1591                         strncpy(config_info.setting, engine_info->setting, sizeof(g_setting) - 1);
1592                 }
1593
1594                 /* Engine is valid*/
1595                 bool is_valid_voice = false;
1596                 tts_config_voice_s* voice = __get_voice_info(engine_info, config_info.language, config_info.type);
1597                 if (NULL != voice) {
1598                         /* language is valid */
1599                         is_valid_voice = true;
1600                         config_info.type = voice->type;
1601                 }
1602
1603                 if (false == is_valid_voice) {
1604                         __set_language_into_config(&config_info, NULL);
1605
1606                         GSList *iter_voice = g_slist_nth(engine_info->voices, 0);
1607                         if (NULL != iter_voice) {
1608                                 voice = iter_voice->data;
1609                                 if (NULL != voice) {
1610                                         if (NULL != voice->language)
1611                                                 strncpy(config_info.language, voice->language, sizeof(g_language) - 1);
1612
1613                                         config_info.type = voice->type;
1614                                 }
1615                         }
1616                 }
1617
1618                 is_valid_engine = true;
1619         }
1620
1621         if (0 != tts_parser_set_config_info(&config_info)) {
1622                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1623                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1624         }
1625
1626         if (true == is_valid_engine) {
1627                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Engine changed");
1628                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Engine : %s", config_info.engine_id);
1629                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Setting : %s", config_info.setting);
1630                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Language : %s", config_info.language);
1631                 SECURE_SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  Type : %d", config_info.type);
1632
1633                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1634                         if (0 != tts_parser_set_engine(config_info.engine_id, config_info.setting,
1635                                 config_info.language, config_info.type)) {
1636                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, " Fail to save config");
1637                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1638                         }
1639                 } else {
1640                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1641                 }
1642         } else {
1643                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Engine id is not valid");
1644                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1645         }
1646
1647         return TTS_CONFIG_ERROR_NONE;
1648 }
1649
1650 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1651 {
1652         int ret = __check_precondition();
1653         if (TTS_CONFIG_ERROR_NONE != ret) {
1654                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1655                 return ret;
1656         }
1657
1658         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
1659         if (NULL == engine_info) {
1660                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] engine info is NULL");
1661                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1662         }
1663
1664         GSList *iter_voice = NULL;
1665         tts_config_voice_s* voice = NULL;
1666
1667         /* Get a first item */
1668         iter_voice = g_slist_nth(engine_info->voices, 0);
1669
1670         while (NULL != iter_voice) {
1671                 /*Get handle data from list*/
1672                 voice = iter_voice->data;
1673
1674                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " lang(%s) type(%d)", voice->language, voice->type);
1675                 if (NULL != voice->language) {
1676                         if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1677                                 break;
1678                 }
1679
1680                 /*Get next item*/
1681                 iter_voice = g_slist_next(iter_voice);
1682         }
1683
1684         return TTS_CONFIG_ERROR_NONE;
1685 }
1686
1687 int tts_config_mgr_get_voice(char** language, int* type)
1688 {
1689         int ret = __check_precondition();
1690         if (TTS_CONFIG_ERROR_NONE != ret) {
1691                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1692                 return ret;
1693         }
1694
1695         if (NULL == language || NULL == type)
1696                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1697
1698         tts_config_s config_info;
1699         if (0 != tts_parser_get_config_info(&config_info)){
1700                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1701                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1702         }
1703
1704         if (0 != strlen(config_info.language)) {
1705                 *language = strdup(config_info.language);
1706                 *type = config_info.type;
1707         } else {
1708                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "language is NULL");
1709                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1710         }
1711
1712         return TTS_CONFIG_ERROR_NONE;
1713 }
1714
1715 int tts_config_mgr_set_voice(const char* language, int type)
1716 {
1717         int ret = __check_precondition();
1718         if (TTS_CONFIG_ERROR_NONE != ret) {
1719                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1720                 return ret;
1721         }
1722
1723         if (NULL == language) {
1724                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Input parameter is NULL");
1725                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1726         }
1727
1728         tts_config_s config_info;
1729         if (0 != tts_parser_get_config_info(&config_info)){
1730                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1731                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1732         }
1733
1734         /* Check language is valid */
1735         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1736                 if (0 != tts_parser_set_voice(language, type)) {
1737                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save default voice");
1738                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1739                 }
1740         } else {
1741                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1742         }
1743
1744         __set_language_into_config(&config_info, language);
1745         config_info.type = type;
1746
1747         if (0 != tts_parser_set_config_info(&config_info)){
1748                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1749                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1750         }
1751
1752         return TTS_CONFIG_ERROR_NONE;
1753 }
1754
1755 int tts_config_mgr_get_auto_voice(bool* value)
1756 {
1757         if (0 >= g_slist_length(g_config_client_list)) {
1758                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1759                 return TTS_CONFIG_ERROR_INVALID_STATE;
1760         }
1761
1762         if (NULL == value)
1763                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1764
1765         tts_config_s config_info;
1766         if (0 != tts_parser_get_config_info(&config_info)){
1767                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1768                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1769         }
1770
1771         *value = config_info.auto_voice;
1772
1773         return TTS_CONFIG_ERROR_NONE;
1774 }
1775
1776 int tts_config_mgr_set_auto_voice(bool value)
1777 {
1778         if (0 >= g_slist_length(g_config_client_list)) {
1779                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1780                 return TTS_CONFIG_ERROR_INVALID_STATE;
1781         }
1782
1783         tts_config_s config_info;
1784         if (0 != tts_parser_get_config_info(&config_info)){
1785                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1786                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1787         }
1788
1789         if (config_info.auto_voice != value) {
1790                 /* Check language is valid */
1791                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1792                         if (0 != tts_parser_set_auto_voice(value)) {
1793                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save auto voice option");
1794                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1795                         }
1796                 } else {
1797                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1798                 }
1799
1800                 config_info.auto_voice = value;
1801                 if (0 != tts_parser_set_config_info(&config_info)) {
1802                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1803                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1804                 }
1805
1806                 if (true == config_info.auto_voice) {
1807                         __tts_config_set_auto_language();
1808
1809                         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1810                                 if (0 != tts_parser_get_config_info(&config_info)){
1811                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1812                                 }
1813
1814                                 if (0 != tts_parser_set_voice(config_info.language, config_info.type)) {
1815                                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to save config");
1816                                 }
1817                         }
1818                 }
1819         }
1820
1821         return TTS_CONFIG_ERROR_NONE;
1822 }
1823
1824 int tts_config_mgr_get_speech_rate(int* value)
1825 {
1826         if (0 >= g_slist_length(g_config_client_list)) {
1827                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1828                 return TTS_CONFIG_ERROR_INVALID_STATE;
1829         }
1830
1831         if (NULL == value) {
1832                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1833         }
1834
1835         tts_config_s config_info;
1836         if (0 != tts_parser_get_config_info(&config_info)){
1837                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1838                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1839         }
1840
1841         *value = config_info.speech_rate;
1842
1843         return TTS_CONFIG_ERROR_NONE;
1844 }
1845
1846 int tts_config_mgr_set_speech_rate(int value)
1847 {
1848         if (0 >= g_slist_length(g_config_client_list)) {
1849                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1850                 return TTS_CONFIG_ERROR_INVALID_STATE;
1851         }
1852
1853         if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1854                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set speech rate : %d", value);
1855                 if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1856                         if (0 != tts_parser_set_speech_rate(value)) {
1857                                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1858                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1859                         }
1860                 } else {
1861                         SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1862                 }
1863
1864                 tts_config_s config_info;
1865                 if (0 != tts_parser_get_config_info(&config_info)){
1866                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1867                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1868                 }
1869                 config_info.speech_rate = value;
1870                 if (0 != tts_parser_set_config_info(&config_info)){
1871                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1872                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1873                 }
1874         } else {
1875                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[Config ERROR] Speech rate is invalid : %d", value);
1876         }
1877
1878         return TTS_CONFIG_ERROR_NONE;
1879 }
1880
1881 static int __check_engine_support_pitch(const char* engine_id)
1882 {
1883         tts_engine_info_s *engine_info = __get_engine_info(engine_id);
1884         if (NULL == engine_info) {
1885                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
1886                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1887         }
1888
1889         if (false == engine_info->pitch_support) {
1890                 return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1891         }
1892
1893         return TTS_CONFIG_ERROR_NONE;
1894 }
1895
1896 int tts_config_mgr_get_pitch(int* value)
1897 {
1898         int ret = __check_precondition();
1899         if (TTS_CONFIG_ERROR_NONE != ret) {
1900                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1901                 return ret;
1902         }
1903
1904         if (NULL == value) {
1905                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1906         }
1907
1908         tts_config_s config_info;
1909         if (0 != tts_parser_get_config_info(&config_info)){
1910                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1911                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1912         }
1913
1914         ret = __check_engine_support_pitch(config_info.engine_id);
1915         if (TTS_CONFIG_ERROR_NONE != ret) {
1916                 return ret;
1917         }
1918
1919         *value = config_info.pitch;
1920
1921         return TTS_CONFIG_ERROR_NONE;
1922 }
1923
1924 int tts_config_mgr_set_pitch(int value)
1925 {
1926         int ret = __check_precondition();
1927         if (TTS_CONFIG_ERROR_NONE != ret) {
1928                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
1929                 return ret;
1930         }
1931
1932         tts_config_s config_info;
1933         if (0 != tts_parser_get_config_info(&config_info)){
1934                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1935                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1936         }
1937
1938         ret = __check_engine_support_pitch(config_info.engine_id);
1939         if (TTS_CONFIG_ERROR_NONE != ret) {
1940                 return ret;
1941         }
1942
1943         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1944                 if (0 != tts_parser_set_pitch(value)) {
1945                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save speech rate");
1946                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1947                 }
1948         } else {
1949                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1950         }
1951
1952         config_info.pitch = value;
1953
1954         if (0 != tts_parser_set_config_info(&config_info)){
1955                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
1956                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1957         }
1958         return TTS_CONFIG_ERROR_NONE;
1959 }
1960
1961 int tts_config_mgr_get_bg_volume_ratio(double *value)
1962 {
1963         if (0 >= g_slist_length(g_config_client_list)) {
1964                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1965                 return TTS_CONFIG_ERROR_INVALID_STATE;
1966         }
1967
1968         if (NULL == value)
1969                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1970
1971         tts_config_s config_info;
1972         if (0 != tts_parser_get_config_info(&config_info)){
1973                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
1974                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1975         }
1976
1977         *value = config_info.bg_volume_ratio;
1978
1979         return TTS_CONFIG_ERROR_NONE;
1980 }
1981
1982 int tts_config_mgr_set_bg_volume_ratio(double value)
1983 {
1984         if (0 >= g_slist_length(g_config_client_list)) {
1985                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
1986                 return TTS_CONFIG_ERROR_INVALID_STATE;
1987         }
1988
1989         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[Config] Set bg volume ratio : %lf", value);
1990         if (__is_client_type(TTS_CONFIG_CLIENT_TYPE_SETTING | TTS_CONFIG_CLIENT_TYPE_SERVER | TTS_CONFIG_CLIENT_TYPE_INTERRUPT)) {
1991                 if (0 != tts_parser_set_bg_volume_ratio(value)) {
1992                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "Fail to save bg volume ratio");
1993                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1994                 }
1995         } else {
1996                 SLOG(LOG_INFO, TAG_TTSCONFIG, "Client type is default. Skip saving configuration file.");
1997         }
1998
1999         tts_config_s config_info;
2000         if (0 != tts_parser_get_config_info(&config_info)){
2001                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
2002                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2003         }
2004
2005         config_info.bg_volume_ratio = value;
2006
2007         if (0 != tts_parser_set_config_info(&config_info)){
2008                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to set configure information");
2009                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2010         }
2011
2012         return TTS_CONFIG_ERROR_NONE;
2013 }
2014
2015 bool tts_config_check_default_engine_is_valid(const char* engine)
2016 {
2017         int ret = __check_precondition();
2018         if (TTS_CONFIG_ERROR_NONE != ret) {
2019                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
2020                 return false;
2021         }
2022
2023         if (NULL == engine)
2024                 return false;
2025
2026         tts_engine_info_s *engine_info = __get_engine_info(engine);
2027         if (NULL == engine_info) {
2028                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2029                 return false;
2030         }
2031
2032         return true;
2033 }
2034
2035 bool tts_config_check_default_voice_is_valid(const char* language, int type)
2036 {
2037         if (0 >= g_slist_length(g_config_client_list)) {
2038                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Not initialized");
2039                 return false;
2040         }
2041
2042         tts_config_s config_info;
2043         if (0 != tts_parser_get_config_info(&config_info)){
2044                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
2045                 return false;
2046         }
2047
2048         if (0 == strlen(config_info.engine_id)) {
2049                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Default engine id is NULL");
2050                 return false;
2051         }
2052
2053         return __tts_config_mgr_check_lang_is_valid(config_info.engine_id, language, type);
2054 }
2055
2056
2057 int __tts_config_mgr_print_engine_info()
2058 {
2059         GSList *iter = NULL;
2060         tts_engine_info_s *engine_info = NULL;
2061
2062         if (0 >= g_slist_length(g_engine_list)) {
2063                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "-------------- engine list -----------------");
2064                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  No Engine in engine directory");
2065                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2066                 return TTS_CONFIG_ERROR_NONE;
2067         }
2068
2069         /* Get a first item */
2070         iter = g_slist_nth(g_engine_list, 0);
2071
2072         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------- engine list -----------------");
2073
2074         int i = 1;
2075         while (NULL != iter) {
2076                 engine_info = iter->data;
2077
2078                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[%dth]", i);
2079                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " name : %s", engine_info->name);
2080                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " id   : %s", engine_info->uuid);
2081                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " setting : %s", engine_info->setting);
2082
2083                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, " Voices");
2084                 GSList *iter_voice = NULL;
2085                 tts_config_voice_s* voice = NULL;
2086
2087                 if (g_slist_length(engine_info->voices) > 0) {
2088                         /* Get a first item */
2089                         iter_voice = g_slist_nth(engine_info->voices, 0);
2090
2091                         int j = 1;
2092                         while (NULL != iter_voice) {
2093                                 /*Get handle data from list*/
2094                                 voice = iter_voice->data;
2095
2096                                 SLOG(LOG_DEBUG, TAG_TTSCONFIG, "  [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2097
2098                                 /*Get next item*/
2099                                 iter_voice = g_slist_next(iter_voice);
2100                                 j++;
2101                         }
2102                 } else {
2103                         SLOG(LOG_ERROR, TAG_TTSCONFIG, "  Voice is NONE");
2104                 }
2105                 iter = g_slist_next(iter);
2106                 i++;
2107         }
2108         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "--------------------------------------------");
2109
2110         return TTS_CONFIG_ERROR_NONE;
2111 }
2112
2113 int tts_config_mgr_get_max_text_size(unsigned int* size)
2114 {
2115         int ret = __check_precondition();
2116         if (TTS_CONFIG_ERROR_NONE != ret) {
2117                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "Precondition is not met (%s)", get_error_message(ret));
2118                 return ret;
2119         }
2120
2121         if (NULL == size) {
2122                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2123         }
2124
2125         tts_config_s config_info;
2126         if (0 != tts_parser_get_config_info(&config_info)){
2127                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "[ERROR] Fail to get configure information");
2128                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2129         }
2130
2131         tts_engine_info_s *engine_info = __get_engine_info(config_info.engine_id);
2132         if (NULL == engine_info) {
2133                 SLOG(LOG_ERROR, TAG_TTSCONFIG, "engine info is NULL");
2134                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
2135         }
2136
2137         *size = engine_info->text_size;
2138         SLOG(LOG_DEBUG, TAG_TTSCONFIG, "[DEBUG] Max text size is %d.", *size);
2139
2140         return TTS_CONFIG_ERROR_NONE;
2141 }