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