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