common/tts_config_mgr.c

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