client/tts.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 <Ecore.h>
  16 #include <iconv.h>
  17 #include <sys/stat.h>
  18 #include <sys/types.h>
  19 #include <sys/wait.h>
  20 #include <system_info.h>
  21 #include <vconf.h>
  22
  23 #include "tts.h"
  24 #include "tts_client.h"
  25 #include "tts_config_mgr.h"
  26 #include "tts_dbus.h"
  27 #include "tts_main.h"
  28
  29
  30 static Ecore_Timer* g_connect_timer = NULL;
  31
  32 static bool g_screen_reader;
  33
  34 static int g_feature_enabled = -1;
  35
  36 /* Function definition */
  37 static Eina_Bool __tts_notify_state_changed(void *data);
  38 static Eina_Bool __tts_notify_error(void *data);
  39
  40 const char* tts_tag()
  41 {
  42         return "ttsc";
  43 }
  44
  45 static int __tts_get_feature_enabled()
  46 {
  47         if (0 == g_feature_enabled) {
  48                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  49                 return TTS_ERROR_NOT_SUPPORTED;
  50         } else if (-1 == g_feature_enabled) {
  51                 bool tts_supported = false;
  52                 if (0 == system_info_get_platform_bool(TTS_FEATURE_PATH, &tts_supported)) {
  53                         if (false == tts_supported) {
  54                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] TTS feature NOT supported");
  55                                 g_feature_enabled = 0;
  56                                 return TTS_ERROR_NOT_SUPPORTED;
  57                         }
  58
  59                         g_feature_enabled = 1;
  60                 } else {
  61                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get feature value");
  62                         return TTS_ERROR_NOT_SUPPORTED;
  63                 }
  64         }
  65
  66         return 0;
  67 }
  68
  69 static const char* __tts_get_error_code(tts_error_e err)
  70 {
  71         switch (err) {
  72         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
  73         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
  74         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
  75         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
  76         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
  77         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
  78         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
  79         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
  80         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
  81         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
  82         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
  83         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
  84         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
  85         default:
  86                 return "Invalid error code";
  87         }
  88         return NULL;
  89 }
  90
  91 static int __tts_convert_config_error_code(tts_config_error_e code)
  92 {
  93         if (code == TTS_CONFIG_ERROR_NONE)                      return TTS_ERROR_NONE;
  94         if (code == TTS_CONFIG_ERROR_OUT_OF_MEMORY)             return TTS_ERROR_OUT_OF_MEMORY;
  95         if (code == TTS_CONFIG_ERROR_IO_ERROR)                  return TTS_ERROR_IO_ERROR;
  96         if (code == TTS_CONFIG_ERROR_INVALID_PARAMETER)         return TTS_ERROR_INVALID_PARAMETER;
  97         if (code == TTS_CONFIG_ERROR_INVALID_STATE)             return TTS_ERROR_INVALID_STATE;
  98         if (code == TTS_CONFIG_ERROR_INVALID_VOICE)             return TTS_ERROR_INVALID_VOICE;
  99         if (code == TTS_CONFIG_ERROR_ENGINE_NOT_FOUND)          return TTS_ERROR_ENGINE_NOT_FOUND;
 100         if (code == TTS_CONFIG_ERROR_OPERATION_FAILED)          return TTS_ERROR_OPERATION_FAILED;
 101         if (code == TTS_CONFIG_ERROR_NOT_SUPPORTED_FEATURE)     return TTS_ERROR_OPERATION_FAILED;
 102
 103         return code;
 104 }
 105
 106 void __tts_config_voice_changed_cb(const char* before_lang, int before_voice_type, const char* language, int voice_type, bool auto_voice, void* user_data)
 107 {
 108         SLOG(LOG_DEBUG, TAG_TTSC, "Voice changed : Before lang(%s) type(%d) , Current lang(%s), type(%d)",
 109                 before_lang, before_voice_type, language, voice_type);
 110
 111         GList* client_list = NULL;
 112         client_list = tts_client_get_client_list();
 113
 114         GList *iter = NULL;
 115         tts_client_s *data = NULL;
 116
 117         if (g_list_length(client_list) > 0) {
 118                 /* Get a first item */
 119                 iter = g_list_first(client_list);
 120
 121                 while (NULL != iter) {
 122                         data = iter->data;
 123                         if (NULL != data->default_voice_changed_cb) {
 124                                 SLOG(LOG_DEBUG, TAG_TTSC, "Call default voice changed callback : uid(%d)", data->uid);
 125                                 data->default_voice_changed_cb(data->tts, before_lang, before_voice_type,
 126                                         language, voice_type, data->default_voice_changed_user_data);
 127                         }
 128
 129                         /* Next item */
 130                         iter = g_list_next(iter);
 131                 }
 132         }
 133
 134         return;
 135 }
 136
 137 int tts_create(tts_h* tts)
 138 {
 139         if (0 != __tts_get_feature_enabled()) {
 140                 return TTS_ERROR_NOT_SUPPORTED;
 141         }
 142
 143         SLOG(LOG_DEBUG, TAG_TTSC, "===== Create TTS");
 144
 145         /* check param */
 146         if (NULL == tts) {
 147                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 148                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 149                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 150                 return TTS_ERROR_INVALID_PARAMETER;
 151         }
 152
 153         if (0 == tts_client_get_size()) {
 154                 if (0 != tts_dbus_open_connection()) {
 155                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open dbus connection");
 156                         return TTS_ERROR_OPERATION_FAILED;
 157                 }
 158         }
 159
 160         if (0 != tts_client_new(tts)) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create client!!!!!");
 162                 return TTS_ERROR_OUT_OF_MEMORY;
 163         }
 164
 165         tts_client_s* client = tts_client_get(*tts);
 166         if (NULL == client) {
 167                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client");
 168                 return TTS_ERROR_OPERATION_FAILED;
 169         }
 170
 171         int ret = tts_config_mgr_initialize(client->uid);
 172         if (0 != ret) {
 173                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init config manager : %d", ret);
 174                 tts_client_destroy(*tts);
 175                 return __tts_convert_config_error_code(ret);
 176         }
 177
 178         ret = tts_config_mgr_set_callback(client->uid, NULL, __tts_config_voice_changed_cb, NULL, NULL, NULL);
 179         if (0 != ret) {
 180                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set config changed : %d", ret);
 181                 tts_client_destroy(*tts);
 182                 return __tts_convert_config_error_code(ret);
 183         }
 184
 185         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 186         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 187
 188         return TTS_ERROR_NONE;
 189 }
 190
 191 int tts_destroy(tts_h tts)
 192 {
 193         if (0 != __tts_get_feature_enabled()) {
 194                 return TTS_ERROR_NOT_SUPPORTED;
 195         }
 196
 197         SLOG(LOG_DEBUG, TAG_TTSC, "===== Destroy TTS");
 198
 199         if (NULL == tts) {
 200                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 201                 return TTS_ERROR_INVALID_PARAMETER;
 202         }
 203
 204         tts_client_s* client = tts_client_get(tts);
 205
 206         /* check handle */
 207         if (NULL == client) {
 208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 209                 return TTS_ERROR_INVALID_PARAMETER;
 210         }
 211
 212         /* check used callback */
 213         if (0 != tts_client_get_use_callback(client)) {
 214                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot destroy in Callback function");
 215                 return TTS_ERROR_OPERATION_FAILED;
 216         }
 217
 218         tts_config_mgr_finalize(client->uid);
 219
 220         int ret = -1;
 221         int count = 0;
 222
 223         /* check state */
 224         switch (client->current_state) {
 225         case TTS_STATE_PAUSED:
 226         case TTS_STATE_PLAYING:
 227         case TTS_STATE_READY:
 228                 if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 229                         while (0 != ret) {
 230                                 ret = tts_dbus_request_finalize(client->uid);
 231                                 if (0 != ret) {
 232                                         if (TTS_ERROR_TIMED_OUT != ret) {
 233                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 234                                                 break;
 235                                         } else {
 236                                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize");
 237                                                 usleep(10000);
 238                                                 count++;
 239                                                 if (TTS_RETRY_COUNT == count) {
 240                                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 241                                                         break;
 242                                                 }
 243                                         }
 244                                 }
 245                         }
 246                 } else {
 247                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 248                 }
 249
 250                 client->before_state = client->current_state;
 251                 client->current_state = TTS_STATE_CREATED;
 252
 253         case TTS_STATE_CREATED:
 254                 if (NULL != g_connect_timer) {
 255                         SLOG(LOG_DEBUG, TAG_TTSC, "Connect Timer is deleted");
 256                         ecore_timer_del(g_connect_timer);
 257                 }
 258                 /* Free resources */
 259                 tts_client_destroy(tts);
 260                 break;
 261
 262         default:
 263                 break;
 264         }
 265
 266         if (0 == tts_client_get_size()) {
 267                 if (0 != tts_dbus_close_connection()) {
 268                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to close connection");
 269                 }
 270         }
 271
 272         tts = NULL;
 273
 274         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 275         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 276
 277         return TTS_ERROR_NONE;
 278 }
 279
 280 void __tts_screen_reader_changed_cb(bool value)
 281 {
 282         g_screen_reader = value;
 283 }
 284
 285 int tts_set_mode(tts_h tts, tts_mode_e mode)
 286 {
 287         if (0 != __tts_get_feature_enabled()) {
 288                 return TTS_ERROR_NOT_SUPPORTED;
 289         }
 290
 291         SLOG(LOG_DEBUG, TAG_TTSC, "===== Set TTS mode");
 292
 293         tts_client_s* client = tts_client_get(tts);
 294
 295         /* check handle */
 296         if (NULL == client) {
 297                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 298                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 299                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 300                 return TTS_ERROR_INVALID_PARAMETER;
 301         }
 302
 303         /* check state */
 304         if (client->current_state != TTS_STATE_CREATED) {
 305                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 306                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 307                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 308                 return TTS_ERROR_INVALID_STATE;
 309         }
 310
 311         if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
 312                 client->mode = mode;
 313         } else {
 314                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
 315                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 316                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 317                 return TTS_ERROR_INVALID_PARAMETER;
 318         }
 319
 320         if (TTS_MODE_SCREEN_READER == mode) {
 321                 int ret;
 322                 int screen_reader;
 323                 ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 324                 if (0 != ret) {
 325                         SLOG(LOG_ERROR, tts_tag(), "[Config ERROR] Fail to get screen reader");
 326                         return TTS_ERROR_OPERATION_FAILED;
 327                 }
 328                 g_screen_reader = (bool)screen_reader;
 329                 tts_config_set_screen_reader_callback(client->uid, __tts_screen_reader_changed_cb);
 330         } else {
 331                 tts_config_unset_screen_reader_callback(client->uid);
 332         }
 333
 334         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 335         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 336
 337         return TTS_ERROR_NONE;
 338 }
 339
 340 int tts_get_mode(tts_h tts, tts_mode_e* mode)
 341 {
 342         if (0 != __tts_get_feature_enabled()) {
 343                 return TTS_ERROR_NOT_SUPPORTED;
 344         }
 345
 346         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
 347
 348         tts_client_s* client = tts_client_get(tts);
 349
 350         /* check handle */
 351         if (NULL == client) {
 352                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 353                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 354                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 355                 return TTS_ERROR_INVALID_PARAMETER;
 356         }
 357
 358         /* check state */
 359         if (client->current_state != TTS_STATE_CREATED) {
 360                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 361                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 362                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 363                 return TTS_ERROR_INVALID_STATE;
 364         }
 365
 366         if (NULL == mode) {
 367                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter(mode) is NULL");
 368                 return TTS_ERROR_INVALID_PARAMETER;
 369         }
 370
 371         *mode = client->mode;
 372
 373         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 374         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 375
 376         return TTS_ERROR_NONE;
 377 }
 378
 379 static Eina_Bool __tts_connect_daemon(void *data)
 380 {
 381         tts_h tts = (tts_h)data;
 382         tts_client_s* client = tts_client_get(tts);
 383
 384         /* check handle */
 385         if (NULL == client) {
 386                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 387                 g_connect_timer = NULL;
 388                 return EINA_FALSE;
 389         }
 390
 391         /* Send hello */
 392         if (0 != tts_dbus_request_hello(client->uid)) {
 393                 return EINA_TRUE;
 394         }
 395
 396         SLOG(LOG_DEBUG, TAG_TTSC, "===== Connect daemon");
 397
 398         /* do request initialize */
 399         int ret = -1;
 400         ret = tts_dbus_request_initialize(client->uid);
 401
 402         if (TTS_ERROR_ENGINE_NOT_FOUND == ret) {
 403                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
 404
 405                 client->reason = TTS_ERROR_ENGINE_NOT_FOUND;
 406                 client->utt_id = -1;
 407
 408                 ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
 409                 g_connect_timer = NULL;
 410                 return EINA_FALSE;
 411
 412         } else if (TTS_ERROR_NONE != ret) {
 413                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
 414                 return EINA_TRUE;
 415
 416         } else {
 417                 /* success to connect tts-daemon */
 418         }
 419
 420         g_connect_timer = NULL;
 421
 422         client = tts_client_get(tts);
 423         /* check handle */
 424         if (NULL == client) {
 425                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 426                 return EINA_FALSE;
 427         }
 428
 429         client->before_state = client->current_state;
 430         client->current_state = TTS_STATE_READY;
 431
 432         if (NULL != client->state_changed_cb) {
 433                 tts_client_use_callback(client);
 434                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 435                 tts_client_not_use_callback(client);
 436         } else {
 437                 SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
 438         }
 439
 440         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 441         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 442
 443         return EINA_FALSE;
 444 }
 445
 446 int tts_prepare(tts_h tts)
 447 {
 448         if (0 != __tts_get_feature_enabled()) {
 449                 return TTS_ERROR_NOT_SUPPORTED;
 450         }
 451
 452         SLOG(LOG_DEBUG, TAG_TTSC, "===== Prepare TTS");
 453
 454         tts_client_s* client = tts_client_get(tts);
 455
 456         /* check handle */
 457         if (NULL == client) {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 459                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 460                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 461                 return TTS_ERROR_INVALID_PARAMETER;
 462         }
 463
 464         /* check state */
 465         if (client->current_state != TTS_STATE_CREATED) {
 466                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
 467                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 468                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 469                 return TTS_ERROR_INVALID_STATE;
 470         }
 471
 472         g_connect_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
 473
 474         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 475         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 476
 477         return TTS_ERROR_NONE;
 478 }
 479
 480 int tts_unprepare(tts_h tts)
 481 {
 482         if (0 != __tts_get_feature_enabled()) {
 483                 return TTS_ERROR_NOT_SUPPORTED;
 484         }
 485
 486         SLOG(LOG_DEBUG, TAG_TTSC, "===== Unprepare TTS");
 487
 488         tts_client_s* client = tts_client_get(tts);
 489
 490         /* check handle */
 491         if (NULL == client) {
 492                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
 493                 return TTS_ERROR_INVALID_PARAMETER;
 494         }
 495
 496         /* check state */
 497         if (client->current_state != TTS_STATE_READY) {
 498                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'READY'");
 499                 return TTS_ERROR_INVALID_STATE;
 500         }
 501
 502         int ret = -1;
 503         int count = 0;
 504         if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
 505                 while (0 != ret) {
 506                         ret = tts_dbus_request_finalize(client->uid);
 507                         if (0 != ret) {
 508                                 if (TTS_ERROR_TIMED_OUT != ret) {
 509                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 510                                         break;
 511                                 } else {
 512                                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry finalize : %s", __tts_get_error_code(ret));
 513                                         usleep(10000);
 514                                         count++;
 515                                         if (TTS_RETRY_COUNT == count) {
 516                                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 517                                                 break;
 518                                         }
 519                                 }
 520                         }
 521                 }
 522         } else {
 523                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize : g_sr(%d) mode(%d)", g_screen_reader, client->mode);
 524         }
 525
 526         client->before_state = client->current_state;
 527         client->current_state = TTS_STATE_CREATED;
 528
 529         if (NULL != client->state_changed_cb) {
 530                 tts_client_use_callback(client);
 531                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 532                 tts_client_not_use_callback(client);
 533                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 534         }
 535
 536         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 537         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 538
 539         return TTS_ERROR_NONE;
 540 }
 541
 542 bool __tts_supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 543 {
 544         tts_h tts = (tts_h)user_data;
 545
 546         tts_client_s* client = tts_client_get(tts);
 547         if (NULL == client) {
 548                 SLOG(LOG_ERROR, TAG_TTSC, "[WARNING] A handle is not valid");
 549                 return false;
 550         }
 551
 552         /* call callback function */
 553         if (NULL != client->supported_voice_cb) {
 554                 return client->supported_voice_cb(tts, language, type, client->supported_voice_user_data);
 555         } else {
 556                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of supported voice");
 557         }
 558
 559         return false;
 560 }
 561
 562 int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, void* user_data)
 563 {
 564         if (0 != __tts_get_feature_enabled()) {
 565                 return TTS_ERROR_NOT_SUPPORTED;
 566         }
 567
 568         SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
 569
 570         if (NULL == tts || NULL == callback) {
 571                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 572                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 573                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 574                 return TTS_ERROR_INVALID_PARAMETER;
 575         }
 576
 577         tts_client_s* client = tts_client_get(tts);
 578
 579         /* check handle */
 580         if (NULL == client) {
 581                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 582                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 583                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 584                 return TTS_ERROR_INVALID_PARAMETER;
 585         }
 586
 587         int ret = 0;
 588         char* current_engine = NULL;
 589         ret = tts_config_mgr_get_engine(&current_engine);
 590         if (0 != ret) {
 591                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get current engine : %d", ret);
 592                 return __tts_convert_config_error_code(ret);
 593         }
 594
 595         client->supported_voice_cb = callback;
 596         client->supported_voice_user_data = user_data;
 597
 598         ret = tts_config_mgr_get_voice_list(current_engine, __tts_supported_voice_cb, client->tts);
 599
 600         if (NULL != current_engine)
 601                 free(current_engine);
 602
 603         client->supported_voice_cb = NULL;
 604         client->supported_voice_user_data = NULL;
 605
 606         if (0 != ret) {
 607                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Result : %d", ret);
 608                 ret = TTS_ERROR_OPERATION_FAILED;
 609         }
 610
 611         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 612         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 613
 614         return ret;
 615 }
 616
 617 int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 618 {
 619         if (0 != __tts_get_feature_enabled()) {
 620                 return TTS_ERROR_NOT_SUPPORTED;
 621         }
 622
 623         SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
 624
 625         if (NULL == tts) {
 626                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 627                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 628                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 629                 return TTS_ERROR_INVALID_PARAMETER;
 630
 631         }
 632         tts_client_s* client = tts_client_get(tts);
 633
 634         if (NULL == client) {
 635                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 636                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 637                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 638                 return TTS_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         /* Request call remote method */
 642         int ret = 0;
 643         ret = tts_config_mgr_get_voice(lang, vctype);
 644         if (0 != ret) {
 645                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %d", ret);
 646                 return __tts_convert_config_error_code(ret);
 647         } else {
 648                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
 649         }
 650
 651         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 652         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 653
 654         return ret;
 655 }
 656
 657 int tts_get_max_text_size(tts_h tts, unsigned int* size)
 658 {
 659         if (0 != __tts_get_feature_enabled()) {
 660                 return TTS_ERROR_NOT_SUPPORTED;
 661         }
 662
 663         if (NULL == tts || NULL == size) {
 664                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Input parameter is null");
 665                 return TTS_ERROR_INVALID_PARAMETER;
 666         }
 667
 668         tts_client_s* client = tts_client_get(tts);
 669
 670         if (NULL == client) {
 671                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : A handle is not valid");
 672                 return TTS_ERROR_INVALID_PARAMETER;
 673         }
 674
 675         if (TTS_STATE_READY != client->current_state) {
 676                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get max text count : Current state is NOT 'READY'.");
 677                 return TTS_ERROR_INVALID_STATE;
 678         }
 679
 680         *size = TTS_MAX_TEXT_SIZE;
 681
 682         SLOG(LOG_DEBUG, TAG_TTSC, "Get max text count : %d", *size);
 683         return TTS_ERROR_NONE;
 684 }
 685
 686 int tts_get_state(tts_h tts, tts_state_e* state)
 687 {
 688         if (0 != __tts_get_feature_enabled()) {
 689                 return TTS_ERROR_NOT_SUPPORTED;
 690         }
 691
 692         if (NULL == tts || NULL == state) {
 693                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : Input parameter is null");
 694                 return TTS_ERROR_INVALID_PARAMETER;
 695         }
 696
 697         tts_client_s* client = tts_client_get(tts);
 698
 699         if (NULL == client) {
 700                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 701                 return TTS_ERROR_INVALID_PARAMETER;
 702         }
 703
 704         *state = client->current_state;
 705
 706         switch (*state) {
 707                 case TTS_STATE_CREATED: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Created'");        break;
 708                 case TTS_STATE_READY:   SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Ready'");          break;
 709                 case TTS_STATE_PLAYING: SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Playing'");        break;
 710                 case TTS_STATE_PAUSED:  SLOG(LOG_DEBUG, TAG_TTSC, "Current state is 'Paused'");         break;
 711                 default:                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid value");             break;
 712         }
 713
 714         return TTS_ERROR_NONE;
 715 }
 716
 717 int tts_get_speed_range(tts_h tts, int* min, int* normal, int* max)
 718 {
 719         if (0 != __tts_get_feature_enabled()) {
 720                 return TTS_ERROR_NOT_SUPPORTED;
 721         }
 722
 723         if (NULL == tts || NULL == min || NULL == normal || NULL == max) {
 724                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 725                 return TTS_ERROR_INVALID_PARAMETER;
 726         }
 727
 728         tts_client_s* client = tts_client_get(tts);
 729
 730         if (NULL == client) {
 731                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get state : A handle is not valid");
 732                 return TTS_ERROR_INVALID_PARAMETER;
 733         }
 734
 735         *min = TTS_SPEED_MIN;
 736         *normal = TTS_SPEED_NORMAL;
 737         *max = TTS_SPEED_MAX;
 738
 739         return TTS_ERROR_NONE;
 740 }
 741
 742 int tts_add_text(tts_h tts, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 743 {
 744         if (0 != __tts_get_feature_enabled()) {
 745                 return TTS_ERROR_NOT_SUPPORTED;
 746         }
 747
 748         if( speed < 0 ) {
 749                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Speed should not be negative(%d)", speed);
 750                 return TTS_ERROR_INVALID_PARAMETER;
 751         }
 752
 753         if( voice_type < 0 ) {
 754                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Voice type should not be negative(%d)", voice_type);
 755                 return TTS_ERROR_INVALID_PARAMETER;
 756         }
 757
 758         SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
 759
 760         if (NULL == tts || NULL == utt_id) {
 761                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
 762                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 763                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 764                 return TTS_ERROR_INVALID_PARAMETER;
 765         }
 766
 767         tts_client_s* client = tts_client_get(tts);
 768
 769         if (NULL == client) {
 770                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 771                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 772                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 773                 return TTS_ERROR_INVALID_PARAMETER;
 774         }
 775
 776         if (TTS_STATE_CREATED == client->current_state) {
 777                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 778                 return TTS_ERROR_INVALID_STATE;
 779         }
 780
 781         if (TTS_MAX_TEXT_SIZE < strlen(text) || strlen(text) <= 0) {
 782                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 783                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 784                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 785                 return TTS_ERROR_INVALID_PARAMETER;
 786         }
 787
 788         if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
 789                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
 790                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 791                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 792                 return TTS_ERROR_INVALID_PARAMETER;
 793         }
 794
 795         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 796                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 797                 return TTS_ERROR_INVALID_STATE;
 798         }
 799
 800         /* check valid utf8 */
 801         iconv_t *ict;
 802         ict = iconv_open("utf-8", "");
 803         if ((iconv_t)-1 == ict) {
 804                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to init for text check");
 805                 return TTS_ERROR_OPERATION_FAILED;
 806         }
 807
 808         size_t len = strlen(text);
 809         char *in_tmp = NULL;
 810         char in_buf[TTS_MAX_TEXT_SIZE];
 811         char *out_tmp = NULL;
 812         char out_buf[TTS_MAX_TEXT_SIZE];
 813         size_t len_tmp = sizeof(out_buf);
 814
 815         memset(in_buf, 0, TTS_MAX_TEXT_SIZE);
 816         snprintf(in_buf, TTS_MAX_TEXT_SIZE, "%s", text);
 817         in_tmp = in_buf;
 818
 819         memset(out_buf, 0, TTS_MAX_TEXT_SIZE);
 820         out_tmp = out_buf;
 821
 822         size_t st;
 823         st = iconv(ict, &in_tmp, &len, &out_tmp, &len_tmp);
 824         if ((size_t)-1 == st) {
 825                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", in_buf);
 826                 iconv_close(ict);
 827                 return TTS_ERROR_INVALID_PARAMETER;
 828         }
 829         iconv_close(ict);
 830         SLOG(LOG_DEBUG, TAG_TTSC, "Text is valid - Converted text is '%s'", out_buf);
 831
 832         /* change default language value */
 833         char* temp = NULL;
 834
 835         if (NULL == language)
 836                 temp = strdup("default");
 837         else
 838                 temp = strdup(language);
 839
 840         client->current_utt_id++;
 841         if (client->current_utt_id == 10000) {
 842                 client->current_utt_id = 1;
 843         }
 844
 845         /* do request */
 846         int ret = -1;
 847         int count = 0;
 848         while (0 != ret) {
 849                 ret = tts_dbus_request_add_text(client->uid, out_buf, temp, voice_type, speed, client->current_utt_id);
 850                 if (0 != ret) {
 851                         if (TTS_ERROR_TIMED_OUT != ret) {
 852                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 853                                 break;
 854                         } else {
 855                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add text : %s", __tts_get_error_code(ret));
 856                                 usleep(10000);
 857                                 count++;
 858                                 if (TTS_RETRY_COUNT == count) {
 859                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 860                                         break;
 861                                 }
 862                         }
 863                 } else {
 864                         *utt_id = client->current_utt_id;
 865                 }
 866         }
 867
 868         if (NULL != temp)       free(temp);
 869
 870         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 871         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 872
 873         return ret;
 874 }
 875
 876 int tts_play(tts_h tts)
 877 {
 878         if (0 != __tts_get_feature_enabled()) {
 879                 return TTS_ERROR_NOT_SUPPORTED;
 880         }
 881
 882         SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
 883
 884         if (NULL == tts) {
 885                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
 886                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 887                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 888                 return TTS_ERROR_INVALID_PARAMETER;
 889         }
 890
 891         tts_client_s* client = tts_client_get(tts);
 892
 893         if (NULL == client) {
 894                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
 895                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 896                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 897                 return TTS_ERROR_INVALID_PARAMETER;
 898         }
 899
 900         if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
 901                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
 902                 return TTS_ERROR_INVALID_STATE;
 903         }
 904
 905         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 906                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 907                 return TTS_ERROR_INVALID_STATE;
 908         }
 909
 910         int ret = -1;
 911         int count = 0;
 912         while (0 != ret) {
 913                 ret = tts_dbus_request_play(client->uid);
 914                 if (0 != ret) {
 915                         if (TTS_ERROR_TIMED_OUT != ret) {
 916                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 917                                 return ret;
 918                         } else {
 919                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play : %s", __tts_get_error_code(ret));
 920                                 usleep(10000);
 921                                 count++;
 922                                 if (TTS_RETRY_COUNT == count) {
 923                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 924                                         return ret;
 925                                 }
 926                         }
 927                 }
 928         }
 929
 930         client->before_state = client->current_state;
 931         client->current_state = TTS_STATE_PLAYING;
 932
 933         if (NULL != client->state_changed_cb) {
 934                 tts_client_use_callback(client);
 935                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
 936                 tts_client_not_use_callback(client);
 937                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
 938         }
 939
 940         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 941         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 942
 943         return TTS_ERROR_NONE;
 944 }
 945
 946
 947 int tts_stop(tts_h tts)
 948 {
 949         if (0 != __tts_get_feature_enabled()) {
 950                 return TTS_ERROR_NOT_SUPPORTED;
 951         }
 952
 953         SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
 954
 955         if (NULL == tts) {
 956                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
 957                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 958                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 959                 return TTS_ERROR_INVALID_PARAMETER;
 960         }
 961
 962         tts_client_s* client = tts_client_get(tts);
 963
 964         if (NULL == client) {
 965                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
 966                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 967                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 968                 return TTS_ERROR_INVALID_PARAMETER;
 969         }
 970
 971         if (TTS_STATE_CREATED == client->current_state) {
 972                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Current state is 'CREATED'.");
 973                 return TTS_ERROR_INVALID_STATE;
 974         }
 975
 976         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
 977                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
 978                 return TTS_ERROR_INVALID_STATE;
 979         }
 980
 981         int ret = -1;
 982         int count = 0;
 983         while (0 != ret) {
 984                 ret = tts_dbus_request_stop(client->uid);
 985                 if (0 != ret) {
 986                         if (TTS_ERROR_TIMED_OUT != ret) {
 987                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
 988                                 return ret;
 989                         } else {
 990                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop : %s", __tts_get_error_code(ret));
 991                                 usleep(10000);
 992                                 count++;
 993                                 if (TTS_RETRY_COUNT == count) {
 994                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 995                                         return ret;
 996                                 }
 997                         }
 998                 }
 999         }
