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                 SLOG(LOG_DEBUG, tts_tag(), " ");
 344                 return ECORE_CALLBACK_DONE;
 345         }
 346
 347         if (IN_CLOSE_WRITE == event.mask) {
 348                 /* check config changed state */
 349                 char* engine = NULL;
 350                 char* setting = NULL;
 351                 char* lang = NULL;
 352                 bool auto_voice = g_config_info->auto_voice;
 353                 int voice_type = -1;
 354                 int speech_rate = -1;
 355                 int pitch = -1;
 356
 357                 GSList *iter = NULL;
 358                 tts_config_client_s* temp_client = NULL;
 359
 360                 if (0 != tts_parser_find_config_changed(&engine, &setting, &auto_voice, &lang, &voice_type, &speech_rate, &pitch))
 361                         return ECORE_CALLBACK_PASS_ON;
 362
 363                 /* engine changed */
 364                 if (NULL != engine || NULL != setting) {
 365                         if (NULL != engine) {
 366                                 memset(g_engine_id, '\0', sizeof(g_engine_id));
 367                                 g_config_info->engine_id = g_engine_id;
 368                                 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
 369                         }
 370                         if (NULL != setting) {
 371                                 memset(g_setting, '\0', sizeof(g_setting));
 372                                 g_config_info->setting = g_setting;
 373                                 strncpy(g_config_info->setting, setting, sizeof(g_setting) - 1);
 374                         }
 375
 376                         SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine change(%s)", g_config_info->engine_id);
 377
 378                         /* Call all callbacks of client*/
 379                         iter = g_slist_nth(g_config_client_list, 0);
 380
 381                         while (NULL != iter) {
 382                                 temp_client = iter->data;
 383
 384                                 if (NULL != temp_client) {
 385                                         if (NULL != temp_client->engine_cb) {
 386                                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
 387                                                 temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
 388                                                         g_config_info->language, g_config_info->type,
 389                                                         g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
 390                                         }
 391                                 }
 392
 393                                 iter = g_slist_next(iter);
 394                         }
 395                 }
 396
 397                 if (auto_voice != g_config_info->auto_voice) {
 398                         g_config_info->auto_voice = auto_voice;
 399                 }
 400
 401                 if (NULL != lang || -1 != voice_type) {
 402                         char* before_lang = NULL;
 403                         int before_type;
 404
 405                         before_lang = strdup(g_config_info->language);
 406                         before_type = g_config_info->type;
 407
 408                         if (NULL != lang) {
 409                                 memset(g_language, '\0', sizeof(g_language));
 410                                 g_config_info->language = g_language;
 411                                 strncpy(g_config_info->language, lang, sizeof(g_language) - 1);
 412                         }
 413                         if (-1 != voice_type) {
 414                                 g_config_info->type = voice_type;
 415                         }
 416
 417                         SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice change(%s, %d)", g_config_info->language, g_config_info->type);
 418
 419                         /* Call all callbacks of client*/
 420                         iter = g_slist_nth(g_config_client_list, 0);
 421
 422                         while (NULL != iter) {
 423                                 temp_client = iter->data;
 424
 425                                 if (NULL != temp_client) {
 426                                         if (NULL != temp_client->voice_cb) {
 427                                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Voice changed callback : uid(%d)", temp_client->uid);
 428                                                 temp_client->voice_cb(before_lang, before_type,
 429                                                         g_config_info->language, g_config_info->type,
 430                                                         g_config_info->auto_voice, temp_client->user_data);
 431                                         }
 432                                 }
 433
 434                                 iter = g_slist_next(iter);
 435                         }
 436
 437                         if (NULL != before_lang) {
 438                                 free(before_lang);
 439                                 before_lang = NULL;
 440                         }
 441                 }
 442
 443                 if (-1 != speech_rate) {
 444                         g_config_info->speech_rate = speech_rate;
 445
 446                         SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate change(%d)", g_config_info->speech_rate);
 447
 448                         /* Call all callbacks of client*/
 449                         iter = g_slist_nth(g_config_client_list, 0);
 450
 451                         while (NULL != iter) {
 452                                 temp_client = iter->data;
 453
 454                                 if (NULL != temp_client) {
 455                                         if (NULL != temp_client->speech_cb) {
 456                                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Speech rate changed callback : uid(%d)", temp_client->uid);
 457                                                 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
 458                                         }
 459                                 }
 460
 461                                 iter = g_slist_next(iter);
 462                         }
 463                 }
 464
 465                 if (-1 != pitch) {
 466                         g_config_info->pitch = pitch;
 467
 468                         SECURE_SLOG(LOG_DEBUG, tts_tag(), "pitch change(%d)", g_config_info->pitch);
 469
 470                         /* Call all callbacks of client*/
 471                         iter = g_slist_nth(g_config_client_list, 0);
 472
 473                         while (NULL != iter) {
 474                                 temp_client = iter->data;
 475
 476                                 if (NULL != temp_client) {
 477                                         if (NULL != temp_client->pitch_cb) {
 478                                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "Pitch changed callback : uid(%d)", temp_client->uid);
 479                                                 temp_client->pitch_cb(g_config_info->pitch, temp_client->user_data);
 480                                         }
 481                                 }
 482
 483                                 iter = g_slist_next(iter);
 484                         }
 485                 }
 486
 487                 if (NULL != engine) {
 488                         free(engine);
 489                         engine = NULL;
 490                 }
 491                 if (NULL != setting) {
 492                         free(setting);
 493                         setting = NULL;
 494                 }
 495                 if (NULL != lang) {
 496                         free(lang);
 497                         lang = NULL;
 498                 }
 499         } else if (IN_IGNORED == event.mask) {
 500                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] IN_IGNORED event");
 501                 tts_parser_unload_config(g_config_info);
 502                 tts_parser_load_config(&g_config_info);
 503         } else {
 504                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event (0x%x)", event.mask);
 505         }
 506
 507         SLOG(LOG_DEBUG, tts_tag(), "=====");
 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);
 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                 SLOG(LOG_DEBUG, tts_tag(), " ");
 881                 return ECORE_CALLBACK_DONE;
 882         }
 883
 884         if (IN_CLOSE_WRITE == event.mask) {
 885                 int ret = __tts_config_mgr_get_engine_info();
 886                 if (0 != ret) {
 887                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
 888                 }
 889                 __tts_config_mgr_print_engine_info();
 890                 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
 891                 if (false == support) {
 892                         SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
 893                         char* temp_lang = NULL;
 894                         int temp_type;
 895                         ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
 896                         if (0 != ret) {
 897                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
 898                         }
 899
 900                         ret = tts_config_mgr_set_voice(temp_lang, temp_type);
 901                         if (0 != ret) {
 902                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
 903                         } else {
 904                                 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
 905                         }
 906                         if (NULL != temp_lang) {
 907                                 free(temp_lang);
 908                                 temp_lang = NULL;
 909                         }
 910                 }
 911
 912                 GSList *iter = NULL;
 913                 tts_config_client_s* temp_client = NULL;
 914                 /* Call all callbacks of client*/
 915                 iter = g_slist_nth(g_config_client_list, 0);
 916
 917                 while (NULL != iter) {
 918                         temp_client = iter->data;
 919
 920                         if (NULL != temp_client) {
 921                                 if (NULL != temp_client->engine_cb) {
 922                                         SECURE_SLOG(LOG_DEBUG, tts_tag(), "Engine changed callback : uid(%d)", temp_client->uid);
 923                                         temp_client->engine_cb(g_config_info->engine_id, g_config_info->setting,
 924                                                 g_config_info->language, g_config_info->type,
 925                                                 g_config_info->auto_voice, g_config_info->credential, temp_client->user_data);
 926                                 }
 927                         }
 928
 929                         iter = g_slist_next(iter);
 930                 }
 931         } else {
 932                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
 933         }
 934
 935         SLOG(LOG_DEBUG, tts_tag(), "=====");
 936         SLOG(LOG_DEBUG, tts_tag(), " ");
 937
 938         return ECORE_CALLBACK_PASS_ON;
 939 }
 940
 941 static int __tts_config_mgr_register_engine_config_updated_event(const char* path)
 942 {
 943         if (NULL == path) {
 944                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Path is NULL");
 945                 return -1;
 946         }
 947
 948         /* For engine directory monitoring */
 949         tts_engine_inotify_s *ino = (tts_engine_inotify_s *)calloc(1, sizeof(tts_engine_inotify_s));
 950         if (NULL == ino) {
 951                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
 952                 return -1;
 953         }
 954
 955         ino->dir_fd = inotify_init();
 956         if (ino->dir_fd < 0) {
 957                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
 958                 free(ino);
 959                 ino = NULL;
 960
 961                 return -1;
 962         }
 963
 964         ino->dir_wd = inotify_add_watch(ino->dir_fd, path, IN_CLOSE_WRITE);
 965         SLOG(LOG_DEBUG, tts_tag(), "Add inotify watch(%s)", path);
 966         if (ino->dir_wd < 0) {
 967                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
 968                 free(ino);
 969                 ino = NULL;
 970                 return -1;
 971         }
 972
 973         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);
 974         if (NULL == ino->dir_fd_handler) {
 975                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
 976                 free(ino);
 977                 ino = NULL;
 978                 return -1;
 979         }
 980
 981         /* Set non-blocking mode of file */
 982         int value;
 983         value = fcntl(ino->dir_fd, F_GETFL, 0);
 984         value |= O_NONBLOCK;
 985
 986         if (0 > fcntl(ino->dir_fd, F_SETFL, value)) {
 987                 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
 988         }
 989
 990         g_ino_list = g_list_append(g_ino_list, ino);
 991
 992         return 0;
 993 }
 994
 995 static int __tts_config_mgr_unregister_engine_config_updated_event()
 996 {
 997         /* delete all inotify variable */
 998         if (0 < g_list_length(g_ino_list)) {
 999                 GList *iter = NULL;
1000                 iter = g_list_first(g_ino_list);
1001
1002                 while (NULL != iter) {
1003                         tts_engine_inotify_s *tmp = iter->data;
1004
1005                         if (NULL != tmp) {
1006                                 ecore_main_fd_handler_del(tmp->dir_fd_handler);
1007                                 inotify_rm_watch(tmp->dir_fd, tmp->dir_wd);
1008                                 close(tmp->dir_fd);
1009
1010                                 free(tmp);
1011                                 tmp = NULL;
1012                         }
1013
1014                         g_ino_list = g_list_remove_link(g_ino_list, iter);
1015
1016                         iter = g_list_first(g_ino_list);
1017                 }
1018         }
1019
1020         return 0;
1021 }
1022
1023 int tts_config_mgr_initialize(int uid)
1024 {
1025         GSList *iter = NULL;
1026         int* get_uid;
1027         tts_config_client_s* temp_client = NULL;
1028
1029         /* Register uid */
1030         if (0 < g_slist_length(g_config_client_list)) {
1031                 /* Check uid */
1032                 iter = g_slist_nth(g_config_client_list, 0);
1033
1034                 while (NULL != iter) {
1035                         get_uid = iter->data;
1036
1037                         if (uid == *get_uid) {
1038                                 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
1039                                 return 0;
1040                         }
1041
1042                         iter = g_slist_next(iter);
1043                 }
1044
1045                 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1046                 if (NULL == temp_client) {
1047                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1048                         return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1049                 }
1050                 temp_client->uid = uid;
1051                 temp_client->engine_cb = NULL;
1052                 temp_client->voice_cb = NULL;
1053                 temp_client->speech_cb = NULL;
1054                 temp_client->pitch_cb = NULL;
1055                 temp_client->screen_cb = NULL;
1056                 temp_client->user_data = NULL;
1057
1058                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1059
1060                 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
1061                 return 0;
1062         } else {
1063                 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1064                 if (NULL == temp_client) {
1065                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to allocate memory");
1066                         return TTS_CONFIG_ERROR_OUT_OF_MEMORY;
1067                 }
1068                 temp_client->uid = uid;
1069                 temp_client->engine_cb = NULL;
1070                 temp_client->voice_cb = NULL;
1071                 temp_client->speech_cb = NULL;
1072                 temp_client->pitch_cb = NULL;
1073                 temp_client->screen_cb = NULL;
1074                 temp_client->user_data = NULL;
1075
1076                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1077         }
1078
1079         if (0 != access(TTS_CONFIG_BASE, F_OK)) {
1080                 if (0 != mkdir(TTS_CONFIG_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1081                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_CONFIG_BASE);
1082                         __tts_config_release_client(uid);
1083                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1084                 } else {
1085                         SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_CONFIG_BASE);
1086                 }
1087         }
1088
1089         if (0 != access(TTS_HOME, F_OK)) {
1090                 if (0 != mkdir(TTS_HOME, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1091                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_HOME);
1092                         __tts_config_release_client(uid);
1093                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1094                 } else {
1095                         SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_HOME);
1096                 }
1097         }
1098
1099         if (0 != access(TTS_DOWNLOAD_BASE, F_OK)) {
1100                 if (0 != mkdir(TTS_DOWNLOAD_BASE, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1101                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_BASE);
1102                         __tts_config_release_client(uid);
1103                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1104                 } else {
1105                         SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_BASE);
1106                 }
1107         }
1108
1109         if (0 != access(TTS_DOWNLOAD_ENGINE_INFO, F_OK)) {
1110                 if (0 != mkdir(TTS_DOWNLOAD_ENGINE_INFO, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)) {
1111                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1112                         __tts_config_release_client(uid);
1113                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1114                 } else {
1115                         SLOG(LOG_DEBUG, tts_tag(), "Success to make directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
1116                 }
1117         }
1118
1119         if (0 != __tts_config_mgr_get_engine_info()) {
1120                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1121                 __tts_config_release_client(uid);
1122                 __tts_config_release_engine();
1123                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1124         }
1125
1126         __tts_config_mgr_print_engine_info();
1127
1128         if (0 != tts_parser_load_config(&g_config_info)) {
1129                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1130                 __tts_config_release_client(uid);
1131                 __tts_config_release_engine();
1132                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1133         }
1134
1135         /* Check whether engine id is valid */
1136         if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1137                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1138                 __tts_config_release_client(uid);
1139                 __tts_config_release_engine();
1140                 tts_parser_unload_config(g_config_info);
1141                 g_config_info = NULL;
1142                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1143         }
1144
1145         if (true == g_config_info->auto_voice) {
1146                 /* Check language with display language */
1147                 __tts_config_set_auto_language();
1148         } else {
1149                 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1150                         /* Default language is not valid */
1151                         char* tmp_language = NULL;
1152                         int tmp_type = -1;
1153                         if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1154                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1155                                 __tts_config_release_client(uid);
1156                                 __tts_config_release_engine();
1157                                 tts_parser_unload_config(g_config_info);
1158                                 g_config_info = NULL;
1159                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1160                         }
1161
1162                         if (NULL != tmp_language) {
1163                                 memset(g_language, '\0', sizeof(g_language));
1164                                 g_config_info->language = g_language;
1165                                 strncpy(g_config_info->language, tmp_language, sizeof(g_language) - 1);
1166
1167                                 g_config_info->type = tmp_type;
1168
1169                                 free(tmp_language);
1170                                 tmp_language = NULL;
1171
1172                                 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1173                                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1174                                         __tts_config_release_client(uid);
1175                                         __tts_config_release_engine();
1176                                         tts_parser_unload_config(g_config_info);
1177                                         g_config_info = NULL;
1178                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1179                                 }
1180                         }
1181                 }
1182         }
1183
1184         /* print daemon config */
1185         SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1186         SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1187         SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1188         SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1189         SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1190         SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1191         SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1192         SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1193         SLOG(LOG_DEBUG, tts_tag(), "=================");
1194
1195         if (0 != __tts_config_mgr_register_config_event()) {
1196                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1197                 __tts_config_release_client(uid);
1198                 __tts_config_release_engine();
1199                 tts_parser_unload_config(g_config_info);
1200                 g_config_info = NULL;
1201                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1202         }
1203
1204         /* Register to detect display language change */
1205         vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1206         vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1207
1208         /* For engine directory monitoring */
1209         //if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1210         //      SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1211         //      __tts_config_release_client(uid);
1212         //      __tts_config_release_engine();
1213         //      tts_parser_unload_config(g_config_info);
1214         //      __tts_config_mgr_unregister_config_event();
1215         //      return TTS_CONFIG_ERROR_OPERATION_FAILED;
1216         //}
1217
1218         return 0;
1219 }
1220
1221 int tts_config_mgr_finalize(int uid)
1222 {
1223         if (0 < __tts_config_release_client(uid)) {
1224                 return 0;
1225         }
1226
1227         tts_config_mgr_unset_callback(uid);
1228
1229         __tts_config_release_engine();
1230
1231         tts_parser_unload_config(g_config_info);
1232         g_config_info = NULL;
1233
1234         __tts_config_mgr_unregister_engine_config_updated_event();
1235
1236         __tts_config_mgr_unregister_config_event();
1237
1238         vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1239         vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1240
1241         return 0;
1242 }
1243
1244 int tts_config_mgr_set_callback(int uid,
1245                                 tts_config_engine_changed_cb engine_cb,
1246                                 tts_config_voice_changed_cb voice_cb,
1247                                 tts_config_speech_rate_changed_cb speech_cb,
1248                                 tts_config_pitch_changed_cb pitch_cb,
1249                                 void* user_data)
1250 {
1251         GSList *iter = NULL;
1252         tts_config_client_s* temp_client = NULL;
1253
1254         /* Call all callbacks of client*/
1255         iter = g_slist_nth(g_config_client_list, 0);
1256
1257         while (NULL != iter) {
1258                 temp_client = iter->data;
1259
1260                 if (NULL != temp_client) {
1261                         if (uid == temp_client->uid) {
1262                                 temp_client->engine_cb = engine_cb;
1263                                 temp_client->voice_cb = voice_cb;
1264                                 temp_client->speech_cb = speech_cb;
1265                                 temp_client->pitch_cb = pitch_cb;
1266                                 temp_client->user_data = user_data;
1267                         }
1268                 }
1269
1270                 iter = g_slist_next(iter);
1271         }
1272         return 0;
1273 }
1274
1275 int tts_config_mgr_unset_callback(int uid)
1276 {
1277         GSList *iter = NULL;
1278         tts_config_client_s* temp_client = NULL;
1279
1280         /* Call all callbacks of client*/
1281         iter = g_slist_nth(g_config_client_list, 0);
1282
1283         while (NULL != iter) {
1284                 temp_client = iter->data;
1285
1286                 if (NULL != temp_client) {
1287                         if (uid == temp_client->uid) {
1288                                 temp_client->engine_cb = NULL;
1289                                 temp_client->voice_cb = NULL;
1290                                 temp_client->speech_cb = NULL;
1291                                 temp_client->pitch_cb = NULL;
1292                                 temp_client->user_data = NULL;
1293                         }
1294                 }
1295
1296                 iter = g_slist_next(iter);
1297         }
1298
1299         return 0;
1300 }
1301
1302 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1303 {
1304         if (NULL == callback) {
1305                 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1306                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1307         }
1308
1309         GSList *iter = NULL;
1310         tts_config_client_s* temp_client = NULL;
1311
1312         /* Call all callbacks of client*/
1313         iter = g_slist_nth(g_config_client_list, 0);
1314
1315         while (NULL != iter) {
1316                 temp_client = iter->data;
1317
1318                 if (NULL != temp_client) {
1319                         if (uid == temp_client->uid) {
1320                                 temp_client->screen_cb = callback;
1321                         }
1322                 }
1323
1324                 iter = g_slist_next(iter);
1325         }
1326         return 0;
1327 }
1328
1329 int tts_config_unset_screen_reader_callback(int uid)
1330 {
1331         GSList *iter = NULL;
1332         tts_config_client_s* temp_client = NULL;
1333
1334         /* Call all callbacks of client*/
1335         iter = g_slist_nth(g_config_client_list, 0);
1336
1337         while (NULL != iter) {
1338                 temp_client = iter->data;
1339
1340                 if (NULL != temp_client) {
1341                         if (uid == temp_client->uid) {
1342                                 temp_client->screen_cb = NULL;
1343                         }
1344                 }
1345
1346                 iter = g_slist_next(iter);
1347         }
1348         return 0;
1349 }
1350
1351
1352 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1353 {
1354         if (0 >= g_slist_length(g_config_client_list)) {
1355                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1356                 return TTS_CONFIG_ERROR_INVALID_STATE;
1357         }
1358
1359         GSList *iter = NULL;
1360         tts_engine_info_s *engine_info = NULL;
1361
1362         if (0 >= g_slist_length(g_engine_list)) {
1363                 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1364                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1365         }
1366
1367         /* Get a first item */
1368         iter = g_slist_nth(g_engine_list, 0);
1369
1370         while (NULL != iter) {
1371                 engine_info = iter->data;
1372
1373                 if (NULL != engine_info) {
1374                         if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1375                                 break;
1376                         }
1377                 }
1378
1379                 iter = g_slist_next(iter);
1380         }
1381
1382         return 0;
1383 }
1384
1385 int tts_config_mgr_get_engine(char** engine)
1386 {
1387         if (0 >= g_slist_length(g_config_client_list)) {
1388                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1389                 return TTS_CONFIG_ERROR_INVALID_STATE;
1390         }
1391
1392         if (NULL == engine) {
1393                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1394                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1395         }
1396
1397         if (NULL != g_config_info->engine_id) {
1398                 /* Check engine id is valid */
1399                 GSList *iter = NULL;
1400                 tts_engine_info_s *engine_info = NULL;
1401
1402                 if (0 >= g_slist_length(g_engine_list)) {
1403                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1404                         return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1405                 }
1406
1407                 /* Get a first item */
1408                 iter = g_slist_nth(g_engine_list, 0);
1409
1410                 while (NULL != iter) {
1411                         engine_info = iter->data;
1412
1413                         if (NULL != engine_info) {
1414                                 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1415                                         *engine = strdup(g_config_info->engine_id);
1416                                         return 0;
1417                                 }
1418                         }
1419                         iter = g_slist_next(iter);
1420                 }
1421
1422                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1423         } else {
1424                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1425         }
1426
1427         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1428 }
1429
1430 int __tts_set_buxtonkey(const char* engine)
1431 {
1432         /* Set vconfkey */
1433         struct buxton_client * bux_cli;
1434         struct buxton_layer * bux_layer;
1435         struct buxton_value * bux_val;
1436
1437         int ret = buxton_open(&bux_cli, NULL, NULL);
1438         if (0 != ret) {
1439                 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_open failed!! (%d)", ret);
1440                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1441         }
1442         bux_layer = buxton_create_layer("system");
1443         if (NULL == bux_layer) {
1444                 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_create_layer FAIL");
1445                 buxton_close(bux_cli);
1446                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1447         }
1448         bux_val = buxton_value_create_string(engine);
1449         if (NULL == bux_val) {
1450                 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_value_create_string FAIL");
1451                 buxton_free_layer(bux_layer);
1452                 buxton_close(bux_cli);
1453                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1454         } else {
1455                 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] layer: %s", buxton_layer_get_name(bux_layer));
1456         }
1457
1458         ret = buxton_set_value_sync(bux_cli, bux_layer, TTS_ENGINE_DB_DEFAULT, bux_val);
1459         if (0 != ret) {
1460                 SLOG(LOG_ERROR, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync failed!! (%d)", ret);
1461                 buxton_value_free(bux_val);
1462                 buxton_free_layer(bux_layer);
1463                 buxton_close(bux_cli);
1464
1465                 bux_cli = NULL;
1466                 bux_layer = NULL;
1467                 bux_val = NULL;
1468
1469                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1470         } else {
1471                 SLOG(LOG_DEBUG, tts_tag(), "[DBUS-BUXTON2] buxton_set_value_sync: %d, %s", ret, TTS_ENGINE_DB_DEFAULT);
1472         }
1473
1474         buxton_value_free(bux_val);
1475         buxton_free_layer(bux_layer);
1476         buxton_close(bux_cli);
1477
1478         bux_cli = NULL;
1479         bux_layer = NULL;
1480         bux_val = NULL;
1481
1482         return TTS_CONFIG_ERROR_NONE;
1483 }
1484
1485 int tts_config_mgr_set_engine(const char* engine)
1486 {
1487         if (0 >= g_slist_length(g_config_client_list)) {
1488                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1489                 return TTS_CONFIG_ERROR_INVALID_STATE;
1490         }
1491
1492         if (NULL == engine)
1493                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1494
1495         /* Check current engine id with new engine id */
1496         if (0 == strcmp(g_config_info->engine_id, engine))
1497                 return 0;
1498
1499         if (0 >= g_slist_length(g_engine_list)) {
1500                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1501                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1502         }
1503
1504         SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1505
1506         int ret = __tts_set_buxtonkey(engine);
1507         if (0 != ret) {
1508                 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] set_buxtonkey Fail!!");
1509                 return ret;
1510         }
1511
1512         GSList *iter = NULL;
1513         tts_engine_info_s *engine_info = NULL;
1514         bool is_valid_engine = false;
1515
1516         /* Get a first item */
1517         iter = g_slist_nth(g_engine_list, 0);
1518
1519         while (NULL != iter) {
1520                 engine_info = iter->data;
1521
1522                 if (NULL == engine_info) {
1523                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1524                         iter = g_slist_next(iter);
1525                         continue;
1526                 }
1527
1528                 /* Check engine id is valid */
1529                 if (0 != strcmp(engine, engine_info->uuid)) {
1530                         iter = g_slist_next(iter);
1531                         continue;
1532                 }
1533
1534                 memset(g_engine_id, '\0', sizeof(g_engine_id));
1535                 g_config_info->engine_id = g_engine_id;
1536                 strncpy(g_config_info->engine_id, engine, sizeof(g_engine_id) - 1);
1537
1538                 if (NULL != engine_info->setting) {
1539                         memset(g_setting, '\0', sizeof(g_setting));
1540                         g_config_info->setting = g_setting;
1541                         strncpy(g_config_info->setting, engine_info->setting, sizeof(g_setting) - 1);
1542                 }
1543
1544                 /* Engine is valid*/
1545                 GSList *iter_voice = NULL;
1546                 tts_config_voice_s* voice = NULL;
1547                 bool is_valid_voice = false;
1548
1549                 /* Get a first item */
1550                 iter_voice = g_slist_nth(engine_info->voices, 0);
1551
1552                 while (NULL != iter_voice) {
1553                         /*Get handle data from list*/
1554                         voice = iter_voice->data;
1555
1556                         if (NULL != voice) {
1557                                 if (NULL == voice->language)
1558                                         continue;
1559                                 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1560
1561                                 if (0 == strcmp(voice->language, g_config_info->language)) {
1562                                         if (voice->type == g_config_info->type) {
1563                                                 /* language is valid */
1564                                                 is_valid_voice = true;
1565                                                 g_config_info->type = voice->type;
1566                                         }
1567                                         break;
1568                                 }
1569                         }
1570
1571                         /*Get next item*/
1572                         iter_voice = g_slist_next(iter_voice);
1573                 }
1574
1575                 if (false == is_valid_voice) {
1576                         memset(g_language, '\0', sizeof(g_language));
1577                         g_config_info->language = g_language;
1578
1579                         iter_voice = g_slist_nth(engine_info->voices, 0);
1580                         if (NULL != iter_voice) {
1581                                 voice = iter_voice->data;
1582                                 if (NULL != voice) {
1583                                         if (NULL != voice->language)
1584                                                 strncpy(g_config_info->language, voice->language, sizeof(g_language) - 1);
1585
1586                                         g_config_info->type = voice->type;
1587                                 }
1588                         }
1589                 }
1590
1591                 is_valid_engine = true;
1592                 break;
1593         }
1594
1595         if (true == is_valid_engine) {
1596                 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1597                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Engine : %s", g_config_info->engine_id);
1598                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Setting : %s", g_config_info->setting);
1599                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Language : %s", g_config_info->language);
1600                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Type : %d", g_config_info->type);
1601
1602                 if (0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1603                         g_config_info->language, g_config_info->type)) {
1604                                 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1605                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1606                 }
1607         } else {
1608                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1609                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1610         }
1611
1612         return 0;
1613 }
1614
1615 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1616 {
1617         if (0 >= g_slist_length(g_config_client_list)) {
1618                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1619                 return TTS_CONFIG_ERROR_INVALID_STATE;
1620         }
1621
1622         if (0 >= g_slist_length(g_engine_list)) {
1623                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1624                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1625         }
1626
1627         GSList *iter = NULL;
1628         tts_engine_info_s *engine_info = NULL;
1629
1630         /* Get a first item */
1631         iter = g_slist_nth(g_engine_list, 0);
1632
1633         while (NULL != iter) {
1634                 engine_info = iter->data;
1635
1636                 if (NULL == engine_info) {
1637                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1638                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1639                 }
1640
1641                 if (0 != strcmp(engine_id, engine_info->uuid)) {
1642                         iter = g_slist_next(iter);
1643                         continue;
1644                 }
1645
1646                 GSList *iter_voice = NULL;
1647                 tts_config_voice_s* voice = NULL;
1648
1649                 /* Get a first item */
1650                 iter_voice = g_slist_nth(engine_info->voices, 0);
1651
1652                 while (NULL != iter_voice) {
1653                         /*Get handle data from list*/
1654                         voice = iter_voice->data;
1655
1656                         SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1657                         if (NULL != voice->language) {
1658                                 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1659                                         break;
1660                         }
1661
1662                         /*Get next item*/
1663                         iter_voice = g_slist_next(iter_voice);
1664                 }
1665                 break;
1666         }
1667
1668         return 0;
1669 }
1670
1671 int tts_config_mgr_get_voice(char** language, int* type)
1672 {
1673         if (0 >= g_slist_length(g_config_client_list)) {
1674                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1675                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1676         }
1677
1678         if (0 >= g_slist_length(g_engine_list)) {
1679                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1680                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1681         }
1682
1683         if (NULL == language || NULL == type)
1684                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1685
1686         if (0 != strlen(g_config_info->language)) {
1687                 *language = strdup(g_config_info->language);
1688                 *type = g_config_info->type;
1689         } else {
1690                 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1691                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1692         }
1693
1694         return 0;
1695 }
1696
1697 int tts_config_mgr_set_voice(const char* language, int type)
1698 {
1699         if (0 >= g_slist_length(g_config_client_list)) {
1700                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1701                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1702         }
1703
1704         if (NULL == language) {
1705                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1706                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1707         }
1708
1709         if (0 >= g_slist_length(g_engine_list)) {
1710                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1711                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1712         }
1713
1714         /* Check language is valid */
1715         if (0 != tts_parser_set_voice(language, type)) {
1716                 SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1717                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1718         }
1719         memset(g_language, '\0', sizeof(g_language));
1720         g_config_info->language = g_language;
1721         strncpy(g_config_info->language, language, sizeof(g_language) - 1);
1722
1723         g_config_info->type = type;
1724
1725         return 0;
1726 }
1727
1728 int tts_config_mgr_get_auto_voice(bool* value)
1729 {
1730         if (0 >= g_slist_length(g_config_client_list)) {
1731                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1732                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1733         }
1734
1735         if (NULL == value)
1736                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1737
1738         *value = g_config_info->auto_voice;
1739
1740         return 0;
1741 }
1742
1743 int tts_config_mgr_set_auto_voice(bool value)
1744 {
1745         if (0 >= g_slist_length(g_config_client_list)) {
1746                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1747                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1748         }
1749
1750         if (g_config_info->auto_voice != value) {
1751                 /* Check language is valid */
1752                 if (0 != tts_parser_set_auto_voice(value)) {
1753                         SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1754                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1755                 }
1756                 g_config_info->auto_voice = value;
1757
1758                 if (true == g_config_info->auto_voice) {
1759                         __tts_config_set_auto_language();
1760                 }
1761         }
1762
1763         return 0;
1764 }
1765
1766 int tts_config_mgr_get_speech_rate(int* value)
1767 {
1768         if (0 >= g_slist_length(g_config_client_list)) {
1769                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1770                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1771         }
1772
1773         if (NULL == value) {
1774                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1775         }
1776
1777         *value = g_config_info->speech_rate;
1778
1779         return 0;
1780 }
1781
1782 int tts_config_mgr_set_speech_rate(int value)
1783 {
1784         if (0 >= g_slist_length(g_config_client_list)) {
1785                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1786                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1787         }
1788
1789         if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1790                 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1791                 if (0 != tts_parser_set_speech_rate(value)) {
1792                         SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1793                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1794                 }
1795
1796                 g_config_info->speech_rate = value;
1797         } else {
1798                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1799         }
1800
1801         return 0;
1802 }
1803
1804 int tts_config_mgr_get_pitch(int* value)
1805 {
1806         if (0 >= g_slist_length(g_config_client_list)) {
1807                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1808                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1809         }
1810
1811         if (NULL == value) {
1812                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1813         }
1814
1815         GSList *iter = NULL;
1816         tts_engine_info_s *engine_info = NULL;
1817
1818         if (0 >= g_slist_length(g_engine_list)) {
1819                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1820                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1821         }
1822
1823         /* Get a first item */
1824         iter = g_slist_nth(g_engine_list, 0);
1825
1826         while (NULL != iter) {
1827                 engine_info = iter->data;
1828
1829                 if (NULL == engine_info) {
1830                         SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1831                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1832                 }
1833
1834                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1835                         iter = g_slist_next(iter);
1836                         continue;
1837                 }
1838
1839                 if (false == engine_info->pitch_support) {
1840                         return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1841                 }  else {
1842                         break;
1843                 }
1844         }
1845
1846         *value = g_config_info->pitch;
1847
1848         return 0;
1849 }
1850
1851 int tts_config_mgr_set_pitch(int value)
1852 {
1853         if (0 >= g_slist_length(g_config_client_list)) {
1854                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1855                 return -1;
1856         }
1857
1858         GSList *iter = NULL;
1859         tts_engine_info_s *engine_info = NULL;
1860
1861         if (0 >= g_slist_length(g_engine_list)) {
1862                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1863                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1864         }
1865
1866         /* Get a first item */
1867         iter = g_slist_nth(g_engine_list, 0);
1868
1869         while (NULL != iter) {
1870                 engine_info = iter->data;
1871
1872                 if (NULL == engine_info) {
1873                         SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1874                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1875                 }
1876
1877                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1878                         iter = g_slist_next(iter);
1879                         continue;
1880                 }
1881
1882                 if (false == engine_info->pitch_support) {
1883                         return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1884                 } else {
1885                         break;
1886                 }
1887         }
1888
1889         if (0 != tts_parser_set_pitch(value)) {
1890                 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1891                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1892         }
1893
1894         g_config_info->pitch = value;
1895
1896         return 0;
1897 }
1898
1899 bool tts_config_check_default_engine_is_valid(const char* engine)
1900 {
1901         if (0 >= g_slist_length(g_config_client_list)) {
1902                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1903                 return -1;
1904         }
1905
1906         if (NULL == engine)
1907                 return false;
1908
1909         if (0 >= g_slist_length(g_engine_list))
1910                 return false;
1911
1912         GSList *iter = NULL;
1913         tts_engine_info_s *engine_info = NULL;
1914
1915         /* Get a first item */
1916         iter = g_slist_nth(g_engine_list, 0);
1917
1918         while (NULL != iter) {
1919                 engine_info = iter->data;
1920
1921                 if (NULL != engine_info) {
1922                         if (0 == strcmp(engine, engine_info->uuid)) {
1923                                 return true;
1924                         }
1925                 }
1926                 iter = g_slist_next(iter);
1927         }
1928
1929         return false;
1930 }
1931
1932 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1933 {
1934         if (0 >= g_slist_length(g_config_client_list)) {
1935                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1936                 return -1;
1937         }
1938
1939         if (NULL == language)
1940                 return false;
1941
1942         if (0 == strlen(g_config_info->engine_id)) {
1943                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1944                 return false;
1945         }
1946
1947         if (0 >= g_slist_length(g_engine_list))
1948                 return false;
1949
1950         GSList *iter = NULL;
1951         tts_engine_info_s *engine_info = NULL;
1952
1953         /* Get a first item */
1954         iter = g_slist_nth(g_engine_list, 0);
1955
1956         while (NULL != iter) {
1957                 engine_info = iter->data;
1958
1959                 if (NULL == engine_info) {
1960                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1961                         iter = g_slist_next(iter);
1962                         continue;
1963                 }
1964
1965                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1966                         iter = g_slist_next(iter);
1967                         continue;
1968                 }
1969
1970                 GSList *iter_voice = NULL;
1971                 tts_config_voice_s* voice = NULL;
1972
1973                 /* Get a first item */
1974                 iter_voice = g_slist_nth(engine_info->voices, 0);
1975
1976                 while (NULL != iter_voice) {
1977                         voice = iter_voice->data;
1978
1979                         if (0 == strcmp(language, voice->language) && voice->type == type)
1980                                 return true;
1981
1982                         /*Get next item*/
1983                         iter_voice = g_slist_next(iter_voice);
1984                 }
1985
1986                 break;
1987         }
1988
1989         return false;
1990 }
1991
1992
1993 int __tts_config_mgr_print_engine_info()
1994 {
1995         GSList *iter = NULL;
1996         tts_engine_info_s *engine_info = NULL;
1997
1998         if (0 >= g_slist_length(g_engine_list)) {
1999                 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
2000                 SLOG(LOG_DEBUG, tts_tag(), "  No Engine in engine directory");
2001                 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
2002                 return 0;
2003         }
2004
2005         /* Get a first item */
2006         iter = g_slist_nth(g_engine_list, 0);
2007
2008         SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
2009
2010         int i = 1;
2011         while (NULL != iter) {
2012                 engine_info = iter->data;
2013
2014                 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
2015                 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
2016                 SLOG(LOG_DEBUG, tts_tag(), " id   : %s", engine_info->uuid);
2017                 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
2018
2019                 SLOG(LOG_DEBUG, tts_tag(), " Voices");
2020                 GSList *iter_voice = NULL;
2021                 tts_config_voice_s* voice = NULL;
2022
2023                 if (g_slist_length(engine_info->voices) > 0) {
2024                         /* Get a first item */
2025                         iter_voice = g_slist_nth(engine_info->voices, 0);
2026
2027                         int j = 1;
2028                         while (NULL != iter_voice) {
2029                                 /*Get handle data from list*/
2030                                 voice = iter_voice->data;
2031
2032                                 SLOG(LOG_DEBUG, tts_tag(), "  [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
2033
2034                                 /*Get next item*/
2035                                 iter_voice = g_slist_next(iter_voice);
2036                                 j++;
2037                         }
2038                 } else {
2039                         SLOG(LOG_ERROR, tts_tag(), "  Voice is NONE");
2040                 }
2041                 iter = g_slist_next(iter);
2042                 i++;
2043         }
2044         SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
2045
2046         return 0;
2047 }
2048
2049 int tts_config_mgr_get_max_text_size(unsigned int* size)
2050 {
2051         if (0 >= g_slist_length(g_config_client_list)) {
2052                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
2053                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2054         }
2055
2056         if (NULL == size) {
2057                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
2058         }
2059
2060         GSList *iter = NULL;
2061         tts_engine_info_s *engine_info = NULL;
2062
2063         if (0 >= g_slist_length(g_engine_list)) {
2064                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
2065                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
2066         }
2067
2068         /* Get a first item */
2069         iter = g_slist_nth(g_engine_list, 0);
2070
2071         while (NULL != iter) {
2072                 engine_info = iter->data;
2073
2074                 if (NULL == engine_info) {
2075                         SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
2076                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
2077                 }
2078
2079                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
2080                         iter = g_slist_next(iter);
2081                         continue;
2082                 }
2083
2084                 break;
2085         }
2086
2087         if (NULL == engine_info) {
2088                 SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
2089                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
2090         }
2091
2092         *size = engine_info->text_size;
2093         SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Max text size is %d.", *size);
2094
2095         return 0;
2096 }
2097