client/tts_core.c

   1 /*
   2 *  Copyright (c) 2020 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 <string.h>
  15 #include <stdatomic.h>
  16
  17 #include <app_manager.h>
  18 #include <dlog.h>
  19 #include <package-manager.h>
  20
  21 #include "tts_internal.h"
  22 #include "tts_defs.h"
  23 #include "tts_core.h"
  24 #include "tts_ipc.h"
  25 #include "tts_dlog.h"
  26
  27
  28 static const int TTS_ERROR_FAIL_TO_SEND_HELLO = TIZEN_ERROR_TTS | 0xFF;
  29
  30
  31 /* Static variables */
  32 static atomic_bool g_is_thread_canceled = false;
  33
  34 static char* g_engine_name = NULL;
  35 static int g_engine_update_status = 0;
  36 static atomic_bool g_is_engine_name_changed = false;
  37
  38 static Ecore_Thread* g_reprepare_thread = NULL;
  39
  40 static char* g_pkgmgr_status = NULL;
  41 static pkgmgr_client* g_pkgmgr = NULL;
  42 static Ecore_Thread* g_pkgmgr_thread = NULL;
  43 static pthread_mutex_t g_pkgmgr_mutex = PTHREAD_MUTEX_INITIALIZER;
  44
  45 static char* g_language = NULL;
  46 static int g_voice_type = -1;
  47 static int g_speed = -1;
  48
  49
  50 /* Static functions */
  51 // TODO: make tts_util? or tts_log?
  52 static const char* __convert_state(tts_state_e state)
  53 {
  54         switch (state) {
  55         case TTS_STATE_CREATED: return "Created";
  56         case TTS_STATE_READY:   return "Ready";
  57         case TTS_STATE_PLAYING: return "Playing";
  58         case TTS_STATE_PAUSED:  return "Paused";
  59         }
  60
  61         return "Invalid state";
  62 }
  63
  64 static char* __get_engine_appid() {
  65         if (NULL == g_engine_name) {
  66                 return NULL;
  67         }
  68
  69         char* appid = (char*)calloc(TTS_ENGINE_APPID_LEN, sizeof(char));
  70         if (NULL == appid) {
  71                 return NULL;
  72         }
  73
  74         snprintf(appid, TTS_ENGINE_APPID_LEN, "%s", g_engine_name);
  75         return appid;
  76 }
  77
  78 static int __update_engine_name()
  79 {
  80         char* new_engine_name = vconf_get_str(TTS_ENGINE_DB_DEFAULT);
  81         RETVM_IF(NULL == new_engine_name, TTS_ERROR_OPERATION_FAILED, "[ERROR] Fail to get engine name");
  82
  83         if (NULL != g_engine_name && 0 == strncmp(g_engine_name, new_engine_name, TTS_ENGINE_APPID_LEN)) {
  84                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] engine name is same");
  85                 free(new_engine_name);
  86                 return TTS_ERROR_NONE;
  87         }
  88
  89         free(g_engine_name);
  90         g_engine_name = new_engine_name;
  91         g_is_engine_name_changed = true;
  92
  93         SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Engine name(%s)", g_engine_name);
  94         return TTS_ERROR_NONE;
  95 }
  96
  97 static inline void __client_error_cb(tts_client_s* client, int utt_id, tts_error_e reason)
  98 {
  99         tts_error_cb callback = tts_client_get_error_cb(client);
 100         void* data = tts_client_get_error_user_data(client);
 101
 102         if (NULL != callback) {
 103                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify error");
 104                 tts_client_use_callback(client);
 105                 callback(tts_client_get_handle(client), utt_id, reason, data);
 106                 tts_client_not_use_callback(client);
 107         } else {
 108                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(error)");
 109         }
 110 }
 111
 112 static inline void __client_state_changed_cb(tts_client_s* client, tts_state_e before_state, tts_state_e current_state)
 113 {
 114         tts_state_changed_cb callback = tts_client_get_state_changed_cb(client);
 115         void* data = tts_client_get_state_changed_user_data(client);
 116
 117         if (NULL != callback) {
 118                 SLOG(LOG_DEBUG, TAG_TTSC, "State changed data : before_state(%s) curret_state(%s)", __convert_state(before_state), __convert_state(current_state));
 119                 tts_client_use_callback(client);
 120                 callback(tts_client_get_handle(client), before_state, current_state, data);
 121                 tts_client_not_use_callback(client);
 122         } else {
 123                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(state_changed)");
 124         }
 125 }
 126
 127 static Eina_Bool __notify_error_timer_cb(void *data)
 128 {
 129         unsigned int uid = (uintptr_t)data;
 130         tts_client_s* client = tts_client_get_by_uid(uid);
 131         RETVM_IF(NULL == client, EINA_FALSE, "[ERROR] uid(%u) is not valid.", uid);
 132
 133         __client_error_cb(client, client->utt_id, client->reason);
 134         client->notify_error_timer = NULL;
 135
 136         return EINA_FALSE;
 137 }
 138
 139 static bool __is_engine_installed(const char* appid)
 140 {
 141         app_info_h app_info = NULL;
 142         int ret = app_manager_get_app_info(appid, &app_info);
 143         if (APP_MANAGER_ERROR_NONE != ret || NULL == app_info) {
 144                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no tts engine (%s). ret(%d)", appid, ret);
 145                 return false;
 146         } else {
 147                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] There is tts engine (%s)", appid);
 148         }
 149
 150         ret = app_info_destroy(app_info);
 151         if (APP_MANAGER_ERROR_NONE != ret)
 152                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to destroy app_info. ret(%d)", ret);
 153
 154         return true;
 155 }
 156
 157 static bool __is_engine_launched()
 158 {
 159         char* appid = __get_engine_appid();
 160         if (NULL == appid) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get engine app ID");
 162                 return false;
 163         }
 164
 165         bool is_installed = __is_engine_installed(appid);
 166         if (false == is_installed) {
 167                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] tts engine(%s) is not installed", appid);
 168                 free(appid);
 169                 return false;
 170         }
 171
 172         bool is_running = false;
 173         int ret = app_manager_is_running(appid, &is_running);
 174         if (APP_MANAGER_ERROR_NONE != ret) {
 175                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to check whether appid(%s) is running or not. ret(%d)", appid, ret);
 176                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is installed(%d)", is_installed);
 177                 free(appid);
 178                 return false;
 179         }
 180
 181         free(appid);
 182         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is %s running. is_installed(%d)", (is_running) ? "" : " not", is_installed);
 183         return is_running;
 184 }
 185
 186 //LCOV_EXCL_START
 187 static int __pkgmgr_status_cb(uid_t target_uid, int req_id, const char *type, const char *pkgname, const char *key, const char *val, const void *pmsg, void *data)
 188 {
 189         // type (the type of the pkgname)
 190         SLOG(LOG_INFO, TAG_TTSC, "[INFO] pkgmgr status cb is invoked. pkgname(%s), type(%s), key(%s), val(%s)", pkgname, type, key, val);
 191
 192         if (NULL == g_engine_name) {
 193                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] engine name is NULL");
 194                 return 0;
 195         }
 196
 197         if (0 != strncmp(g_engine_name, pkgname, strlen(g_engine_name))) {
 198                 SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] this is not tts engine");
 199                 return 0;
 200         }
 201
 202         if (NULL == key) {
 203                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] key is NULL");
 204                 return 0;
 205         }
 206
 207         if (0 == strncmp(key, "start", strlen(key))) {
 208                 if (NULL != g_pkgmgr_status) {
 209                         free(g_pkgmgr_status);
 210                         g_pkgmgr_status = NULL;
 211                 }
 212
 213                 if (val) {
 214                         g_pkgmgr_status = strdup(val);
 215                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] pkgmgr status. key(%s), status(%s)", key, g_pkgmgr_status);
 216
 217                         if ((0 == strncmp(val, "update", strlen(val) || 0 == strncmp(val, "uninstall", strlen(val))))) {
 218                                 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] start to install.");
 219                                 g_engine_update_status = 1;
 220                         }
 221                 }
 222         } else if (0 == strncmp(key, "end", strlen(key)) && val && 0 == strncmp(val, "ok", strlen(val))) {
 223                 if (g_pkgmgr_status) {
 224                         if (0 == strncmp(g_pkgmgr_status, "install", strlen(g_pkgmgr_status)) || 0 == strncmp(g_pkgmgr_status, "update", strlen(g_pkgmgr_status))) {
 225                                 SLOG(LOG_ERROR, TAG_TTSC, "[INFO] finish to install");
 226                                 g_engine_update_status = 0;
 227
 228                                 free(g_pkgmgr_status);
 229                                 g_pkgmgr_status = NULL;
 230                         }
 231                 }
 232         }
 233
 234         return 0;
 235 }
 236 //LCOV_EXCL_STOP
 237
 238 static void __create_pkgmgr_thread(void* data, Ecore_Thread* thread)
 239 {
 240         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] create pkgmgr thread");
 241
 242         pthread_mutex_lock(&g_pkgmgr_mutex);
 243         while (NULL == g_pkgmgr) {
 244                 /* Checking the thread is canceled or not */
 245                 if (g_is_thread_canceled) {
 246                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] g_pkgmgr_thread is canceled. Exit");
 247                         break;
 248                 }
 249
 250                 /* Checking handle which can be destroyed on other thread */
 251                 if (0 == tts_client_get_size()) {
 252                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] All client is already destroyed");
 253                         break;
 254                 }
 255
 256                 g_pkgmgr = pkgmgr_client_new(PC_LISTENING);
 257                 if (NULL == g_pkgmgr) {
 258 //                      SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to create pkgmgr handle");
 259                 } else {
 260                         int ret = pkgmgr_client_set_status_type(g_pkgmgr, PKGMGR_CLIENT_STATUS_INSTALL | PKGMGR_CLIENT_STATUS_UNINSTALL | PKGMGR_CLIENT_STATUS_UPGRADE);
 261                         if (0 == ret) {
 262                                 if (pkgmgr_client_listen_status(g_pkgmgr, __pkgmgr_status_cb, NULL) < 0) {
 263                                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to listen pkgmgr status. remove and recreate client");
 264                                         pkgmgr_client_free(g_pkgmgr);
 265                                         g_pkgmgr = NULL;
 266                                 } else {
 267                                         SLOG(LOG_ERROR, TAG_TTSC, "[INFO] Succeed to register pkgmgr cb");
 268                                         break;
 269                                 }
 270                         } else {
 271                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set status type on pkgmgr, ret(%d)", ret);
 272                                 pkgmgr_client_free(g_pkgmgr);
 273                                 g_pkgmgr = NULL;
 274                         }
 275                 }
 276
 277                 usleep(10000);
 278         }
 279         pthread_mutex_unlock(&g_pkgmgr_mutex);
 280
 281         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] create pkgmgr end");
 282 }
 283
 284 static void __finish_pkgmgr_thread(void* data, Ecore_Thread* thread)
 285 {
 286         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Finish pkgmgr thread");
 287         g_is_thread_canceled = false;
 288         g_pkgmgr_thread = NULL;
 289 }
 290
 291 //LCOV_EXCL_START
 292 static void __cancel_pkgmgr_thread(void* data, Ecore_Thread* thread)
 293 {
 294         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] Cancel pkgmgr thread");
 295         g_is_thread_canceled = false;
 296         g_pkgmgr_thread = NULL;
 297 }
 298 //LCOV_EXCL_STOP
 299
 300 static void __pkgmgr_thread(void* data)
 301 {
 302         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] call pkgmgr_thread");
 303         if (NULL == g_pkgmgr_thread) {
 304                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] ecore thread run: create_pkgmgr_thread");
 305                 g_pkgmgr_thread = ecore_thread_run(__create_pkgmgr_thread, __finish_pkgmgr_thread, __cancel_pkgmgr_thread, NULL);
 306         }
 307
 308         return;
 309 }
 310
 311 //LCOV_EXCL_START
 312 static void __start_reprepare_thread(void* data, Ecore_Thread* thread)
 313 {
 314         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] start reprepare thread. engine update status(%d)", g_engine_update_status);
 315
 316         if (0 == g_engine_update_status && g_is_engine_name_changed) {
 317                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Reprepare by engine change");
 318                 return;
 319         }
 320
 321         int cnt = 0;
 322         while (!g_engine_update_status && cnt < 20) {
 323                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] wait for starting update");
 324
 325                 usleep(50000);
 326                 cnt++;
 327
 328                 // TODO: fix way to exit thread safely
 329                 /* Checking thread is canceled or not */
 330                 if (ecore_thread_check(g_reprepare_thread)) {
 331                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] client thread is canceled. Exit");
 332                         return;
 333                 }
 334         }
 335
 336         SLOG(LOG_INFO, TAG_TTSC, "[DEBUG] update status(%d)", g_engine_update_status);
 337
 338         while (g_engine_update_status && (NULL != g_pkgmgr)) {
 339                 usleep(200000);
 340
 341                 // TODO: fix way to exit thread safely
 342                 /* Checking thread is canceled or not */
 343                 if (ecore_thread_check(g_reprepare_thread)) {
 344                         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] client thread is canceled. Exit");
 345                         return;
 346                 }
 347         }
 348
 349         SLOG(LOG_INFO, TAG_TTSC, "[INFO] finish updating. request to prepare");
 350
 351         return;
 352 }
 353 //LCOV_EXCL_STOP
 354
 355 static void __end_reprepare_thread(void* data, Ecore_Thread* thread)
 356 {
 357         SLOG(LOG_INFO, TAG_TTSC, "[INFO] end reprepare thread");
 358
 359         GList* clients = tts_client_get_client_list();
 360         if (NULL == clients) {
 361                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get client list");
 362                 g_is_engine_name_changed = false;
 363                 g_reprepare_thread = NULL;
 364                 return;
 365         }
 366
 367         GList *iter = NULL;
 368         if (g_list_length(clients) > 0) {
 369                 iter = g_list_first(clients);
 370
 371                 while (NULL != iter) {
 372                         tts_client_s* client = iter->data;
 373                         if (NULL != client) {
 374                                 tts_core_prepare(client);
 375                         }
 376
 377                         iter = g_list_next(iter);
 378                 }
 379         }
 380
 381         g_list_free(clients);
 382         g_is_engine_name_changed = false;
 383         g_reprepare_thread = NULL;
 384 }
 385
 386 //LCOV_EXCL_START
 387 static void __cancel_reprepare_thread(void* data, Ecore_Thread* thread)
 388 {
 389         SLOG(LOG_INFO, TAG_TTSC, "[INFO] cancel reprepare thread");
 390         g_is_engine_name_changed = false;
 391         g_reprepare_thread = NULL;
 392 }
 393 //LCOV_EXCL_STOP
 394
 395 static inline void __run_client_reprepare_thread()
 396 {
 397         if (NULL == g_reprepare_thread) {
 398                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] ecore thread run: start_reprepare_thread");
 399                 g_reprepare_thread = ecore_thread_run(__start_reprepare_thread, __end_reprepare_thread, __cancel_reprepare_thread, NULL);
 400         } else {
 401                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Reprepare thread is already running");
 402         }
 403 }
 404
 405 static int __send_hello_msg(tts_client_s* client)
 406 {
 407         tts_state_e current_state = tts_client_get_current_state(client);
 408         if (TTS_STATE_READY == current_state) {
 409                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] TTS client has been already connected to tts service"); //LCOV_EXCL_LINE
 410                 return TTS_ERROR_INVALID_STATE;
 411         }
 412
 413         if (false == tts_core_check_screen_reader(client)) {
 414                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
 415                 return TTS_ERROR_SCREEN_READER_OFF;
 416         }
 417
 418         unsigned int uid = tts_client_get_uid(client);
 419         tts_mode_e mode = tts_client_get_mode(client);
 420         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u), mode(%d)", tts_client_get_handle(client), client, uid, (int)mode);
 421
 422         /* check service engine status */
 423         bool is_launched = __is_engine_launched();
 424         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 425         if (false == is_launched) {
 426                 /* If engine is NOT launched, check whether engine is updating or not */
 427                 if (g_engine_update_status) {
 428                         /* suyeon wait engine update */
 429                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] cannot prepare due to engine update");
 430                         __run_client_reprepare_thread();
 431                         return TTS_ERROR_INVALID_STATE;
 432                 }
 433         }
 434
 435         if (0 != tts_ipc_request_hello(uid, mode)) {
 436                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 437         } else {
 438                 SLOG(LOG_INFO, TAG_TTSC, "@@@ Send Hello");
 439         }
 440
 441         return TTS_ERROR_NONE;
 442 }
 443
 444 static Eina_Bool __prepare_cb(void *data)
 445 {
 446         unsigned int uid = (uintptr_t)data;
 447         tts_client_s* client = tts_client_get_by_uid(uid);
 448         RETVM_IF(NULL == client, EINA_FALSE, "[ERROR] uid(%u) is not valid.", uid);
 449
 450         int ret = __send_hello_msg(client);
 451         if (ret != TTS_ERROR_NONE) {
 452                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to send hello message"); //LCOV_EXCL_LINE
 453                 client->hello_timer = NULL;
 454                 return EINA_FALSE;
 455         }
 456
 457         client->prepare_count++;
 458         if (TTS_HELLO_RETRY_COUNT == client->prepare_count) {
 459                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare, retry count reaches the limit");
 460
 461                 bool is_launched = __is_engine_launched();
 462                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 463
 464                 client->hello_timer = NULL;
 465
 466                 tts_core_notify_error_async(client, TTS_ERROR_TIMED_OUT, -1, "[ERROR] Fail to prepare. Please call tts_prepare() again.");
 467
 468                 return EINA_FALSE;
 469         }
 470
 471         return EINA_TRUE;
 472 }
 473
 474 static Eina_Bool __prepare_first_cb(void *data)
 475 {
 476         /* send first hello message */
 477         unsigned int uid = (uintptr_t)data;
 478         tts_client_s* client = tts_client_get_by_uid(uid);
 479         RETVM_IF(NULL == client, EINA_FALSE, "[ERROR] uid(%u) is not valid.", uid);
 480
 481         int ret = __send_hello_msg(client);
 482         if (ret != TTS_ERROR_NONE) {
 483                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to sent hello message"); //LCOV_EXCL_LINE
 484                 client->hello_timer = NULL;
 485         } else {
 486                 /* Set retry timer callback */
 487                 client->prepare_count = 0;
 488                 client->hello_timer = ecore_timer_add(0.5, __prepare_cb, data);
 489         }
 490
 491         return EINA_FALSE;
 492 }
 493
 494 static int __prepare_sync_cb(tts_client_s* client)
 495 {
 496         // TODO: make function duplicated block
 497         bool is_launched = __is_engine_launched();
 498         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 499
 500         if (false == is_launched) {
 501                 /* check whether engine is updating or not */
 502                 if (g_engine_update_status) {
 503                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot prepare due to engine update.");
 504                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client automatically tries to reprepare asynchrnously.");
 505                         __run_client_reprepare_thread();
 506                         return TTS_ERROR_OPERATION_FAILED;
 507                 }
 508         }
 509
 510         // TODO: make function duplicated block
 511         unsigned int uid = tts_client_get_uid(client);
 512         if (TTS_ERROR_NONE != tts_ipc_request_hello_sync(uid)) {
 513                 return TTS_ERROR_FAIL_TO_SEND_HELLO;
 514         }
 515
 516         SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 517
 518         // TODO: make function duplicated block
 519         /* do request initialize */
 520         bool credential_needed = false;
 521         tts_mode_e mode = tts_client_get_mode(client);
 522         int ret = tts_ipc_request_initialize(uid, mode, &credential_needed);
 523         if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == ret) {
 524                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize. ret(%d/%s)", ret, get_error_message(ret));
 525                 tts_core_notify_error_async(client, ret, -1, NULL);
 526
 527                 return ret;
 528         } else if (TTS_ERROR_NONE != ret) {
 529                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect. ret(%d/%s)", ret, get_error_message(ret));
 530                 return TTS_ERROR_FAIL_TO_SEND_HELLO;
 531         } else {
 532                 /* success to connect tts-daemon */
 533                 client->credential_needed = credential_needed;
 534                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 535         }
 536         // TODO: make function duplicated block
 537
 538         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 539         return TTS_ERROR_NONE;
 540 }
 541
 542 static void __engine_changed_cb(keynode_t* key, void* data)
 543 {
 544         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine vconfkey is changed");
 545         if (0 != __update_engine_name()) {
 546                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set engine name into core module");
 547         }
 548
 549         return;
 550 }
 551
 552 static bool __supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 553 {
 554         unsigned int uid = (uintptr_t)user_data;
 555         tts_client_s* client = tts_client_get_by_uid(uid);
 556         RETVM_IF(NULL == client, false, "[ERROR] uid(%u) is not valid.", uid);
 557
 558         /* call callback function */
 559         tts_supported_voice_cb callback = tts_client_get_supported_voice_cb(client);
 560         void* data = tts_client_get_supported_voice_user_data(client);
 561
 562         if (NULL == callback) {
 563                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get callback.");
 564                 return false;
 565         }
 566
 567         return callback(tts_client_get_handle(client), language, type, data);
 568 }
 569
 570 static bool __is_screen_reader_turned_on()
 571 {
 572         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Update screen reader state");
 573
 574         int screen_reader = 0;
 575         int ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 576         if (0 != ret) {
 577                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get screen reader vconf(%d)", ret);
 578                 return false;
 579         }
 580
 581         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Current screen reader status(%d)", screen_reader);
 582         return (bool)screen_reader;
 583 }
 584
 585 static inline bool __is_ipc_retry_needed(tts_client_s* client, tts_error_e ret)
 586 {
 587         if (TTS_ERROR_NONE == ret) {
 588                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success the IPC request");
 589                 return false;
 590         }
 591
 592         if (TTS_ERROR_TIMED_OUT == ret) {
 593                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] IPC is failed. Try again. ret(%d/%s)", ret, get_error_message(ret));
 594                 usleep(10000);
 595                 return true;
 596         }
 597
 598         if (TTS_ERROR_INVALID_PARAMETER == ret && false == tts_client_is_reprepared(client)) {
 599                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] IPC is failed by unregistered client. ret(%d/%s)", ret, get_error_message(ret));
 600                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Try to prepare again");
 601                 tts_client_set_current_state(client, TTS_STATE_CREATED);
 602                 tts_core_prepare_sync(client);
 603                 tts_client_set_reprepared(client, true);
 604                 return true;
 605         }
 606
 607         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] IPC request is failed. ret(%d/%s)", ret, get_error_message(ret));
 608         return false;
 609 }
 610
 611 static inline int __request_add_text(tts_client_s* client, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 612 {
 613         /* change default language value */
 614         const char* convert_language = (NULL == language ? "default" : language);
 615         int new_utt_id = tts_client_new_utterance_id(client);
 616         if (0 > new_utt_id) {
 617                 return TTS_ERROR_OPERATION_FAILED;
 618         }
 619
 620         // TODO: If use cpp, remove dupliceated code using command class pattern
 621         unsigned int uid = tts_client_get_uid(client);
 622         int ret = -1;
 623         tts_client_set_reprepared(client, false);
 624         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
 625                 ret = tts_ipc_request_add_text(uid, text, convert_language, voice_type, speed, new_utt_id, client->credential);
 626                 if (false == __is_ipc_retry_needed(client, ret)) {
 627                         break;
 628                 }
 629         }
 630
 631         if (TTS_ERROR_NONE != ret) {
 632                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 633                 return ret;
 634         }
 635
 636         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_add_text");
 637         *utt_id = new_utt_id;
 638         return TTS_ERROR_NONE;
 639 }
 640
 641 static inline int __request_play(tts_client_s* client)
 642 {
 643         unsigned int uid = tts_client_get_uid(client);
 644         int ret = -1;
 645         tts_client_set_reprepared(client, false);
 646         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
 647                 ret = tts_ipc_request_play(uid, client->credential);
 648                 if (false == __is_ipc_retry_needed(client, ret)) {
 649                         break;
 650                 }
 651         }
 652
 653         if (TTS_ERROR_NONE != ret) {
 654                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 655                 return ret;
 656         }
 657
 658         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_play");
 659         return tts_core_notify_state_changed(client, TTS_STATE_PLAYING);
 660 }
 661
 662 int tts_core_initialize()
 663 {
 664         ecore_main_loop_thread_safe_call_async(__pkgmgr_thread, NULL);
 665
 666         if (0 != __update_engine_name()) {
 667                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set engine name into core module");
 668         }
 669         g_is_engine_name_changed = false;
 670
 671         /* Register vconfkey callback to detect engine change */
 672         vconf_notify_key_changed(TTS_ENGINE_DB_DEFAULT, __engine_changed_cb, NULL);
 673
 674         return TTS_ERROR_NONE;
 675 }
 676
 677 int tts_core_deinitialize()
 678 {
 679         if (NULL != g_reprepare_thread && EINA_FALSE == ecore_thread_check(g_reprepare_thread)) {
 680                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Cancel reprepare thread");
 681                 ecore_thread_cancel(g_reprepare_thread);
 682                 ecore_thread_wait(g_reprepare_thread, 0.5);             // wait g_reprepare_thread is terminated.
 683         }
 684
 685         if (NULL != g_pkgmgr_thread) {
 686                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Cancel pkgmgr thread");
 687                 g_is_thread_canceled = true;
 688         }
 689
 690         if (NULL != g_language) {
 691                 free(g_language);
 692                 g_language = NULL;
 693         }
 694
 695         if (NULL != g_engine_name) {
 696                 free(g_engine_name);
 697                 g_engine_name = NULL;
 698         }
 699
 700         pthread_mutex_lock(&g_pkgmgr_mutex);
 701         if (NULL != g_pkgmgr) {
 702                 pkgmgr_client_remove_listen_status(g_pkgmgr);
 703                 pkgmgr_client_free(g_pkgmgr);
 704                 g_pkgmgr = NULL;
 705         }
 706
 707         if (NULL != g_pkgmgr_status) {
 708                 free(g_pkgmgr_status);
 709                 g_pkgmgr_status = NULL;
 710         }
 711         pthread_mutex_unlock(&g_pkgmgr_mutex);
 712
 713         /* Unregister vconfkey callback */
 714         vconf_ignore_key_changed(TTS_ENGINE_DB_DEFAULT, __engine_changed_cb);
 715
 716         return TTS_ERROR_NONE;
 717 }
 718
 719 int tts_core_notify_state_changed(tts_client_s* client, tts_state_e current_state)
 720 {
 721         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 722
 723         tts_state_e before_state = tts_client_get_current_state(client);
 724         if (before_state == current_state) {
 725                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] State is not changed. before(%s), current(%s)", __convert_state(before_state), __convert_state(current_state));
 726                 return TTS_ERROR_NONE;
 727         }
 728
 729         SLOG(LOG_DEBUG, TAG_TTSC, "State changed to (%s).", __convert_state(current_state));
 730         tts_client_set_current_state(client, current_state);
 731         __client_state_changed_cb(client, before_state, current_state);
 732
 733         return TTS_ERROR_NONE;
 734 }
 735
 736 int tts_core_notify_utt_started(tts_client_s* client, int utt_id)
 737 {
 738         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 739
 740         client->utt_id = utt_id;
 741         SLOG(LOG_DEBUG, TAG_TTSC, "Utterance started data : utt_id(%d)", client->utt_id);
 742
 743         tts_utterance_started_cb callback = tts_client_get_utterance_started_cb(client);
 744         void* data = tts_client_get_utterance_started_user_data(client);
 745
 746         if (NULL != callback) {
 747                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
 748                 tts_client_use_callback(client);
 749                 callback(tts_client_get_handle(client), client->utt_id, data);
 750                 tts_client_not_use_callback(client);
 751         } else {
 752                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_started)");
 753         }
 754
 755         return TTS_ERROR_NONE;
 756 }
 757
 758 int tts_core_notify_utt_completeted(tts_client_s* client, int utt_id)
 759 {
 760         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 761
 762         client->utt_id = utt_id;
 763         SLOG(LOG_DEBUG, TAG_TTSC, "Utterance completed data : utt_id(%d)", utt_id);
 764
 765         tts_utterance_completed_cb callback = tts_client_get_utterance_completed_cb(client);
 766         void* data = tts_client_get_utterance_completed_user_data(client);
 767
 768         if (NULL != callback) {
 769                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
 770                 tts_client_use_callback(client);
 771                 callback(tts_client_get_handle(client), utt_id, data);
 772                 tts_client_not_use_callback(client);
 773         } else {
 774                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_completed)");
 775         }
 776
 777         return TTS_ERROR_NONE;
 778 }
 779
 780 int tts_core_notify_error_async(tts_client_s* client, tts_error_e reason, int utt_id, const char* err_msg)
 781 {
 782         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 783
 784         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : utt_id(%d) reason(%s)", utt_id, tts_core_covert_error_code(reason));
 785         client->utt_id = utt_id;
 786         client->reason = reason;
 787         tts_client_set_error_message(client, err_msg);
 788
 789         SLOG(LOG_DEBUG, TAG_TTSC, "Notify error asynchronously");
 790         if (NULL != client->notify_error_timer) {
 791                 ecore_timer_del(client->notify_error_timer);
 792         }
 793
 794         uintptr_t uid = tts_client_get_uid(client);
 795         client->notify_error_timer = ecore_timer_add(0, __notify_error_timer_cb, (void*)uid);
 796
 797         return TTS_ERROR_NONE;
 798 }
 799
 800 //LCOV_EXCL_START
 801 int tts_core_notify_default_voice_changed(tts_client_s* client, const char* before_lang, int before_voice_type, const char* language, int voice_type)
 802 {
 803         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 804
 805         SLOG(LOG_DEBUG, TAG_TTSC, "Default voice changed data : before_lang(%s), before_voice_type(%d), language(%s), voice_type(%d)",
 806                         before_lang, before_voice_type, language, voice_type);
 807
 808         tts_default_voice_changed_cb callback = tts_client_get_default_voice_changed_cb(client);
 809         void* data = tts_client_get_default_voice_changed_user_data(client);
 810
 811         if (NULL != callback) {
 812                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify default voice changed");
 813                 tts_client_use_callback(client);
 814                 callback(tts_client_get_handle(client), before_lang, before_voice_type, language, voice_type, data);
 815                 tts_client_not_use_callback(client);
 816         } else {
 817                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(default_voice_changed)");
 818         }
 819
 820         return TTS_ERROR_NONE;
 821 }
 822
 823 int tts_core_notify_engine_changed(tts_client_s* client, const char* engine_id, const char* language, int voice_type, bool need_credential)
 824 {
 825         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 826
 827         SLOG(LOG_DEBUG, TAG_TTSC, "Engine changed data : engine_id(%s) language(%s), voicd_type(%d), need_credential(%d)",
 828                         engine_id, language, voice_type, need_credential);
 829
 830         tts_engine_changed_cb callback = tts_client_get_engine_changed_cb(client);
 831         void* data = tts_client_get_engine_changed_user_data(client);
 832
 833         if (NULL != callback) {
 834                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify engine changed");
 835                 tts_client_use_callback(client);
 836                 callback(tts_client_get_handle(client), engine_id, language, voice_type, need_credential, data);
 837                 tts_client_not_use_callback(client);
 838         } else {
 839                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(engine_changed)");
 840         }
 841
 842         return TTS_ERROR_NONE;
 843 }
 844 //LCOV_EXCL_STOP
 845
 846 int tts_core_notify_screen_reader_changed(tts_client_s* client, bool value)
 847 {
 848         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 849
 850         SLOG(LOG_DEBUG, TAG_TTSC, "Screen reader is changed. Current status(%d)", value);
 851
 852         tts_screen_reader_changed_cb callback = tts_client_get_screen_reader_changed_cb(client);
 853         void* data = tts_client_get_screen_reader_changed_user_data(client);
 854
 855         if (NULL != callback) {
 856                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify screen reader changed");
 857                 tts_client_use_callback(client);
 858                 callback(tts_client_get_handle(client), value, data);
 859                 tts_client_not_use_callback(client);
 860         } else {
 861                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(screen_reader_changed)");
 862         }
 863
 864         return TTS_ERROR_NONE;
 865 }
 866
 867 bool tts_core_is_valid_text(const char* text)
 868 {
 869         if (NULL == text) {
 870                 return false;
 871         }
 872
 873         /* check valid utf8 */
 874         DBusError err;
 875         dbus_error_init(&err);
 876         bool valid = dbus_validate_utf8(text, &err);
 877         if (dbus_error_is_set(&err)) {
 878                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
 879                 dbus_error_free(&err);
 880                 return false;
 881         }
 882
 883         if (false == valid) {
 884                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
 885                 return false;
 886         }
 887
 888         if (strlen(text) <= 0) {
 889                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 890                 return false;
 891         }
 892
 893         unsigned int max_text_size = 0;
 894         /* check text size */
 895         if (0 != tts_config_mgr_get_max_text_size(&max_text_size)) {
 896                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
 897                 return false;
 898         }
 899
 900         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] max_text_size is %d byte", max_text_size);
 901         if (0 < max_text_size && max_text_size < strlen(text)) {
 902                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is bigger than maximum test size. text_size(%zu byte)", strlen(text));
 903                 return false;
 904         }
 905
 906         return true;
 907 }
 908
 909 bool tts_core_check_screen_reader(tts_client_s* client)
 910 {
 911         RETVM_IF(false == tts_client_is_valid_client(client), false, "[ERROR] Client is invalid.");
 912
 913         tts_mode_e mode = tts_client_get_mode(client);
 914         if (TTS_MODE_SCREEN_READER == mode && false == __is_screen_reader_turned_on()) {
 915                 return false;
 916         }
 917
 918         return true;
 919 }
 920
 921 bool tts_core_check_credential(tts_client_s* client)
 922 {
 923         RETVM_IF(false == tts_client_is_valid_client(client), false, "[ERROR] Client is invalid.");
 924
 925         if (true == client->credential_needed && NULL == tts_client_get_credential_key(client)) {
 926                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
 927                 return false;
 928         }
 929
 930         return true;
 931 }
 932
 933 //LCOV_EXCL_START
 934 const char* tts_core_covert_error_code(tts_error_e err)
 935 {
 936         switch (err) {
 937         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
 938         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
 939         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
 940         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
 941         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
 942         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
 943         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
 944         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
 945         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
 946         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
 947         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
 948         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
 949         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
 950         case TTS_ERROR_NOT_SUPPORTED_FEATURE:   return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
 951         case TTS_ERROR_SERVICE_RESET:           return "TTS_ERROR_SERVICE_RESET";
 952         case TTS_ERROR_SCREEN_READER_OFF:       return "TTS_ERROR_SCREEN_READER_OFF";
 953         default:
 954                 return "Invalid error code";
 955         }
 956         return NULL;
 957 }
 958 //LCOV_EXCL_STOP
 959
 960 int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed)
 961 {
 962         tts_client_s* client = tts_client_get_by_uid(uid);
 963         RETVM_IF(NULL == client, TTS_ERROR_OPERATION_FAILED, "Fail to get TTS client or ignore this uid(%u)", uid);
 964
 965         tts_state_e current_state = tts_client_get_current_state(client);
 966         RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_NONE, "[INFO] tts client is already READY");
 967
 968         if (client->hello_timer) {
 969                 ecore_timer_del(client->hello_timer);
 970                 client->hello_timer = NULL;
 971         }
 972
 973         if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == ret) {
 974                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", tts_core_covert_error_code(ret));
 975                 tts_core_notify_error_async(client, ret, -1, NULL);
 976
 977                 return TTS_ERROR_OPERATION_FAILED;
 978         } else if (TTS_ERROR_ALREADY_INITIALIZED == ret) {
 979                 /* success to connect tts-daemon */
 980                 if (TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED != credential_needed) {
 981                         client->credential_needed = credential_needed;
 982                         SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%d)", credential_needed);
 983                 }
 984         } else if (TTS_ERROR_NONE != ret) {
 985                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", tts_core_covert_error_code(ret));
 986                 return TTS_ERROR_OPERATION_FAILED;
 987         }
 988
 989         tts_core_notify_state_changed(client, TTS_STATE_READY);
 990
 991         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 992         return TTS_ERROR_NONE;
 993 }
 994
 995 int tts_core_prepare(tts_client_s* client)
 996 {
 997         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 998
 999         if (false == tts_core_check_screen_reader(client)) {
1000                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
1001                 return TTS_ERROR_SCREEN_READER_OFF;
1002         }
1003
1004         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare. tts_h(%p), tts_client(%p)", tts_client_get_handle(client), client);
1005         if (NULL == client->hello_timer) {
1006                 SLOG(LOG_ERROR, TAG_TTSC, "Register timer for __prepare_first_cb");
1007
1008                 ecore_thread_main_loop_begin();
1009                 uintptr_t uid = tts_client_get_uid(client);
1010                 client->hello_timer = ecore_timer_add(0.0, __prepare_first_cb, (void*)uid);
1011                 ecore_thread_main_loop_end();
1012         } else {
1013                 LOGD("Client is already trying to prepare");
1014         }
1015
1016         return TTS_ERROR_NONE;
1017 }
1018
1019 int tts_core_prepare_sync(tts_client_s* client)
1020 {
1021         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1022
1023         unsigned int uid = tts_client_get_uid(client);
1024         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Start core_prepare_sync. tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
1025         int cnt = 0;
1026         while (TTS_CONNECTION_RETRY_COUNT > cnt) {
1027                 if (false == tts_core_check_screen_reader(client)) {
1028                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Screen reader option is not available");
1029                         return TTS_ERROR_SCREEN_READER_OFF;
1030                 }
1031
1032                 int ret = __prepare_sync_cb(client);
1033                 if (TTS_ERROR_NONE == ret) {
1034                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Prepare succeeds. uid(%u)", uid);
1035                         break;
1036                 }
1037
1038                 if (TTS_ERROR_FAIL_TO_SEND_HELLO == ret) {
1039                         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Fail to send hello. Try again. uid(%u)", uid);
1040                 } else {
1041                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare. uid(%u), ret(%d/%s)", uid, ret, get_error_message(ret));
1042                         return ret;
1043                 }
1044
1045                 cnt++;
1046         }
1047
1048         if (TTS_CONNECTION_RETRY_COUNT == cnt) {
1049                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
1050                 return TTS_ERROR_OPERATION_FAILED;
1051         }
1052
1053         tts_core_notify_state_changed(client, TTS_STATE_READY);
1054
1055         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1056         return TTS_ERROR_NONE;
1057 }
1058
1059 int tts_core_unprepare(tts_client_s* client)
1060 {
1061         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1062
1063         unsigned int uid = tts_client_get_uid(client);
1064         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
1065         if (client->hello_timer) {
1066                 ecore_timer_del(client->hello_timer);
1067                 client->hello_timer = NULL;
1068         }
1069
1070         int ret = -1;
1071         if (false == tts_core_check_screen_reader(client)) {
1072                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize. Handled by screen reader");
1073
1074                 ret = tts_ipc_stop_listening(uid);
1075                 if (0 != ret) {
1076                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to remove match : %s", tts_core_covert_error_code(ret));
1077                 }
1078         } else {
1079                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Request finalize");
1080
1081                 tts_client_set_reprepared(client, false);
1082                 for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1083                         ret = tts_ipc_request_finalize(uid);
1084                         if (false == __is_ipc_retry_needed(client, ret)) {
1085                                 break;
1086                         }
1087                 }
1088
1089                 if (TTS_ERROR_NONE == ret) {
1090                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_finalize");
1091                 }
1092         }
1093
1094         return TTS_ERROR_NONE;
1095 }
1096
1097 int tts_core_reprepare()
1098 {
1099         GList* clients = tts_client_get_client_list();
1100         RETVM_IF(NULL == clients, TTS_ERROR_OPERATION_FAILED, "[ERROR] Fail to get client list");
1101
1102         GList *iter = NULL;
1103         if (g_list_length(clients) > 0) {
1104                 iter = g_list_first(clients);
1105
1106                 while (NULL != iter) {
1107                         tts_client_s* client = iter->data;
1108                         if (true == tts_client_is_valid_client(client)) {
1109                                 tts_client_set_current_state(client, TTS_STATE_CREATED);
1110                         }
1111
1112                         iter = g_list_next(iter);
1113                 }
1114         }
1115
1116         g_list_free(clients);
1117         __run_client_reprepare_thread();
1118
1119         return TTS_ERROR_NONE;
1120 }
1121
1122 int tts_core_foreach_supported_voices(tts_client_s* client, const char* engine_id, tts_supported_voice_cb callback, void* user_data)
1123 {
1124         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1125
1126         tts_client_set_supported_voice_cb(client, callback, user_data);
1127         uintptr_t uid = tts_client_get_uid(client);
1128         int ret = tts_config_mgr_get_voice_list(engine_id, __supported_voice_cb, (void*)uid);
1129         tts_client_set_supported_voice_cb(client, NULL, NULL);
1130
1131         if (0 != ret) {
1132                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get voice list");
1133                 return TTS_ERROR_OPERATION_FAILED;
1134         }
1135
1136         return TTS_ERROR_NONE;
1137 }
1138
1139 int tts_core_handle_service_reset()
1140 {
1141         GList* client_list = tts_client_get_client_list();
1142         RETVM_IF(NULL == client_list, TTS_ERROR_OPERATION_FAILED, "[ERROR] Fail to get client list");
1143
1144         if (g_list_length(client_list) > 0) {
1145                 GList *iter = g_list_first(client_list);
1146                 while (NULL != iter) {
1147                         tts_client_s *client = iter->data;
1148                         if (false == tts_client_is_valid_client(client)) {
1149                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client is not valid");
1150                         } else {
1151                                 tts_core_notify_error_async(client, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
1152                         }
1153
1154                         iter = g_list_next(iter);
1155                 }
1156         }
1157
1158         g_list_free(client_list);
1159
1160         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1161         tts_core_reprepare();
1162
1163         return TTS_ERROR_NONE;
1164 }
1165
1166 int tts_core_add_text(tts_client_s* client, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1167 {
1168         RETVM_IF(NULL == text || NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Parameter is invalid.");
1169         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1170
1171         tts_client_set_repeat_text(client, text);
1172
1173         if (NULL != g_language) {
1174                 free(g_language);
1175         }
1176
1177         g_language = (NULL == language ? NULL : strdup(language));
1178         g_voice_type = voice_type;
1179         g_speed = speed;
1180
1181         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text(%s), language(%s), voice type(%d), speed(%d)", text, (g_language) ? g_language : "NULL", g_voice_type, g_speed);
1182         return __request_add_text(client, text, language, voice_type, speed, utt_id);
1183 }
1184
1185 int tts_core_play(tts_client_s* client)
1186 {
1187         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1188
1189         return __request_play(client);
1190 }
1191
1192 int tts_core_stop(tts_client_s* client)
1193 {
1194         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1195
1196         unsigned int uid = tts_client_get_uid(client);
1197         int ret = -1;
1198         tts_client_set_reprepared(client, false);
1199         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1200                 ret = tts_ipc_request_stop(uid);
1201                 if (false == __is_ipc_retry_needed(client, ret)) {
1202                         break;
1203                 }
1204         }
1205
1206         if (TTS_ERROR_NONE != ret) {
1207                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1208                 return ret;
1209         }
1210
1211         return tts_core_notify_state_changed(client, TTS_STATE_READY);
1212 }
1213
1214 int tts_core_pause(tts_client_s* client)
1215 {
1216         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1217
1218         unsigned int uid = tts_client_get_uid(client);
1219         int ret = -1;
1220         tts_client_set_reprepared(client, false);
1221         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1222                 ret = tts_ipc_request_pause(uid);
1223                 if (false == __is_ipc_retry_needed(client, ret)) {
1224                         break;
1225                 }
1226         }
1227
1228         if (TTS_ERROR_NONE != ret) {
1229                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1230                 return ret;
1231         }
1232
1233         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_pause");
1234         return tts_core_notify_state_changed(client, TTS_STATE_PAUSED);
1235 }
1236
1237 int tts_core_repeat(tts_client_s* client, char** text_repeat, int* utt_id)
1238 {
1239         RETVM_IF(NULL == text_repeat || NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Parameter is invalid.");
1240         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1241
1242         const char* repeat_text = tts_client_get_repeat_text(client);
1243         if (NULL == repeat_text) {
1244                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
1245                 return TTS_ERROR_OPERATION_FAILED;
1246         }
1247
1248         int new_utt_id = -1;
1249         int ret = __request_add_text(client, repeat_text, g_language, g_voice_type, g_speed, &new_utt_id);
1250         if (TTS_ERROR_NONE != ret) {
1251                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
1252                 return ret;
1253         }
1254
1255         /* Play added texts */
1256         ret = __request_play(client);
1257         if (TTS_ERROR_NONE != ret) {
1258                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
1259                 return ret;
1260         }
1261
1262         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", repeat_text, new_utt_id);
1263
1264         *utt_id = new_utt_id;
1265         *text_repeat = strdup(repeat_text);
1266         return TTS_ERROR_NONE;
1267 }
1268
1269 int tts_core_add_pcm(tts_client_s* client, int event, const void* data, unsigned int data_size, int audio_type, int rate)
1270 {
1271         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1272
1273         unsigned int uid = tts_client_get_uid(client);
1274         int ret = -1;
1275         tts_client_set_reprepared(client, false);
1276         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1277                 ret = tts_ipc_request_add_pcm(uid, event, data, data_size, audio_type, rate);
1278                 if (false == __is_ipc_retry_needed(client, ret)) {
1279                         break;
1280                 }
1281         }
1282
1283         if (TTS_ERROR_NONE != ret) {
1284                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1285                 return ret;
1286         }
1287
1288         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_add_pcm");
1289         return TTS_ERROR_NONE;
1290 }
1291
1292 int tts_core_play_pcm(tts_client_s* client)
1293 {
1294         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1295
1296         unsigned int uid = tts_client_get_uid(client);
1297         int ret = -1;
1298         tts_client_set_reprepared(client, false);
1299         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1300                 ret = tts_ipc_request_play_pcm(uid);
1301                 if (false == __is_ipc_retry_needed(client, ret)) {
1302                         break;
1303                 }
1304         }
1305
1306         if (TTS_ERROR_NONE != ret) {
1307                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1308                 return ret;
1309         }
1310
1311         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_play_pcm");
1312         return tts_core_notify_state_changed(client, TTS_STATE_PLAYING);
1313 }
1314
1315 int tts_core_stop_pcm(tts_client_s* client)
1316 {
1317         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1318
1319         unsigned int uid = tts_client_get_uid(client);
1320         int ret = -1;
1321         tts_client_set_reprepared(client, false);
1322         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1323                 ret = tts_ipc_request_stop_pcm(uid);
1324                 if (false == __is_ipc_retry_needed(client, ret)) {
1325                         break;
1326                 }
1327         }
1328
1329         if (TTS_ERROR_NONE != ret) {
1330                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1331                 return ret;
1332         }
1333
1334         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_stop_pcm");
1335         return tts_core_notify_state_changed(client, TTS_STATE_READY);
1336 }
1337
1338 int tts_core_set_private_data(tts_client_s* client, const char* key, const char* data)
1339 {
1340         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1341
1342         unsigned int uid = tts_client_get_uid(client);
1343         int ret = -1;
1344         tts_client_set_reprepared(client, false);
1345         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1346                 ret = tts_ipc_request_set_private_data(uid, key, data);
1347                 if (false == __is_ipc_retry_needed(client, ret)) {
1348                         break;
1349                 }
1350         }
1351
1352         if (TTS_ERROR_NONE != ret) {
1353                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1354                 return ret;
1355         }
1356
1357         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_set_private_data");
1358         return TTS_ERROR_NONE;
1359 }
1360
1361 int tts_core_get_private_data(tts_client_s* client, const char* key, char** data)
1362 {
1363         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1364
1365         unsigned int uid = tts_client_get_uid(client);
1366         int ret = -1;
1367         tts_client_set_reprepared(client, false);
1368         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1369                 ret = tts_ipc_request_get_private_data(uid, key, data);
1370                 if (false == __is_ipc_retry_needed(client, ret)) {
1371                         break;
1372                 }
1373         }
1374
1375         if (TTS_ERROR_NONE != ret) {
1376                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1377                 return ret;
1378         }
1379
1380         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1381                 free(*data);
1382                 *data = NULL;
1383         }
1384
1385         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_get_private_data");
1386         return TTS_ERROR_NONE;
1387 }