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 void __tts_config_speech_rate_key_changed_cb(keynode_t *key, void *data)
 514 {
 515         int ret;
 516         int speech_rate;
 517         ret = vconf_get_int(TTS_ACCESSIBILITY_SPEED_KEY, &speech_rate);
 518
 519         if (0 != ret) {
 520                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get speech rate");
 521                 return;
 522         }
 523
 524         /* Check speech rate is valid */
 525         if (TTS_CONFIG_SPEED_MIN <= speech_rate && speech_rate <= TTS_CONFIG_SPEED_MAX) {
 526                 SLOG(LOG_DEBUG, tts_tag(), "[Config] Speech rate  : %d", speech_rate);
 527
 528                 if (g_config_info->speech_rate != speech_rate) {
 529                         g_config_info->speech_rate = speech_rate;
 530
 531                         tts_parser_set_speech_rate(g_config_info->speech_rate);
 532
 533                         GSList *iter = NULL;
 534                         tts_config_client_s* temp_client = NULL;
 535
 536                         /* Call all callbacks of client*/
 537                         iter = g_slist_nth(g_config_client_list, 0);
 538
 539                         while (NULL != iter) {
 540                                 temp_client = iter->data;
 541
 542                                 if (NULL != temp_client) {
 543                                         if (NULL != temp_client->speech_cb) {
 544                                                 temp_client->speech_cb(g_config_info->speech_rate, temp_client->user_data);
 545                                         }
 546                                 }
 547
 548                                 iter = g_slist_next(iter);
 549                         }
 550                 }
 551         } else {
 552                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is not valid : %d", speech_rate);
 553         }
 554
 555         return;
 556 }
 557
 558 int __tts_config_set_auto_language()
 559 {
 560         char* value = NULL;
 561         value = vconf_get_str(TTS_LANGSET_KEY);
 562         if (NULL == value) {
 563                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get display language");
 564                 return -1;
 565         }
 566
 567         char temp_lang[6] = {'\0', };
 568         strncpy(temp_lang, value, 5);
 569         free(value);
 570
 571         if (true == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, temp_lang, g_config_info->type)) {
 572                 /* tts default voice change */
 573                 if (NULL == g_config_info->language) {
 574                         SLOG(LOG_ERROR, tts_tag(), "Current config language is NULL");
 575                         return -1;
 576                 }
 577
 578                 char* before_lang = NULL;
 579                 int before_type;
 580
 581                 if (0 != tts_parser_set_voice(temp_lang, g_config_info->type)) {
 582                         SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
 583                         return -1;
 584                 }
 585
 586                 before_lang = strdup(g_config_info->language);
 587                 before_type = g_config_info->type;
 588
 589                 free(g_config_info->language);
 590                 g_config_info->language = strdup(temp_lang);
 591
 592                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[Config] Default voice : lang(%s) type(%d)",
 593                         g_config_info->language, g_config_info->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(before_lang, before_type,
 607                                                 g_config_info->language, g_config_info->type,
 608                                                 g_config_info->auto_voice, temp_client->user_data);
 609                                 }
 610                         }
 611
 612                         iter = g_slist_next(iter);
 613                 }
 614
 615                 if (NULL != before_lang) {
 616                         free(before_lang);
 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, tts_tag(), "[ERROR] Fail to select language");
 624                         return -1;
 625                 }
 626
 627                 if (NULL == tmp_language) {
 628                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] language is NULL");
 629                         return -1;
 630                 }
 631
 632                 if (0 != tts_parser_set_voice(tmp_language, tmp_type)) {
 633                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
 634                         return -1;
 635                 }
 636
 637                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[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                 if (NULL != g_config_info->language) {
 660                         free(g_config_info->language);
 661                         g_config_info->language = strdup(tmp_language);
 662                 }
 663
 664                 g_config_info->type = tmp_type;
 665
 666                 free(tmp_language);
 667         }
 668
 669         return 0;
 670 }
 671
 672 void __tts_config_display_language_changed_cb(keynode_t *key, void *data)
 673 {
 674         if (true == g_config_info->auto_voice) {
 675                 __tts_config_set_auto_language();
 676         }
 677
 678         return;
 679 }
 680
 681 void __tts_config_screen_reader_changed_cb(keynode_t *key, void *data)
 682 {
 683         int ret;
 684         int screen_reader;
 685         ret = vconf_get_int(TTS_ACCESSIBILITY_KEY, &screen_reader);
 686         if (0 != ret) {
 687                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 688                 return;
 689         }
 690
 691         GSList *iter = NULL;
 692         tts_config_client_s* temp_client = NULL;
 693
 694         /* Call all callbacks of client*/
 695         iter = g_slist_nth(g_config_client_list, 0);
 696
 697         while (NULL != iter) {
 698                 temp_client = iter->data;
 699
 700                 if (NULL != temp_client) {
 701                         if (NULL != temp_client->screen_cb) {
 702                                 temp_client->screen_cb((bool)screen_reader);
 703                         }
 704                 }
 705
 706                 iter = g_slist_next(iter);
 707         }
 708 }
 709
 710 int __tts_config_release_client(int uid)
 711 {
 712         GSList *iter = NULL;
 713         tts_config_client_s* temp_client = NULL;
 714
 715         if (0 < g_slist_length(g_config_client_list)) {
 716                 /* Check uid */
 717                 iter = g_slist_nth(g_config_client_list, 0);
 718
 719                 while (NULL != iter) {
 720                         temp_client = iter->data;
 721
 722                         if (NULL != temp_client) {
 723                                 if (uid == temp_client->uid) {
 724                                         g_config_client_list = g_slist_remove(g_config_client_list, temp_client);
 725                                         free(temp_client);
 726                                         break;
 727                                 }
 728                         }
 729
 730                         iter = g_slist_next(iter);
 731                 }
 732         }
 733
 734         SLOG(LOG_DEBUG, tts_tag(), "Client count (%d)", g_slist_length(g_config_client_list));
 735
 736         return g_slist_length(g_config_client_list);
 737 }
 738
 739 void __tts_config_release_engine()
 740 {
 741         GSList *iter = NULL;
 742         tts_engine_info_s *engine_info = NULL;
 743
 744         if (0 < g_slist_length(g_engine_list)) {
 745
 746                 /* Get a first item */
 747                 iter = g_slist_nth(g_engine_list, 0);
 748
 749                 while (NULL != iter) {
 750                         engine_info = iter->data;
 751
 752                         if (NULL != engine_info) {
 753                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 754
 755                                 tts_parser_free_engine_info(engine_info);
 756                         }
 757
 758                         iter = g_slist_nth(g_engine_list, 0);
 759                 }
 760         }
 761
 762         return;
 763 }
 764
 765 int __tts_config_mgr_get_engine_info()
 766 {
 767         DIR *dp = NULL;
 768         int ret = -1;
 769         struct dirent entry;
 770         struct dirent *dirp = NULL;
 771
 772         char filepath[512] = {'\0',};
 773         int filesize;
 774         tts_engine_info_s* info = NULL;
 775
 776         g_engine_list = NULL;
 777
 778         /* Get engine info from default engine directory */
 779         dp  = opendir(TTS_DEFAULT_ENGINE_INFO);
 780         if (NULL == dp) {
 781                 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DEFAULT_ENGINE_INFO);
 782         } else {
 783                 do {
 784                         ret = readdir_r(dp, &entry, &dirp);
 785                         if (0 != ret) {
 786                                 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
 787                                 break;
 788                         }
 789
 790                         if (NULL != dirp) {
 791                                 filesize = strlen(TTS_DEFAULT_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 792                                 if (filesize >= 512) {
 793                                         SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 794                                         closedir(dp);
 795                                         return -1;
 796                                 }
 797
 798                                 memset(filepath, '\0', 512);
 799                                 snprintf(filepath, 512, "%s/%s", TTS_DEFAULT_ENGINE_INFO, dirp->d_name);
 800
 801                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
 802
 803                                 if (0 == tts_parser_get_engine_info(filepath, &info)) {
 804                                         g_engine_list = g_slist_append(g_engine_list, info);
 805                                 }
 806                         }
 807                 } while (NULL != dirp);
 808
 809                 closedir(dp);
 810         }
 811
 812         /* Get engine info from downloadable engine directory */
 813         dp  = opendir(TTS_DOWNLOAD_ENGINE_INFO);
 814         if (NULL == dp) {
 815                 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] No downloadable directory : %s", TTS_DOWNLOAD_ENGINE_INFO);
 816         } else {
 817                 do {
 818                         ret = readdir_r(dp, &entry, &dirp);
 819                         if (0 != ret) {
 820                                 SLOG(LOG_ERROR, tts_tag(), "[CONFIG] Fail to read directory");
 821                                 break;
 822                         }
 823
 824                         if (NULL != dirp) {
 825                                 filesize = strlen(TTS_DOWNLOAD_ENGINE_INFO) + strlen(dirp->d_name) + 2;
 826                                 if (filesize >= 512) {
 827                                         SECURE_SLOG(LOG_ERROR, tts_tag(), "[CONFIG ERROR] File path is too long : %s", dirp->d_name);
 828                                         closedir(dp);
 829                                         return -1;
 830                                 }
 831
 832                                 memset(filepath, '\0', 512);
 833                                 snprintf(filepath, 512, "%s/%s", TTS_DOWNLOAD_ENGINE_INFO, dirp->d_name);
 834
 835                                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Filepath(%s)", filepath);
 836
 837                                 if (0 == tts_parser_get_engine_info(filepath, &info)) {
 838                                         /* Compare id */
 839                                         GSList *iter = NULL;
 840                                         tts_engine_info_s *engine_info = NULL;
 841
 842                                         /* Get a first item */
 843                                         iter = g_slist_nth(g_engine_list, 0);
 844
 845                                         while (NULL != iter) {
 846                                                 engine_info = iter->data;
 847
 848                                                 if (NULL != engine_info) {
 849                                                         /* Remove old engine info */
 850                                                         if (0 == strncmp(engine_info->uuid, info->uuid, strlen(engine_info->uuid))) {
 851                                                                 SLOG(LOG_DEBUG, tts_tag(), "[CONFIG] Remove old engine : %s", engine_info->name);
 852                                                                 g_engine_list = g_slist_remove(g_engine_list, engine_info);
 853                                                                 tts_parser_free_engine_info(engine_info);
 854                                                                 break;
 855                                                         }
 856                                                 }
 857                                                 iter = iter->next;
 858                                         }
 859
 860                                         g_engine_list = g_slist_append(g_engine_list, info);
 861                                 }
 862                         }
 863                 } while (NULL != dirp);
 864
 865                 closedir(dp);
 866         }
 867
 868         if (0 >= g_slist_length(g_engine_list)) {
 869                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] No engine");
 870                 return -1;
 871         }
 872
 873         return 0;
 874 }
 875
 876 static Eina_Bool __tts_config_mgr_engine_config_inotify_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 877 {
 878         SLOG(LOG_DEBUG, tts_tag(), "===== Engine config updated callback event");
 879
 880         int length;
 881         struct inotify_event event;
 882         memset(&event, '\0', sizeof(struct inotify_event));
 883
 884         length = read(g_dir_fd, &event, sizeof(struct inotify_event));
 885         if (0 > length) {
 886                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Empty Inotify event");
 887                 SLOG(LOG_DEBUG, tts_tag(), "=====");
 888                 SLOG(LOG_DEBUG, tts_tag(), " ");
 889                 return ECORE_CALLBACK_DONE;
 890         }
 891
 892         if (IN_CLOSE_WRITE == event.mask) {
 893                 int ret = __tts_config_mgr_get_engine_info();
 894                 if (0 != ret) {
 895                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info when config updated");
 896                 }
 897                 __tts_config_mgr_print_engine_info();
 898                 bool support = tts_config_check_default_voice_is_valid(g_config_info->language, g_config_info->type);
 899                 if (false == support) {
 900                         SLOG(LOG_DEBUG, tts_tag(), "[ERROR] Default voice is valid");
 901                         char* temp_lang = NULL;
 902                         int temp_type;
 903                         ret = __tts_config_mgr_select_lang(g_config_info->engine_id, &temp_lang, &temp_type);
 904                         if (0 != ret) {
 905                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get voice");
 906                         }
 907
 908                         ret = tts_config_mgr_set_voice(temp_lang, temp_type);
 909                         if (0 != ret) {
 910                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to set voice");
 911                         } else {
 912                                 SLOG(LOG_DEBUG, tts_tag(), "[DEBUG] Saved default voice : lang(%s), type(%d)", g_config_info->language, g_config_info->type);
 913                         }
 914                         if (NULL != temp_lang)  free(temp_lang);
 915                 }
 916         } else {
 917                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Undefined event");
 918         }
 919
 920         SLOG(LOG_DEBUG, tts_tag(), "=====");
 921         SLOG(LOG_DEBUG, tts_tag(), " ");
 922
 923         return ECORE_CALLBACK_PASS_ON;
 924 }
 925
 926 static int __tts_config_mgr_register_engine_config_updated_event()
 927 {
 928         /* For engine directory monitoring */
 929         g_dir_fd = inotify_init();
 930         if (g_dir_fd < 0) {
 931                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to init inotify");
 932                 return -1;
 933         }
 934
 935         g_dir_wd = inotify_add_watch(g_dir_fd, TTS_OPT_BASE"/engine-info/", IN_CLOSE_WRITE);
 936         if (g_dir_wd < 0) {
 937                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add watch");
 938                 return -1;
 939         }
 940
 941         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);
 942         if (NULL == g_dir_fd_handler) {
 943                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to add fd handler");
 944                 return -1;
 945         }
 946
 947         /* Set non-blocking mode of file */
 948         int value;
 949         value = fcntl(g_dir_fd, F_GETFL, 0);
 950         value |= O_NONBLOCK;
 951
 952         if (0 > fcntl(g_dir_fd, F_SETFL, value)) {
 953                 SLOG(LOG_WARN, tts_tag(), "[WARNING] Fail to set non-block mode");
 954         }
 955
 956         return 0;
 957 }
 958
 959 static int __tts_config_mgr_unregister_engine_config_updated_event()
 960 {
 961         /* delete inotify variable */
 962         ecore_main_fd_handler_del(g_dir_fd_handler);
 963         inotify_rm_watch(g_dir_fd, g_dir_wd);
 964         close(g_dir_fd);
 965
 966         return 0;
 967 }
 968
 969 int tts_config_mgr_initialize(int uid)
 970 {
 971         GSList *iter = NULL;
 972         int* get_uid;
 973         tts_config_client_s* temp_client = NULL;
 974
 975         /* Register uid */
 976         if (0 < g_slist_length(g_config_client_list)) {
 977                 /* Check uid */
 978                 iter = g_slist_nth(g_config_client_list, 0);
 979
 980                 while (NULL != iter) {
 981                         get_uid = iter->data;
 982
 983                         if (uid == *get_uid) {
 984                                 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] uid(%d) has already registered", uid);
 985                                 return 0;
 986                         }
 987
 988                         iter = g_slist_next(iter);
 989                 }
 990
 991                 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
 992                 temp_client->uid = uid;
 993
 994                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
 995
 996                 SECURE_SLOG(LOG_WARN, tts_tag(), "[CONFIG] Add uid(%d) but config has already initialized", uid);
 997                 return 0;
 998         } else {
 999                 temp_client = (tts_config_client_s*)calloc(1, sizeof(tts_config_client_s));
1000                 temp_client->uid = uid;
1001
1002                 g_config_client_list = g_slist_append(g_config_client_list, temp_client);
1003         }
1004
1005         if (0 != __tts_config_mgr_get_engine_info()) {
1006                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get engine info");
1007                 __tts_config_release_client(uid);
1008                 __tts_config_release_engine();
1009                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1010         }
1011
1012         __tts_config_mgr_print_engine_info();
1013
1014         if (0 != tts_parser_load_config(&g_config_info)) {
1015                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to parse configure information");
1016                 __tts_config_release_client(uid);
1017                 __tts_config_release_engine();
1018                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1019         }
1020
1021         /* Check whether engine id is valid */
1022         if (0 != __tts_config_mgr_check_engine_is_valid(g_config_info->engine_id)) {
1023                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to get default engine");
1024                 __tts_config_release_client(uid);
1025                 __tts_config_release_engine();
1026                 tts_parser_unload_config(g_config_info);
1027                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1028         }
1029
1030         if (true == g_config_info->auto_voice) {
1031                 /* Check language with display language */
1032                 __tts_config_set_auto_language();
1033         } else {
1034                 if (false == __tts_config_mgr_check_lang_is_valid(g_config_info->engine_id, g_config_info->language, g_config_info->type)) {
1035                         /* Default language is not valid */
1036                         char* tmp_language = NULL;
1037                         int tmp_type = -1;
1038                         if (0 != __tts_config_mgr_select_lang(g_config_info->engine_id, &tmp_language, &tmp_type)) {
1039                                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to select language");
1040                                 __tts_config_release_client(uid);
1041                                 __tts_config_release_engine();
1042                                 tts_parser_unload_config(g_config_info);
1043                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1044                         }
1045
1046                         if (NULL != tmp_language) {
1047                                 if (NULL != g_config_info->language) {
1048                                         free(g_config_info->language);
1049                                         g_config_info->language = strdup(tmp_language);
1050                                 }
1051
1052                                 g_config_info->type = tmp_type;
1053
1054                                 free(tmp_language);
1055
1056                                 if (0 != tts_parser_set_voice(g_config_info->language, g_config_info->type)) {
1057                                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to save config");
1058                                         __tts_config_release_client(uid);
1059                                         __tts_config_release_engine();
1060                                         tts_parser_unload_config(g_config_info);
1061                                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1062                                 }
1063                         }
1064                 }
1065         }
1066
1067         /* print daemon config */
1068         SLOG(LOG_DEBUG, tts_tag(), "== TTS config ==");
1069         SECURE_SLOG(LOG_DEBUG, tts_tag(), " engine : %s", g_config_info->engine_id);
1070         SECURE_SLOG(LOG_DEBUG, tts_tag(), " setting : %s", g_config_info->setting);
1071         SECURE_SLOG(LOG_DEBUG, tts_tag(), " auto voice : %s", g_config_info->auto_voice ? "on" : "off");
1072         SECURE_SLOG(LOG_DEBUG, tts_tag(), " language : %s", g_config_info->language);
1073         SECURE_SLOG(LOG_DEBUG, tts_tag(), " voice type : %d", g_config_info->type);
1074         SECURE_SLOG(LOG_DEBUG, tts_tag(), " speech rate : %d", g_config_info->speech_rate);
1075         SECURE_SLOG(LOG_DEBUG, tts_tag(), " pitch : %d", g_config_info->pitch);
1076         SLOG(LOG_DEBUG, tts_tag(), "=================");
1077
1078         if (0 != __tts_config_mgr_register_config_event()) {
1079                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register config event");
1080                 __tts_config_release_client(uid);
1081                 __tts_config_release_engine();
1082                 tts_parser_unload_config(g_config_info);
1083                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1084         }
1085
1086         /* Register to detect display language change */
1087         vconf_notify_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb, NULL);
1088         vconf_notify_key_changed(TTS_ACCESSIBILITY_SPEED_KEY, __tts_config_speech_rate_key_changed_cb, NULL);
1089         vconf_notify_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb, NULL);
1090
1091         /* For engine directory monitoring */
1092         if (0 != __tts_config_mgr_register_engine_config_updated_event()) {
1093                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Fail to register engine config updated event");
1094                 __tts_config_release_client(uid);
1095                 __tts_config_release_engine();
1096                 tts_parser_unload_config(g_config_info);
1097                 __tts_config_mgr_unregister_config_event();
1098                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1099         }
1100
1101         return 0;
1102 }
1103
1104 int tts_config_mgr_finalize(int uid)
1105 {
1106         if (0 < __tts_config_release_client(uid)) {
1107                 return 0;
1108         }
1109
1110         __tts_config_release_engine();
1111
1112         tts_parser_unload_config(g_config_info);
1113
1114         __tts_config_mgr_unregister_engine_config_updated_event();
1115
1116         __tts_config_mgr_unregister_config_event();
1117
1118         vconf_ignore_key_changed(TTS_LANGSET_KEY, __tts_config_display_language_changed_cb);
1119         vconf_ignore_key_changed(TTS_ACCESSIBILITY_SPEED_KEY, __tts_config_speech_rate_key_changed_cb);
1120         vconf_ignore_key_changed(TTS_ACCESSIBILITY_KEY, __tts_config_screen_reader_changed_cb);
1121
1122         return 0;
1123 }
1124
1125 int tts_config_mgr_set_callback(int uid,
1126                                 tts_config_engine_changed_cb engine_cb,
1127                                 tts_config_voice_changed_cb voice_cb,
1128                                 tts_config_speech_rate_changed_cb speech_cb,
1129                                 tts_config_pitch_changed_cb pitch_cb,
1130                                 void* user_data)
1131 {
1132         GSList *iter = NULL;
1133         tts_config_client_s* temp_client = NULL;
1134
1135         /* Call all callbacks of client*/
1136         iter = g_slist_nth(g_config_client_list, 0);
1137
1138         while (NULL != iter) {
1139                 temp_client = iter->data;
1140
1141                 if (NULL != temp_client) {
1142                         if (uid == temp_client->uid) {
1143                                 temp_client->engine_cb = engine_cb;
1144                                 temp_client->voice_cb = voice_cb;
1145                                 temp_client->speech_cb = speech_cb;
1146                                 temp_client->pitch_cb = pitch_cb;
1147                                 temp_client->user_data = user_data;
1148                         }
1149                 }
1150
1151                 iter = g_slist_next(iter);
1152         }
1153         return 0;
1154 }
1155
1156 int tts_config_mgr_unset_callback(int uid)
1157 {
1158         GSList *iter = NULL;
1159         tts_config_client_s* temp_client = NULL;
1160
1161         /* Call all callbacks of client*/
1162         iter = g_slist_nth(g_config_client_list, 0);
1163
1164         while (NULL != iter) {
1165                 temp_client = iter->data;
1166
1167                 if (NULL != temp_client) {
1168                         if (uid == temp_client->uid) {
1169                                 temp_client->engine_cb = NULL;
1170                                 temp_client->voice_cb = NULL;
1171                                 temp_client->speech_cb = NULL;
1172                                 temp_client->pitch_cb = NULL;
1173                                 temp_client->user_data = NULL;
1174                         }
1175                 }
1176
1177                 iter = g_slist_next(iter);
1178         }
1179
1180         return 0;
1181 }
1182
1183 int tts_config_set_screen_reader_callback(int uid, tts_config_screen_reader_changed_cb callback)
1184 {
1185         if (NULL == callback) {
1186                 SLOG(LOG_ERROR, tts_tag(), "Input parameter is NULL");
1187                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1188         }
1189
1190         GSList *iter = NULL;
1191         tts_config_client_s* temp_client = NULL;
1192
1193         /* Call all callbacks of client*/
1194         iter = g_slist_nth(g_config_client_list, 0);
1195
1196         while (NULL != iter) {
1197                 temp_client = iter->data;
1198
1199                 if (NULL != temp_client) {
1200                         if (uid == temp_client->uid) {
1201                                 temp_client->screen_cb = callback;
1202                         }
1203                 }
1204
1205                 iter = g_slist_next(iter);
1206         }
1207         return 0;
1208 }
1209
1210 int tts_config_unset_screen_reader_callback(int uid)
1211 {
1212         GSList *iter = NULL;
1213         tts_config_client_s* temp_client = NULL;
1214
1215         /* Call all callbacks of client*/
1216         iter = g_slist_nth(g_config_client_list, 0);
1217
1218         while (NULL != iter) {
1219                 temp_client = iter->data;
1220
1221                 if (NULL != temp_client) {
1222                         if (uid == temp_client->uid) {
1223                                 temp_client->screen_cb = NULL;
1224                         }
1225                 }
1226
1227                 iter = g_slist_next(iter);
1228         }
1229         return 0;
1230 }
1231
1232
1233 int tts_config_mgr_get_engine_list(tts_config_supported_engine_cb callback, void* user_data)
1234 {
1235         if (0 >= g_slist_length(g_config_client_list)) {
1236                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1237                 return TTS_CONFIG_ERROR_INVALID_STATE;
1238         }
1239
1240         GSList *iter = NULL;
1241         tts_engine_info_s *engine_info = NULL;
1242
1243         if (0 >= g_slist_length(g_engine_list)) {
1244                 SLOG(LOG_ERROR, tts_tag(), "There is no engine!!");
1245                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1246         }
1247
1248         /* Get a first item */
1249         iter = g_slist_nth(g_engine_list, 0);
1250
1251         while (NULL != iter) {
1252                 engine_info = iter->data;
1253
1254                 if (NULL != engine_info) {
1255                         if (false == callback(engine_info->uuid, engine_info->name, engine_info->setting, user_data)) {
1256                                 break;
1257                         }
1258                 }
1259
1260                 iter = g_slist_next(iter);
1261         }
1262
1263         return 0;
1264 }
1265
1266 int tts_config_mgr_get_engine(char** engine)
1267 {
1268         if (0 >= g_slist_length(g_config_client_list)) {
1269                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1270                 return TTS_CONFIG_ERROR_INVALID_STATE;
1271         }
1272
1273         if (NULL == engine) {
1274                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1275                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1276         }
1277
1278         if (NULL != g_config_info->engine_id) {
1279                 /* Check engine id is valid */
1280                 GSList *iter = NULL;
1281                 tts_engine_info_s *engine_info = NULL;
1282
1283                 if (0 >= g_slist_length(g_engine_list)) {
1284                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1285                         return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1286                 }
1287
1288                 /* Get a first item */
1289                 iter = g_slist_nth(g_engine_list, 0);
1290
1291                 while (NULL != iter) {
1292                         engine_info = iter->data;
1293
1294                         if (NULL != engine_info) {
1295                                 if (0 == strcmp(engine_info->uuid, g_config_info->engine_id)) {
1296                                         *engine = strdup(g_config_info->engine_id);
1297                                         return 0;
1298                                 }
1299                         }
1300                         iter = g_slist_next(iter);
1301                 }
1302
1303                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Current engine id is not valid");
1304         } else {
1305                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is NULL");
1306         }
1307
1308         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1309 }
1310
1311 int tts_config_mgr_set_engine(const char* engine)
1312 {
1313         if (0 >= g_slist_length(g_config_client_list)) {
1314                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1315                 return TTS_CONFIG_ERROR_INVALID_STATE;
1316         }
1317
1318         if (NULL == engine)
1319                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1320
1321         /* Check current engine id with new engine id */
1322         if (0 == strcmp(g_config_info->engine_id, engine))
1323                 return 0;
1324
1325         if (0 >= g_slist_length(g_engine_list)) {
1326                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1327                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1328         }
1329
1330         SLOG(LOG_DEBUG, tts_tag(), "New engine id : %s", engine);
1331
1332         GSList *iter = NULL;
1333         tts_engine_info_s *engine_info = NULL;
1334         bool is_valid_engine = false;
1335
1336         /* Get a first item */
1337         iter = g_slist_nth(g_engine_list, 0);
1338
1339         while (NULL != iter) {
1340                 engine_info = iter->data;
1341
1342                 if (NULL == engine_info) {
1343                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1344                         iter = g_slist_next(iter);
1345                         continue;
1346                 }
1347
1348                 /* Check engine id is valid */
1349                 if (0 != strcmp(engine, engine_info->uuid)) {
1350                         iter = g_slist_next(iter);
1351                         continue;
1352                 }
1353
1354                 if (NULL != g_config_info->engine_id)
1355                         free(g_config_info->engine_id);
1356
1357                 g_config_info->engine_id = strdup(engine);
1358
1359                 if (NULL != g_config_info->setting)
1360                         free(g_config_info->setting);
1361
1362                 if (NULL != engine_info->setting)
1363                         g_config_info->setting = strdup(engine_info->setting);
1364
1365                 /* Engine is valid*/
1366                 GSList *iter_voice = NULL;
1367                 tts_config_voice_s* voice = NULL;
1368                 bool is_valid_voice = false;
1369
1370                 /* Get a first item */
1371                 iter_voice = g_slist_nth(engine_info->voices, 0);
1372
1373                 while (NULL != iter_voice) {
1374                         /*Get handle data from list*/
1375                         voice = iter_voice->data;
1376
1377                         if (NULL != voice) {
1378                                 if (NULL == voice->language)
1379                                         continue;
1380                                 SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1381
1382                                 if (0 == strcmp(voice->language, g_config_info->language)) {
1383                                         if (voice->type == g_config_info->type) {
1384                                                 /* language is valid */
1385                                                 is_valid_voice = true;
1386
1387                                                 if (NULL != g_config_info->language) {
1388                                                         free(g_config_info->language);
1389
1390                                                         g_config_info->language = strdup(voice->language);
1391                                                         g_config_info->type = voice->type;
1392                                                 }
1393                                         }
1394                                         break;
1395                                 }
1396                         }
1397
1398                         /*Get next item*/
1399                         iter_voice = g_slist_next(iter_voice);
1400                 }
1401
1402                 if (false == is_valid_voice) {
1403                         if (NULL != g_config_info->language) {
1404                                 free(g_config_info->language);
1405
1406                                 iter_voice = g_slist_nth(engine_info->voices, 0);
1407                                 if (NULL != iter_voice) {
1408                                         voice = iter_voice->data;
1409                                         if (NULL != voice) {
1410                                                 if (NULL != voice->language)
1411                                                         g_config_info->language = strdup(voice->language);
1412                                                 g_config_info->type = voice->type;
1413                                         }
1414                                 }
1415                         }
1416                 }
1417
1418                 is_valid_engine = true;
1419                 break;
1420         }
1421
1422         if (true == is_valid_engine) {
1423                 SLOG(LOG_DEBUG, tts_tag(), "[Config] Engine changed");
1424                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Engine : %s", g_config_info->engine_id);
1425                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Setting : %s", g_config_info->setting);
1426                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Language : %s", g_config_info->language);
1427                 SECURE_SLOG(LOG_DEBUG, tts_tag(), "  Type : %d", g_config_info->type);
1428
1429                 if ( 0 != tts_parser_set_engine(g_config_info->engine_id, g_config_info->setting,
1430                         g_config_info->language, g_config_info->type)) {
1431                                 SLOG(LOG_ERROR, tts_tag(), " Fail to save config");
1432                                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1433                 }
1434         } else {
1435                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine id is not valid");
1436                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1437         }
1438
1439         return 0;
1440 }
1441
1442 int tts_config_mgr_get_voice_list(const char* engine_id, tts_config_supported_voice_cb callback, void* user_data)
1443 {
1444         if (0 >= g_slist_length(g_config_client_list)) {
1445                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1446                 return TTS_CONFIG_ERROR_INVALID_STATE;
1447         }
1448
1449         if (0 >= g_slist_length(g_engine_list)) {
1450                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1451                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1452         }
1453
1454         GSList *iter = NULL;
1455         tts_engine_info_s *engine_info = NULL;
1456
1457         /* Get a first item */
1458         iter = g_slist_nth(g_engine_list, 0);
1459
1460         while (NULL != iter) {
1461                 engine_info = iter->data;
1462
1463                 if (NULL == engine_info) {
1464                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] engine info is NULL");
1465                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1466                 }
1467
1468                 if (0 != strcmp(engine_id, engine_info->uuid)) {
1469                         iter = g_slist_next(iter);
1470                         continue;
1471                 }
1472
1473                 GSList *iter_voice = NULL;
1474                 tts_config_voice_s* voice = NULL;
1475
1476                 /* Get a first item */
1477                 iter_voice = g_slist_nth(engine_info->voices, 0);
1478
1479                 while (NULL != iter_voice) {
1480                         /*Get handle data from list*/
1481                         voice = iter_voice->data;
1482
1483                         SLOG(LOG_DEBUG, tts_tag(), " lang(%s) type(%d)", voice->language, voice->type);
1484                         if (NULL != voice->language) {
1485                                 if (false == callback(engine_info->uuid, voice->language, voice->type, user_data))
1486                                         break;
1487                         }
1488
1489                         /*Get next item*/
1490                         iter_voice = g_slist_next(iter_voice);
1491                 }
1492                 break;
1493         }
1494
1495         return 0;
1496 }
1497
1498 int tts_config_mgr_get_voice(char** language, int* type)
1499 {
1500         if (0 >= g_slist_length(g_config_client_list)) {
1501                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1502                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1503         }
1504
1505         if (0 >= g_slist_length(g_engine_list)) {
1506                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1507                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1508         }
1509
1510         if (NULL == language || NULL == type)
1511                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1512
1513         if (NULL != g_config_info->language) {
1514                 *language = strdup(g_config_info->language);
1515                 *type = g_config_info->type;
1516         } else {
1517                 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1518                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1519         }
1520
1521         return 0;
1522 }
1523
1524 int tts_config_mgr_set_voice(const char* language, int type)
1525 {
1526         if (0 >= g_slist_length(g_config_client_list)) {
1527                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1528                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1529         }
1530
1531         if (NULL == language) {
1532                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Input parameter is NULL");
1533                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1534         }
1535
1536         if (0 >= g_slist_length(g_engine_list)) {
1537                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine");
1538                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1539         }
1540
1541         /* Check language is valid */
1542         if (NULL != g_config_info->language) {
1543                 if (0 != tts_parser_set_voice(language, type)) {
1544                         SLOG(LOG_ERROR, tts_tag(), "Fail to save default voice");
1545                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1546                 }
1547                 free(g_config_info->language);
1548                 g_config_info->language = strdup(language);
1549                 g_config_info->type = type;
1550
1551         } else {
1552                 SLOG(LOG_ERROR, tts_tag(), "language is NULL");
1553                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1554         }
1555
1556         return 0;
1557 }
1558
1559 int tts_config_mgr_get_auto_voice(bool* value)
1560 {
1561         if (0 >= g_slist_length(g_config_client_list)) {
1562                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1563                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1564         }
1565
1566         if (NULL == value)
1567                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1568
1569         *value = g_config_info->auto_voice;
1570
1571         return 0;
1572 }
1573
1574 int tts_config_mgr_set_auto_voice(bool value)
1575 {
1576         if (0 >= g_slist_length(g_config_client_list)) {
1577                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1578                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1579         }
1580
1581         if (g_config_info->auto_voice != value) {
1582                 /* Check language is valid */
1583                 if (0 != tts_parser_set_auto_voice(value)) {
1584                         SLOG(LOG_ERROR, tts_tag(), "Fail to save auto voice option");
1585                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1586                 }
1587                 g_config_info->auto_voice = value;
1588
1589                 if (true == g_config_info->auto_voice) {
1590                         __tts_config_set_auto_language();
1591                 }
1592         }
1593
1594         return 0;
1595 }
1596
1597 int tts_config_mgr_get_speech_rate(int* value)
1598 {
1599         if (0 >= g_slist_length(g_config_client_list)) {
1600                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1601                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1602         }
1603
1604         if (NULL == value) {
1605                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1606         }
1607
1608         *value = g_config_info->speech_rate;
1609
1610         return 0;
1611 }
1612
1613 int tts_config_mgr_set_speech_rate(int value)
1614 {
1615         if (0 >= g_slist_length(g_config_client_list)) {
1616                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1617                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1618         }
1619
1620         if (TTS_CONFIG_SPEED_MIN <= value && value <= TTS_CONFIG_SPEED_MAX) {
1621                 SLOG(LOG_DEBUG, tts_tag(), "[Config] Set speech rate : %d", value);
1622                 if (0 != tts_parser_set_speech_rate(value)) {
1623                         SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1624                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1625                 }
1626
1627                 g_config_info->speech_rate = value;
1628
1629                 vconf_set_int(TTS_ACCESSIBILITY_SPEED_KEY, value);
1630         } else {
1631                 SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Speech rate is invalid : %d", value);
1632         }
1633
1634         return 0;
1635 }
1636
1637 int tts_config_mgr_get_pitch(int* value)
1638 {
1639         if (0 >= g_slist_length(g_config_client_list)) {
1640                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1641                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1642         }
1643
1644         if (NULL == value) {
1645                 return TTS_CONFIG_ERROR_INVALID_PARAMETER;
1646         }
1647
1648         GSList *iter = NULL;
1649         tts_engine_info_s *engine_info = NULL;
1650
1651         if (0 >= g_slist_length(g_engine_list)) {
1652                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1653                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1654         }
1655
1656         /* Get a first item */
1657         iter = g_slist_nth(g_engine_list, 0);
1658
1659         while (NULL != iter) {
1660                 engine_info = iter->data;
1661
1662                 if (NULL == engine_info) {
1663                         SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1664                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1665                 }
1666
1667                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1668                         iter = g_slist_next(iter);
1669                         continue;
1670                 }
1671
1672                 if (false == engine_info->pitch_support) {
1673                         return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1674                 }  else {
1675                         break;
1676                 }
1677         }
1678
1679         *value = g_config_info->pitch;
1680
1681         return 0;
1682 }
1683
1684 int tts_config_mgr_set_pitch(int value)
1685 {
1686         if (0 >= g_slist_length(g_config_client_list)) {
1687                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1688                 return -1;
1689         }
1690
1691         GSList *iter = NULL;
1692         tts_engine_info_s *engine_info = NULL;
1693
1694         if (0 >= g_slist_length(g_engine_list)) {
1695                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] There is no engine!!");
1696                 return TTS_CONFIG_ERROR_ENGINE_NOT_FOUND;
1697         }
1698
1699         /* Get a first item */
1700         iter = g_slist_nth(g_engine_list, 0);
1701
1702         while (NULL != iter) {
1703                 engine_info = iter->data;
1704
1705                 if (NULL == engine_info) {
1706                         SLOG(LOG_ERROR, tts_tag(), "engine info is NULL");
1707                         return TTS_CONFIG_ERROR_OPERATION_FAILED;
1708                 }
1709
1710                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1711                         iter = g_slist_next(iter);
1712                         continue;
1713                 }
1714
1715                 if (false == engine_info->pitch_support) {
1716                         return TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE;
1717                 } else {
1718                         break;
1719                 }
1720         }
1721
1722         if (0 != tts_parser_set_pitch(value)) {
1723                 SLOG(LOG_ERROR, tts_tag(), "Fail to save speech rate");
1724                 return TTS_CONFIG_ERROR_OPERATION_FAILED;
1725         }
1726
1727         g_config_info->pitch = value;
1728
1729         return 0;
1730 }
1731
1732 bool tts_config_check_default_engine_is_valid(const char* engine)
1733 {
1734         if (0 >= g_slist_length(g_config_client_list)) {
1735                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1736                 return -1;
1737         }
1738
1739         if (NULL == engine)
1740                 return false;
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                         if (0 == strcmp(engine, engine_info->uuid)) {
1756                                 return true;
1757                         }
1758                 }
1759                 iter = g_slist_next(iter);
1760         }
1761
1762         return false;
1763 }
1764
1765 bool tts_config_check_default_voice_is_valid(const char* language, int type)
1766 {
1767         if (0 >= g_slist_length(g_config_client_list)) {
1768                 SLOG(LOG_ERROR, tts_tag(), "Not initialized");
1769                 return -1;
1770         }
1771
1772         if (NULL == language)
1773                 return false;
1774
1775         if (NULL == g_config_info->engine_id) {
1776                 SLOG(LOG_ERROR, tts_tag(), "[ERROR] Default engine id is NULL");
1777                 return false;
1778         }
1779
1780         if (0 >= g_slist_length(g_engine_list))
1781                 return false;
1782
1783         GSList *iter = NULL;
1784         tts_engine_info_s *engine_info = NULL;
1785
1786         /* Get a first item */
1787         iter = g_slist_nth(g_engine_list, 0);
1788
1789         while (NULL != iter) {
1790                 engine_info = iter->data;
1791
1792                 if (NULL == engine_info) {
1793                         SLOG(LOG_ERROR, tts_tag(), "[ERROR] Engine info is NULL");
1794                         iter = g_slist_next(iter);
1795                         continue;
1796                 }
1797
1798                 if (0 != strcmp(g_config_info->engine_id, engine_info->uuid)) {
1799                         iter = g_slist_next(iter);
1800                         continue;
1801                 }
1802
1803                 GSList *iter_voice = NULL;
1804                 tts_config_voice_s* voice = NULL;
1805
1806                 /* Get a first item */
1807                 iter_voice = g_slist_nth(engine_info->voices, 0);
1808
1809                 while (NULL != iter_voice) {
1810                         voice = iter_voice->data;
1811
1812                         if (0 == strcmp(language, voice->language) && voice->type == type)
1813                                 return true;
1814
1815                         /*Get next item*/
1816                         iter_voice = g_slist_next(iter_voice);
1817                 }
1818
1819                 break;
1820         }
1821
1822         return false;
1823 }
1824
1825
1826 int __tts_config_mgr_print_engine_info()
1827 {
1828         GSList *iter = NULL;
1829         tts_engine_info_s *engine_info = NULL;
1830
1831         if (0 >= g_slist_length(g_engine_list)) {
1832                 SLOG(LOG_DEBUG, tts_tag(), "-------------- engine list -----------------");
1833                 SLOG(LOG_DEBUG, tts_tag(), "  No Engine in engine directory");
1834                 SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1835                 return 0;
1836         }
1837
1838         /* Get a first item */
1839         iter = g_slist_nth(g_engine_list, 0);
1840
1841         SLOG(LOG_DEBUG, tts_tag(), "--------------- engine list -----------------");
1842
1843         int i = 1;
1844         while (NULL != iter) {
1845                 engine_info = iter->data;
1846
1847                 SLOG(LOG_DEBUG, tts_tag(), "[%dth]", i);
1848                 SLOG(LOG_DEBUG, tts_tag(), " name : %s", engine_info->name);
1849                 SLOG(LOG_DEBUG, tts_tag(), " id   : %s", engine_info->uuid);
1850                 SLOG(LOG_DEBUG, tts_tag(), " setting : %s", engine_info->setting);
1851
1852                 SLOG(LOG_DEBUG, tts_tag(), " Voices");
1853                 GSList *iter_voice = NULL;
1854                 tts_config_voice_s* voice = NULL;
1855
1856                 if (g_slist_length(engine_info->voices) > 0) {
1857                         /* Get a first item */
1858                         iter_voice = g_slist_nth(engine_info->voices, 0);
1859
1860                         int j = 1;
1861                         while (NULL != iter_voice) {
1862                                 /*Get handle data from list*/
1863                                 voice = iter_voice->data;
1864
1865                                 SLOG(LOG_DEBUG, tts_tag(), "  [%dth] lang(%s) type(%d)", j, voice->language, voice->type);
1866
1867                                 /*Get next item*/
1868                                 iter_voice = g_slist_next(iter_voice);
1869                                 j++;
1870                         }
1871                 } else {
1872                         SLOG(LOG_ERROR, tts_tag(), "  Voice is NONE");
1873                 }
1874                 iter = g_slist_next(iter);
1875                 i++;
1876         }
1877         SLOG(LOG_DEBUG, tts_tag(), "--------------------------------------------");
1878
1879         return 0;
1880 }
1881
1882 char* tts_config_get_message_path(int mode, int pid)
1883 {
1884         char* path = NULL;
1885         path = calloc(128, sizeof(char));
1886
1887         switch(mode) {
1888         case 0: snprintf(path, 128, "%s%s_%d", MESSAGE_FILE_PATH_ROOT, MESSAGE_FILE_PREFIX_DEFAULT, pid);       break;
1889         case 1: snprintf(path, 128, "%s%s_%d", MESSAGE_FILE_PATH_ROOT, MESSAGE_FILE_PREFIX_NOTIFICATION, pid);  break;
1890         case 2: snprintf(path, 128, "%s%s_%d", MESSAGE_FILE_PATH_ROOT, MESSAGE_FILE_PREFIX_SCREEN_READER, pid); break;
1891         default:
1892                 if (NULL != path)       free(path);
1893                 SLOG(LOG_ERROR, tts_tag(), "[Config] Invalid mode (%d)", mode);
1894                 return NULL;
1895         }
1896
1897         return path;
1898 }