common/tts_config_mgr.c

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