1000
1001         client->before_state = client->current_state;
1002         client->current_state = TTS_STATE_READY;
1003
1004         if (NULL != client->state_changed_cb) {
1005                 tts_client_use_callback(client);
1006                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1007                 tts_client_not_use_callback(client);
1008                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1009         }
1010
1011         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1012         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1013
1014         return TTS_ERROR_NONE;
1015 }
1016
1017
1018 int tts_pause(tts_h tts)
1019 {
1020         if (0 != __tts_get_feature_enabled()) {
1021                 return TTS_ERROR_NOT_SUPPORTED;
1022         }
1023
1024         SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
1025
1026         if (NULL == tts) {
1027                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
1028                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1029                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1030                 return TTS_ERROR_INVALID_PARAMETER;
1031         }
1032
1033         tts_client_s* client = tts_client_get(tts);
1034
1035         if (NULL == client) {
1036                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
1037                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1038                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1039                 return TTS_ERROR_INVALID_PARAMETER;
1040         }
1041
1042         if (TTS_STATE_PLAYING != client->current_state) {
1043                 SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
1044                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1045                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
1046                 return TTS_ERROR_INVALID_STATE;
1047         }
1048
1049         if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
1050                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
1051                 return TTS_ERROR_INVALID_STATE;
1052         }
1053
1054         int ret = -1;
1055         int count = 0;
1056         while (0 != ret) {
1057                 ret = tts_dbus_request_pause(client->uid);
1058                 if (0 != ret) {
1059                         if (TTS_ERROR_TIMED_OUT != ret) {
1060                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
1061                                 return ret;
1062                         } else {
1063                                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry pause : %s", __tts_get_error_code(ret));
1064                                 usleep(10000);
1065                                 count++;
1066                                 if (TTS_RETRY_COUNT == count) {
1067                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1068                                         return ret;
1069                                 }
1070                         }
1071                 }
1072         }
1073
1074         client->before_state = client->current_state;
1075         client->current_state = TTS_STATE_PAUSED;
1076
1077         if (NULL != client->state_changed_cb) {
1078                 tts_client_use_callback(client);
1079                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1080                 tts_client_not_use_callback(client);
1081                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
1082         }
1083
1084         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
1085         SLOG(LOG_DEBUG, TAG_TTSC, " ");
1086
1087         return TTS_ERROR_NONE;
1088 }
1089
1090 static Eina_Bool __tts_notify_error(void *data)
1091 {
1092         tts_h tts = (tts_h)data;
1093
1094         tts_client_s* client = tts_client_get(tts);
1095
1096         /* check handle */
1097         if (NULL == client) {
1098                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify error msg : A handle is not valid");
1099                 return EINA_FALSE;
1100         }
1101
1102         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : uttid(%d) reason(%s)", client->utt_id, __tts_get_error_code(client->reason));
1103
1104         if (NULL != client->error_cb) {
1105                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of error");
1106                 tts_client_use_callback(client);
1107                 client->error_cb(client->tts, client->utt_id, client->reason, client->error_user_data);
1108                 tts_client_not_use_callback(client);
1109         } else {
1110                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1111         }
1112
1113         return EINA_FALSE;
1114 }
1115
1116 int __tts_cb_error(int uid, tts_error_e reason, int utt_id)
1117 {
1118         tts_client_s* client = tts_client_get_by_uid(uid);
1119
1120         if (NULL == client) {
1121                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1122                 return TTS_ERROR_INVALID_PARAMETER;
1123         }
1124
1125         client->utt_id = utt_id;
1126         client->reason = reason;
1127
1128         /* call callback function */
1129         if (NULL != client->error_cb) {
1130                 ecore_timer_add(0, __tts_notify_error, client->tts);
1131         } else {
1132                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of error ");
1133         }
1134
1135         return 0;
1136 }
1137
1138 static Eina_Bool __tts_notify_state_changed(void *data)
1139 {
1140         tts_h tts = (tts_h)data;
1141
1142         tts_client_s* client = tts_client_get(tts);
1143
1144         /* check handle */
1145         if (NULL == client) {
1146                 SLOG(LOG_WARN, TAG_TTSC, "Fail to notify state changed : A handle is not valid");
1147                 return EINA_FALSE;
1148         }
1149
1150         if (NULL != client->state_changed_cb) {
1151                 tts_client_use_callback(client);
1152                 client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
1153                 tts_client_not_use_callback(client);
1154                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called : pre(%d) cur(%d)", client->before_state, client->current_state);
1155         } else {
1156                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1157         }
1158
1159         return EINA_FALSE;
1160 }
1161
1162 int __tts_cb_set_state(int uid, int state)
1163 {
1164         tts_client_s* client = tts_client_get_by_uid(uid);
1165         if (NULL == client) {
1166                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] The handle is not valid");
1167                 return -1;
1168         }
1169
1170         tts_state_e state_from_daemon = (tts_state_e)state;
1171
1172         if (client->current_state == state_from_daemon) {
1173                 SLOG(LOG_DEBUG, TAG_TTSC, "Current state has already been %d", client->current_state);
1174                 return 0;
1175         }
1176
1177         if (NULL != client->state_changed_cb) {
1178                 ecore_timer_add(0, __tts_notify_state_changed, client->tts);
1179         } else {
1180                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] State changed callback is null");
1181         }
1182
1183         client->before_state = client->current_state;
1184         client->current_state = state_from_daemon;
1185
1186         return 0;
1187 }
1188
1189 int __tts_cb_utt_started(int uid, int utt_id)
1190 {
1191         tts_client_s* client = tts_client_get_by_uid(uid);
1192
1193         if (NULL == client) {
1194                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1195                 return TTS_ERROR_INVALID_PARAMETER;
1196         }
1197
1198         SLOG(LOG_DEBUG, TAG_TTSC, "utterance started : utt id(%d) ", utt_id);
1199
1200         client->utt_id = utt_id;
1201
1202         /* call callback function */
1203         if (NULL != client->utt_started_cb) {
1204                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance started ");
1205                 tts_client_use_callback(client);
1206                 client->utt_started_cb(client->tts, client->utt_id, client->utt_started_user_data);
1207                 tts_client_not_use_callback(client);
1208         } else {
1209                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance started ");
1210         }
1211
1212         return 0;
1213 }
1214
1215 int __tts_cb_utt_completed(int uid, int utt_id)
1216 {
1217         tts_client_s* client = tts_client_get_by_uid(uid);
1218
1219         if (NULL == client) {
1220                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] A handle is not valid");
1221                 return TTS_ERROR_INVALID_PARAMETER;
1222         }
1223
1224         SLOG(LOG_DEBUG, TAG_TTSC, "utterance completed : uttid(%d) ", utt_id);
1225
1226         client->utt_id = utt_id;
1227
1228         /* call callback function */
1229         if (NULL != client->utt_completeted_cb) {
1230                 SLOG(LOG_DEBUG, TAG_TTSC, "Call callback function of utterance completed ");
1231                 tts_client_use_callback(client);
1232                 client->utt_completeted_cb(client->tts, client->utt_id, client->utt_completed_user_data);
1233                 tts_client_not_use_callback(client);
1234         } else {
1235                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback function of utterance completed ");
1236         }
1237
1238         return 0;
1239 }
1240
1241 int tts_set_state_changed_cb(tts_h tts, tts_state_changed_cb callback, void* user_data)
1242 {
1243         if (0 != __tts_get_feature_enabled()) {
1244                 return TTS_ERROR_NOT_SUPPORTED;
1245         }
1246
1247         if (NULL == tts || NULL == callback) {
1248                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Input parameter is null");
1249                 return TTS_ERROR_INVALID_PARAMETER;
1250         }
1251
1252         tts_client_s* client = tts_client_get(tts);
1253
1254         if (NULL == client) {
1255                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : A handle is not valid");
1256                 return TTS_ERROR_INVALID_PARAMETER;
1257         }
1258
1259         if (TTS_STATE_CREATED != client->current_state) {
1260                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set state changed cb : Current state is not 'Created'.");
1261                 return TTS_ERROR_INVALID_STATE;
1262         }
1263
1264         client->state_changed_cb = callback;
1265         client->state_changed_user_data = user_data;
1266
1267         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set state changed cb");
1268
1269         return 0;
1270 }
1271
1272 int tts_unset_state_changed_cb(tts_h tts)
1273 {
1274         if (0 != __tts_get_feature_enabled()) {
1275                 return TTS_ERROR_NOT_SUPPORTED;
1276         }
1277
1278         if (NULL == tts) {
1279                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Input parameter is null");
1280                 return TTS_ERROR_INVALID_PARAMETER;
1281         }
1282
1283         tts_client_s* client = tts_client_get(tts);
1284
1285         if (NULL == client) {
1286                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : A handle is not valid");
1287                 return TTS_ERROR_INVALID_PARAMETER;
1288         }
1289
1290         if (TTS_STATE_CREATED != client->current_state) {
1291                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset state changed cb : Current state is not 'Created'.");
1292                 return TTS_ERROR_INVALID_STATE;
1293         }
1294
1295         client->state_changed_cb = NULL;
1296         client->state_changed_user_data = NULL;
1297
1298         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset state changed cb");
1299
1300         return 0;
1301 }
1302
1303 int tts_set_utterance_started_cb(tts_h tts, tts_utterance_started_cb callback, void* user_data)
1304 {
1305         if (0 != __tts_get_feature_enabled()) {
1306                 return TTS_ERROR_NOT_SUPPORTED;
1307         }
1308
1309         if (NULL == tts || NULL == callback) {
1310                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Input parameter is null");
1311                 return TTS_ERROR_INVALID_PARAMETER;
1312         }
1313
1314         tts_client_s* client = tts_client_get(tts);
1315
1316         if (NULL == client) {
1317                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : A handle is not valid");
1318                 return TTS_ERROR_INVALID_PARAMETER;
1319         }
1320
1321         if (TTS_STATE_CREATED != client->current_state) {
1322                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt started cb : Current state is not 'Created'.");
1323                 return TTS_ERROR_INVALID_STATE;
1324         }
1325
1326         client->utt_started_cb = callback;
1327         client->utt_started_user_data = user_data;
1328
1329         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt started cb");
1330
1331         return 0;
1332 }
1333
1334 int tts_unset_utterance_started_cb(tts_h tts)
1335 {
1336         if (0 != __tts_get_feature_enabled()) {
1337                 return TTS_ERROR_NOT_SUPPORTED;
1338         }
1339
1340         if (NULL == tts) {
1341                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Input parameter is null");
1342                 return TTS_ERROR_INVALID_PARAMETER;
1343         }
1344
1345         tts_client_s* client = tts_client_get(tts);
1346
1347         if (NULL == client) {
1348                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : A handle is not valid");
1349                 return TTS_ERROR_INVALID_PARAMETER;
1350         }
1351
1352         if (TTS_STATE_CREATED != client->current_state) {
1353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt started cb : Current state is not 'Created'.");
1354                 return TTS_ERROR_INVALID_STATE;
1355         }
1356
1357         client->utt_started_cb = NULL;
1358         client->utt_started_user_data = NULL;
1359
1360         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt started cb");
1361
1362         return 0;
1363 }
1364
1365 int tts_set_utterance_completed_cb(tts_h tts, tts_utterance_completed_cb callback, void* user_data)
1366 {
1367         if (0 != __tts_get_feature_enabled()) {
1368                 return TTS_ERROR_NOT_SUPPORTED;
1369         }
1370
1371         if (NULL == tts || NULL == callback) {
1372                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Input parameter is null");
1373                 return TTS_ERROR_INVALID_PARAMETER;
1374         }
1375
1376         tts_client_s* client = tts_client_get(tts);
1377
1378         if (NULL == client) {
1379                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : A handle is not valid");
1380                 return TTS_ERROR_INVALID_PARAMETER;
1381         }
1382
1383         if (TTS_STATE_CREATED != client->current_state) {
1384                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set utt completed cb : Current state is not 'Created'.");
1385                 return TTS_ERROR_INVALID_STATE;
1386         }
1387
1388         client->utt_completeted_cb = callback;
1389         client->utt_completed_user_data = user_data;
1390
1391         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set utt completed cb");
1392
1393         return 0;
1394 }
1395
1396 int tts_unset_utterance_completed_cb(tts_h tts)
1397 {
1398         if (0 != __tts_get_feature_enabled()) {
1399                 return TTS_ERROR_NOT_SUPPORTED;
1400         }
1401
1402         if (NULL == tts) {
1403                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Input parameter is null");
1404                 return TTS_ERROR_INVALID_PARAMETER;
1405         }
1406
1407         tts_client_s* client = tts_client_get(tts);
1408
1409         if (NULL == client) {
1410                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : A handle is not valid");
1411                 return TTS_ERROR_INVALID_PARAMETER;
1412         }
1413
1414         if (TTS_STATE_CREATED != client->current_state) {
1415                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset utt completed cb : Current state is not 'Created'.");
1416                 return TTS_ERROR_INVALID_STATE;
1417         }
1418
1419         client->utt_completeted_cb = NULL;
1420         client->utt_completed_user_data = NULL;
1421
1422         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset utt completed cb");
1423         return 0;
1424 }
1425
1426 int tts_set_error_cb(tts_h tts, tts_error_cb callback, void* user_data)
1427 {
1428         if (0 != __tts_get_feature_enabled()) {
1429                 return TTS_ERROR_NOT_SUPPORTED;
1430         }
1431
1432         if (NULL == tts || NULL == callback) {
1433                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Input parameter is null");
1434                 return TTS_ERROR_INVALID_PARAMETER;
1435         }
1436
1437         tts_client_s* client = tts_client_get(tts);
1438
1439         if (NULL == client) {
1440                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : A handle is not valid");
1441                 return TTS_ERROR_INVALID_PARAMETER;
1442         }
1443
1444         if (TTS_STATE_CREATED != client->current_state) {
1445                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set error cb : Current state is not 'Created'.");
1446                 return TTS_ERROR_INVALID_STATE;
1447         }
1448
1449         client->error_cb = callback;
1450         client->error_user_data = user_data;
1451
1452         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set error cb");
1453
1454         return 0;
1455 }
1456
1457 int tts_unset_error_cb(tts_h tts)
1458 {
1459         if (0 != __tts_get_feature_enabled()) {
1460                 return TTS_ERROR_NOT_SUPPORTED;
1461         }
1462
1463         if (NULL == tts) {
1464                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Input parameter is null");
1465                 return TTS_ERROR_INVALID_PARAMETER;
1466         }
1467
1468         tts_client_s* client = tts_client_get(tts);
1469
1470         if (NULL == client) {
1471                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : A handle is not valid");
1472                 return TTS_ERROR_INVALID_PARAMETER;
1473         }
1474
1475         if (TTS_STATE_CREATED != client->current_state) {
1476                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset error cb : Current state is not 'Created'.");
1477                 return TTS_ERROR_INVALID_STATE;
1478         }
1479
1480         client->error_cb = NULL;
1481         client->error_user_data = NULL;
1482
1483         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset error cb");
1484
1485         return 0;
1486 }
1487
1488 int tts_set_default_voice_changed_cb(tts_h tts, tts_default_voice_changed_cb callback, void* user_data)
1489 {
1490         if (0 != __tts_get_feature_enabled()) {
1491                 return TTS_ERROR_NOT_SUPPORTED;
1492         }
1493
1494         if (NULL == tts || NULL == callback) {
1495                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Input parameter is null");
1496                 return TTS_ERROR_INVALID_PARAMETER;
1497         }
1498
1499         tts_client_s* client = tts_client_get(tts);
1500
1501         if (NULL == client) {
1502                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : A handle is not valid");
1503                 return TTS_ERROR_INVALID_PARAMETER;
1504         }
1505
1506         if (TTS_STATE_CREATED != client->current_state) {
1507                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Set default voice changed cb : Current state is not 'Created'.");
1508                 return TTS_ERROR_INVALID_STATE;
1509         }
1510
1511         client->default_voice_changed_cb = callback;
1512         client->default_voice_changed_user_data = user_data;
1513
1514         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Set default voice changed cb");
1515
1516         return 0;
1517 }
1518
1519 int tts_unset_default_voice_changed_cb(tts_h tts)
1520 {
1521         if (0 != __tts_get_feature_enabled()) {
1522                 return TTS_ERROR_NOT_SUPPORTED;
1523         }
1524
1525         if (NULL == tts) {
1526                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Input parameter is null");
1527                 return TTS_ERROR_INVALID_PARAMETER;
1528         }
1529
1530         tts_client_s* client = tts_client_get(tts);
1531
1532         if (NULL == client) {
1533                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : A handle is not valid");
1534                 return TTS_ERROR_INVALID_PARAMETER;
1535         }
1536
1537         if (TTS_STATE_CREATED != client->current_state) {
1538                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Unset default voice changed cb : Current state is not 'Created'.");
1539                 return TTS_ERROR_INVALID_STATE;
1540         }
1541
1542         client->default_voice_changed_cb = NULL;
1543         client->default_voice_changed_user_data = NULL;
1544
1545         SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Unset default voice changed cb");
1546
1547         return 0;
1548 }