common/tts_config_mgr.c

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