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