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         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
 420
 421         /* check service engine status */
 422         bool is_launched = __is_engine_launched();
 423         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 424         if (false == is_launched) {
 425                 /* If engine is NOT launched, check whether engine is updating or not */
 426                 if (g_engine_update_status) {
 427                         /* suyeon wait engine update */
 428                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] cannot prepare due to engine update");
 429                         __run_client_reprepare_thread();
 430                         return TTS_ERROR_INVALID_STATE;
 431                 }
 432         }
 433
 434         if (0 != tts_ipc_request_hello(uid)) {
 435                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request hello !!"); //LCOV_EXCL_LINE
 436         } else {
 437                 SLOG(LOG_INFO, TAG_TTSC, "@@@ Send Hello");
 438         }
 439
 440         return TTS_ERROR_NONE;
 441 }
 442
 443 static Eina_Bool __prepare_cb(void *data)
 444 {
 445         unsigned int uid = (uintptr_t)data;
 446         tts_client_s* client = tts_client_get_by_uid(uid);
 447         RETVM_IF(NULL == client, EINA_FALSE, "[ERROR] uid(%u) is not valid.", uid);
 448
 449         int ret = __send_hello_msg(client);
 450         if (ret != TTS_ERROR_NONE) {
 451                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to send hello message"); //LCOV_EXCL_LINE
 452                 client->hello_timer = NULL;
 453                 return EINA_FALSE;
 454         }
 455
 456         client->prepare_count++;
 457         if (TTS_HELLO_RETRY_COUNT == client->prepare_count) {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to prepare, retry count reaches the limit");
 459
 460                 bool is_launched = __is_engine_launched();
 461                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 462
 463                 client->hello_timer = NULL;
 464
 465                 tts_core_notify_error_async(client, TTS_ERROR_TIMED_OUT, -1, "[ERROR] Fail to prepare. Please call tts_prepare() again.");
 466
 467                 return EINA_FALSE;
 468         }
 469
 470         return EINA_TRUE;
 471 }
 472
 473 static Eina_Bool __prepare_first_cb(void *data)
 474 {
 475         /* send first hello message */
 476         unsigned int uid = (uintptr_t)data;
 477         tts_client_s* client = tts_client_get_by_uid(uid);
 478         RETVM_IF(NULL == client, EINA_FALSE, "[ERROR] uid(%u) is not valid.", uid);
 479
 480         int ret = __send_hello_msg(client);
 481         if (ret != TTS_ERROR_NONE) {
 482                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to sent hello message"); //LCOV_EXCL_LINE
 483                 client->hello_timer = NULL;
 484         } else {
 485                 /* Set retry timer callback */
 486                 client->prepare_count = 0;
 487                 client->hello_timer = ecore_timer_add(0.5, __prepare_cb, data);
 488         }
 489
 490         return EINA_FALSE;
 491 }
 492
 493 static int __prepare_sync_cb(tts_client_s* client)
 494 {
 495         // TODO: make function duplicated block
 496         bool is_launched = __is_engine_launched();
 497         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine is launched(%d)", is_launched);
 498
 499         if (false == is_launched) {
 500                 /* check whether engine is updating or not */
 501                 if (g_engine_update_status) {
 502                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Cannot prepare due to engine update.");
 503                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client automatically tries to reprepare asynchrnously.");
 504                         __run_client_reprepare_thread();
 505                         return TTS_ERROR_OPERATION_FAILED;
 506                 }
 507         }
 508
 509         // TODO: make function duplicated block
 510         unsigned int uid = tts_client_get_uid(client);
 511         if (TTS_ERROR_NONE != tts_ipc_request_hello_sync(uid)) {
 512                 return TTS_ERROR_FAIL_TO_SEND_HELLO;
 513         }
 514
 515         SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 516
 517         // TODO: make function duplicated block
 518         /* do request initialize */
 519         bool credential_needed = false;
 520         int ret = tts_ipc_request_initialize(uid, &credential_needed);
 521         if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == ret) {
 522                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize. ret(%d/%s)", ret, get_error_message(ret));
 523                 tts_core_notify_error_async(client, ret, -1, NULL);
 524
 525                 return ret;
 526         } else if (TTS_ERROR_NONE != ret) {
 527                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect. ret(%d/%s)", ret, get_error_message(ret));
 528                 return TTS_ERROR_FAIL_TO_SEND_HELLO;
 529         } else {
 530                 /* success to connect tts-daemon */
 531                 client->credential_needed = credential_needed;
 532                 SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%s)", credential_needed ? "need" : "no need");
 533         }
 534         // TODO: make function duplicated block
 535
 536         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 537         return TTS_ERROR_NONE;
 538 }
 539
 540 static void __engine_changed_cb(keynode_t* key, void* data)
 541 {
 542         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts engine vconfkey is changed");
 543         if (0 != __update_engine_name()) {
 544                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set engine name into core module");
 545         }
 546
 547         return;
 548 }
 549
 550 static bool __supported_voice_cb(const char* engine_id, const char* language, int type, void* user_data)
 551 {
 552         unsigned int uid = (uintptr_t)user_data;
 553         tts_client_s* client = tts_client_get_by_uid(uid);
 554         RETVM_IF(NULL == client, false, "[ERROR] uid(%u) is not valid.", uid);
 555
 556         /* call callback function */
 557         tts_supported_voice_cb callback = tts_client_get_supported_voice_cb(client);
 558         void* data = tts_client_get_supported_voice_user_data(client);
 559
 560         if (NULL == callback) {
 561                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get callback.");
 562                 return false;
 563         }
 564
 565         return callback(tts_client_get_handle(client), language, type, data);
 566 }
 567
 568 static bool __is_screen_reader_turned_on()
 569 {
 570         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Update screen reader state");
 571
 572         int screen_reader = 0;
 573         int ret = vconf_get_bool(TTS_ACCESSIBILITY_KEY, &screen_reader);
 574         if (0 != ret) {
 575                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get screen reader vconf(%d)", ret);
 576                 return false;
 577         }
 578
 579         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Current screen reader status(%d)", screen_reader);
 580         return (bool)screen_reader;
 581 }
 582
 583 static inline bool __is_ipc_retry_needed(tts_client_s* client, tts_error_e ret)
 584 {
 585         if (TTS_ERROR_NONE == ret) {
 586                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success the IPC request");
 587                 return false;
 588         }
 589
 590         if (TTS_ERROR_TIMED_OUT == ret) {
 591                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] IPC is failed. Try again. ret(%d/%s)", ret, get_error_message(ret));
 592                 usleep(10000);
 593                 return true;
 594         }
 595
 596         if (TTS_ERROR_INVALID_PARAMETER == ret && false == tts_client_is_reprepared(client)) {
 597                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] IPC is failed by unregistered client. ret(%d/%s)", ret, get_error_message(ret));
 598                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Try to prepare again");
 599                 tts_client_set_current_state(client, TTS_STATE_CREATED);
 600                 tts_core_prepare_sync(client);
 601                 tts_client_set_reprepared(client, true);
 602                 return true;
 603         }
 604
 605         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] IPC request is failed. ret(%d/%s)", ret, get_error_message(ret));
 606         return false;
 607 }
 608
 609 static inline int __request_add_text(tts_client_s* client, const char* text, const char* language, int voice_type, int speed, int* utt_id)
 610 {
 611         /* change default language value */
 612         const char* convert_language = (NULL == language ? "default" : language);
 613         int new_utt_id = tts_client_new_utterance_id(client);
 614         if (0 > new_utt_id) {
 615                 return TTS_ERROR_OPERATION_FAILED;
 616         }
 617
 618         // TODO: If use cpp, remove dupliceated code using command class pattern
 619         unsigned int uid = tts_client_get_uid(client);
 620         int ret = -1;
 621         tts_client_set_reprepared(client, false);
 622         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
 623                 ret = tts_ipc_request_add_text(uid, text, convert_language, voice_type, speed, new_utt_id, client->credential);
 624                 if (false == __is_ipc_retry_needed(client, ret)) {
 625                         break;
 626                 }
 627         }
 628
 629         if (TTS_ERROR_NONE != ret) {
 630                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 631                 return ret;
 632         }
 633
 634         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_add_text");
 635         *utt_id = new_utt_id;
 636         return TTS_ERROR_NONE;
 637 }
 638
 639 static inline int __request_play(tts_client_s* client)
 640 {
 641         unsigned int uid = tts_client_get_uid(client);
 642         int ret = -1;
 643         tts_client_set_reprepared(client, false);
 644         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
 645                 ret = tts_ipc_request_play(uid, client->credential);
 646                 if (false == __is_ipc_retry_needed(client, ret)) {
 647                         break;
 648                 }
 649         }
 650
 651         if (TTS_ERROR_NONE != ret) {
 652                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
 653                 return ret;
 654         }
 655
 656         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_play");
 657         return tts_core_notify_state_changed(client, TTS_STATE_PLAYING);
 658 }
 659
 660 int tts_core_initialize()
 661 {
 662         ecore_main_loop_thread_safe_call_async(__pkgmgr_thread, NULL);
 663
 664         if (0 != __update_engine_name()) {
 665                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set engine name into core module");
 666         }
 667         g_is_engine_name_changed = false;
 668
 669         /* Register vconfkey callback to detect engine change */
 670         vconf_notify_key_changed(TTS_ENGINE_DB_DEFAULT, __engine_changed_cb, NULL);
 671
 672         return TTS_ERROR_NONE;
 673 }
 674
 675 int tts_core_deinitialize()
 676 {
 677         if (NULL != g_reprepare_thread && EINA_FALSE == ecore_thread_check(g_reprepare_thread)) {
 678                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Cancel reprepare thread");
 679                 ecore_thread_cancel(g_reprepare_thread);
 680                 ecore_thread_wait(g_reprepare_thread, 0.5);             // wait g_reprepare_thread is terminated.
 681         }
 682
 683         if (NULL != g_pkgmgr_thread) {
 684                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Cancel pkgmgr thread");
 685                 g_is_thread_canceled = true;
 686         }
 687
 688         if (NULL != g_language) {
 689                 free(g_language);
 690                 g_language = NULL;
 691         }
 692
 693         if (NULL != g_engine_name) {
 694                 free(g_engine_name);
 695                 g_engine_name = NULL;
 696         }
 697
 698         pthread_mutex_lock(&g_pkgmgr_mutex);
 699         if (NULL != g_pkgmgr) {
 700                 pkgmgr_client_remove_listen_status(g_pkgmgr);
 701                 pkgmgr_client_free(g_pkgmgr);
 702                 g_pkgmgr = NULL;
 703         }
 704
 705         if (NULL != g_pkgmgr_status) {
 706                 free(g_pkgmgr_status);
 707                 g_pkgmgr_status = NULL;
 708         }
 709         pthread_mutex_unlock(&g_pkgmgr_mutex);
 710
 711         /* Unregister vconfkey callback */
 712         vconf_ignore_key_changed(TTS_ENGINE_DB_DEFAULT, __engine_changed_cb);
 713
 714         return TTS_ERROR_NONE;
 715 }
 716
 717 int tts_core_notify_state_changed(tts_client_s* client, tts_state_e current_state)
 718 {
 719         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 720
 721         tts_state_e before_state = tts_client_get_current_state(client);
 722         if (before_state == current_state) {
 723                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] State is not changed. before(%s), current(%s)", __convert_state(before_state), __convert_state(current_state));
 724                 return TTS_ERROR_NONE;
 725         }
 726
 727         SLOG(LOG_DEBUG, TAG_TTSC, "State changed to (%s).", __convert_state(current_state));
 728         tts_client_set_current_state(client, current_state);
 729         __client_state_changed_cb(client, before_state, current_state);
 730
 731         return TTS_ERROR_NONE;
 732 }
 733
 734 int tts_core_notify_utt_started(tts_client_s* client, int utt_id)
 735 {
 736         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 737
 738         client->utt_id = utt_id;
 739         SLOG(LOG_DEBUG, TAG_TTSC, "Utterance started data : utt_id(%d)", client->utt_id);
 740
 741         tts_utterance_started_cb callback = tts_client_get_utterance_started_cb(client);
 742         void* data = tts_client_get_utterance_started_user_data(client);
 743
 744         if (NULL != callback) {
 745                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
 746                 tts_client_use_callback(client);
 747                 callback(tts_client_get_handle(client), client->utt_id, data);
 748                 tts_client_not_use_callback(client);
 749         } else {
 750                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_started)");
 751         }
 752
 753         return TTS_ERROR_NONE;
 754 }
 755
 756 int tts_core_notify_utt_completeted(tts_client_s* client, int utt_id)
 757 {
 758         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 759
 760         client->utt_id = utt_id;
 761         SLOG(LOG_DEBUG, TAG_TTSC, "Utterance completed data : utt_id(%d)", utt_id);
 762
 763         tts_utterance_completed_cb callback = tts_client_get_utterance_completed_cb(client);
 764         void* data = tts_client_get_utterance_completed_user_data(client);
 765
 766         if (NULL != callback) {
 767                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify utterance started");
 768                 tts_client_use_callback(client);
 769                 callback(tts_client_get_handle(client), utt_id, data);
 770                 tts_client_not_use_callback(client);
 771         } else {
 772                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(utt_completed)");
 773         }
 774
 775         return TTS_ERROR_NONE;
 776 }
 777
 778 int tts_core_notify_error_async(tts_client_s* client, tts_error_e reason, int utt_id, const char* err_msg)
 779 {
 780         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 781
 782         SLOG(LOG_DEBUG, TAG_TTSC, "Error data : utt_id(%d) reason(%s)", utt_id, tts_core_covert_error_code(reason));
 783         client->utt_id = utt_id;
 784         client->reason = reason;
 785         tts_client_set_error_message(client, err_msg);
 786
 787         SLOG(LOG_DEBUG, TAG_TTSC, "Notify error asynchronously");
 788         if (NULL != client->notify_error_timer) {
 789                 ecore_timer_del(client->notify_error_timer);
 790         }
 791
 792         uintptr_t uid = tts_client_get_uid(client);
 793         client->notify_error_timer = ecore_timer_add(0, __notify_error_timer_cb, (void*)uid);
 794
 795         return TTS_ERROR_NONE;
 796 }
 797
 798 //LCOV_EXCL_START
 799 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)
 800 {
 801         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 802
 803         SLOG(LOG_DEBUG, TAG_TTSC, "Default voice changed data : before_lang(%s), before_voice_type(%d), language(%s), voice_type(%d)",
 804                         before_lang, before_voice_type, language, voice_type);
 805
 806         tts_default_voice_changed_cb callback = tts_client_get_default_voice_changed_cb(client);
 807         void* data = tts_client_get_default_voice_changed_user_data(client);
 808
 809         if (NULL != callback) {
 810                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify default voice changed");
 811                 tts_client_use_callback(client);
 812                 callback(tts_client_get_handle(client), before_lang, before_voice_type, language, voice_type, data);
 813                 tts_client_not_use_callback(client);
 814         } else {
 815                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(default_voice_changed)");
 816         }
 817
 818         return TTS_ERROR_NONE;
 819 }
 820
 821 int tts_core_notify_engine_changed(tts_client_s* client, const char* engine_id, const char* language, int voice_type, bool need_credential)
 822 {
 823         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 824
 825         SLOG(LOG_DEBUG, TAG_TTSC, "Engine changed data : engine_id(%s) language(%s), voicd_type(%d), need_credential(%d)",
 826                         engine_id, language, voice_type, need_credential);
 827
 828         tts_engine_changed_cb callback = tts_client_get_engine_changed_cb(client);
 829         void* data = tts_client_get_engine_changed_user_data(client);
 830
 831         if (NULL != callback) {
 832                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify engine changed");
 833                 tts_client_use_callback(client);
 834                 callback(tts_client_get_handle(client), engine_id, language, voice_type, need_credential, data);
 835                 tts_client_not_use_callback(client);
 836         } else {
 837                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(engine_changed)");
 838         }
 839
 840         return TTS_ERROR_NONE;
 841 }
 842 //LCOV_EXCL_STOP
 843
 844 int tts_core_notify_screen_reader_changed(tts_client_s* client, bool value)
 845 {
 846         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
 847
 848         SLOG(LOG_DEBUG, TAG_TTSC, "Screen reader is changed. Current status(%d)", value);
 849
 850         tts_screen_reader_changed_cb callback = tts_client_get_screen_reader_changed_cb(client);
 851         void* data = tts_client_get_screen_reader_changed_user_data(client);
 852
 853         if (NULL != callback) {
 854                 SLOG(LOG_DEBUG, TAG_TTSC, "Notify screen reader changed");
 855                 tts_client_use_callback(client);
 856                 callback(tts_client_get_handle(client), value, data);
 857                 tts_client_not_use_callback(client);
 858         } else {
 859                 SLOG(LOG_WARN, TAG_TTSC, "No registered callback(screen_reader_changed)");
 860         }
 861
 862         return TTS_ERROR_NONE;
 863 }
 864
 865 bool tts_core_is_valid_text(const char* text)
 866 {
 867         if (NULL == text) {
 868                 return false;
 869         }
 870
 871         /* check valid utf8 */
 872         DBusError err;
 873         dbus_error_init(&err);
 874         bool valid = dbus_validate_utf8(text, &err);
 875         if (dbus_error_is_set(&err)) {
 876                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Error(%s), text(%s)", err.message, text);
 877                 dbus_error_free(&err);
 878                 return false;
 879         }
 880
 881         if (false == valid) {
 882                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Text is invalid - '%s'", text);
 883                 return false;
 884         }
 885
 886         if (strlen(text) <= 0) {
 887                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
 888                 return false;
 889         }
 890
 891         unsigned int max_text_size = 0;
 892         /* check text size */
 893         if (0 != tts_config_mgr_get_max_text_size(&max_text_size)) {
 894                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
 895                 return false;
 896         }
 897
 898         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] max_text_size is %d byte", max_text_size);
 899         if (0 < max_text_size && max_text_size < strlen(text)) {
 900                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is bigger than maximum test size. text_size(%zu byte)", strlen(text));
 901                 return false;
 902         }
 903
 904         return true;
 905 }
 906
 907 bool tts_core_check_screen_reader(tts_client_s* client)
 908 {
 909         RETVM_IF(false == tts_client_is_valid_client(client), false, "[ERROR] Client is invalid.");
 910
 911         tts_mode_e mode = tts_client_get_mode(client);
 912         if (TTS_MODE_SCREEN_READER == mode && false == __is_screen_reader_turned_on()) {
 913                 return false;
 914         }
 915
 916         return true;
 917 }
 918
 919 bool tts_core_check_credential(tts_client_s* client)
 920 {
 921         RETVM_IF(false == tts_client_is_valid_client(client), false, "[ERROR] Client is invalid.");
 922
 923         if (true == client->credential_needed && NULL == tts_client_get_credential_key(client)) {
 924                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Do not have app credential for this engine");
 925                 return false;
 926         }
 927
 928         return true;
 929 }
 930
 931 //LCOV_EXCL_START
 932 const char* tts_core_covert_error_code(tts_error_e err)
 933 {
 934         switch (err) {
 935         case TTS_ERROR_NONE:                    return "TTS_ERROR_NONE";
 936         case TTS_ERROR_OUT_OF_MEMORY:           return "TTS_ERROR_OUT_OF_MEMORY";
 937         case TTS_ERROR_IO_ERROR:                return "TTS_ERROR_IO_ERROR";
 938         case TTS_ERROR_INVALID_PARAMETER:       return "TTS_ERROR_INVALID_PARAMETER";
 939         case TTS_ERROR_OUT_OF_NETWORK:          return "TTS_ERROR_OUT_OF_NETWORK";
 940         case TTS_ERROR_TIMED_OUT:               return "TTS_ERROR_TIMED_OUT";
 941         case TTS_ERROR_PERMISSION_DENIED:       return "TTS_ERROR_PERMISSION_DENIED";
 942         case TTS_ERROR_NOT_SUPPORTED:           return "TTS_ERROR_NOT_SUPPORTED";
 943         case TTS_ERROR_INVALID_STATE:           return "TTS_ERROR_INVALID_STATE";
 944         case TTS_ERROR_INVALID_VOICE:           return "TTS_ERROR_INVALID_VOICE";
 945         case TTS_ERROR_ENGINE_NOT_FOUND:        return "TTS_ERROR_ENGINE_NOT_FOUND";
 946         case TTS_ERROR_OPERATION_FAILED:        return "TTS_ERROR_OPERATION_FAILED";
 947         case TTS_ERROR_AUDIO_POLICY_BLOCKED:    return "TTS_ERROR_AUDIO_POLICY_BLOCKED";
 948         case TTS_ERROR_NOT_SUPPORTED_FEATURE:   return "TTS_ERROR_NOT_SUPPORTED_FEATURE";
 949         case TTS_ERROR_SERVICE_RESET:           return "TTS_ERROR_SERVICE_RESET";
 950         case TTS_ERROR_SCREEN_READER_OFF:       return "TTS_ERROR_SCREEN_READER_OFF";
 951         default:
 952                 return "Invalid error code";
 953         }
 954         return NULL;
 955 }
 956 //LCOV_EXCL_STOP
 957
 958 int tts_core_receive_hello(unsigned int uid, int ret, int credential_needed)
 959 {
 960         tts_client_s* client = tts_client_get_by_uid(uid);
 961         RETVM_IF(NULL == client, TTS_ERROR_OPERATION_FAILED, "Fail to get TTS client or ignore this uid(%u)", uid);
 962
 963         tts_state_e current_state = tts_client_get_current_state(client);
 964         RETVM_IF(TTS_STATE_CREATED != current_state, TTS_ERROR_NONE, "[INFO] tts client is already READY");
 965
 966         if (client->hello_timer) {
 967                 ecore_timer_del(client->hello_timer);
 968                 client->hello_timer = NULL;
 969         }
 970
 971         if (TTS_ERROR_ENGINE_NOT_FOUND == ret || TTS_ERROR_PERMISSION_DENIED == ret) {
 972                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", tts_core_covert_error_code(ret));
 973                 tts_core_notify_error_async(client, ret, -1, NULL);
 974
 975                 return TTS_ERROR_OPERATION_FAILED;
 976         } else if (TTS_ERROR_ALREADY_INITIALIZED == ret) {
 977                 /* success to connect tts-daemon */
 978                 if (TTS_CREDENTIAL_NEEDED_ALREADY_INITIALIZED != credential_needed) {
 979                         client->credential_needed = credential_needed;
 980                         SLOG(LOG_ERROR, TAG_TTSC, "Supported options : credential(%d)", credential_needed);
 981                 }
 982         } else if (TTS_ERROR_NONE != ret) {
 983                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", tts_core_covert_error_code(ret));
 984                 return TTS_ERROR_OPERATION_FAILED;
 985         }
 986
 987         tts_ipc_request_set_mode(uid, tts_client_get_mode(client));
 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_ipc_request_set_mode(uid, tts_client_get_mode(client));
1054         tts_core_notify_state_changed(client, TTS_STATE_READY);
1055
1056         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
1057         return TTS_ERROR_NONE;
1058 }
1059
1060 int tts_core_unprepare(tts_client_s* client)
1061 {
1062         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1063
1064         unsigned int uid = tts_client_get_uid(client);
1065         SLOG(LOG_INFO, TAG_TTSC, "[INFO] tts_h(%p), tts_client(%p), uid(%u)", tts_client_get_handle(client), client, uid);
1066         if (client->hello_timer) {
1067                 ecore_timer_del(client->hello_timer);
1068                 client->hello_timer = NULL;
1069         }
1070
1071         int ret = -1;
1072         if (false == tts_core_check_screen_reader(client)) {
1073                 SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Do not request finalize. Handled by screen reader");
1074
1075                 ret = tts_ipc_stop_listening(uid);
1076                 if (0 != ret) {
1077                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to remove match : %s", tts_core_covert_error_code(ret));
1078                 }
1079         } else {
1080                 SLOG(LOG_INFO, TAG_TTSC, "[INFO] Request finalize");
1081
1082                 tts_client_set_reprepared(client, false);
1083                 for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1084                         ret = tts_ipc_request_finalize(uid);
1085                         if (false == __is_ipc_retry_needed(client, ret)) {
1086                                 break;
1087                         }
1088                 }
1089
1090                 if (TTS_ERROR_NONE == ret) {
1091                         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_finalize");
1092                 }
1093         }
1094
1095         return TTS_ERROR_NONE;
1096 }
1097
1098 int tts_core_reprepare()
1099 {
1100         GList* clients = tts_client_get_client_list();
1101         RETVM_IF(NULL == clients, TTS_ERROR_OPERATION_FAILED, "[ERROR] Fail to get client list");
1102
1103         GList *iter = NULL;
1104         if (g_list_length(clients) > 0) {
1105                 iter = g_list_first(clients);
1106
1107                 while (NULL != iter) {
1108                         tts_client_s* client = iter->data;
1109                         if (true == tts_client_is_valid_client(client)) {
1110                                 tts_client_set_current_state(client, TTS_STATE_CREATED);
1111                         }
1112
1113                         iter = g_list_next(iter);
1114                 }
1115         }
1116
1117         g_list_free(clients);
1118         __run_client_reprepare_thread();
1119
1120         return TTS_ERROR_NONE;
1121 }
1122
1123 int tts_core_foreach_supported_voices(tts_client_s* client, const char* engine_id, tts_supported_voice_cb callback, void* user_data)
1124 {
1125         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1126
1127         tts_client_set_supported_voice_cb(client, callback, user_data);
1128         uintptr_t uid = tts_client_get_uid(client);
1129         int ret = tts_config_mgr_get_voice_list(engine_id, __supported_voice_cb, (void*)uid);
1130         tts_client_set_supported_voice_cb(client, NULL, NULL);
1131
1132         if (0 != ret) {
1133                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get voice list");
1134                 return TTS_ERROR_OPERATION_FAILED;
1135         }
1136
1137         return TTS_ERROR_NONE;
1138 }
1139
1140 int tts_core_handle_service_reset()
1141 {
1142         GList* client_list = tts_client_get_client_list();
1143         RETVM_IF(NULL == client_list, TTS_ERROR_OPERATION_FAILED, "[ERROR] Fail to get client list");
1144
1145         if (g_list_length(client_list) > 0) {
1146                 GList *iter = g_list_first(client_list);
1147                 while (NULL != iter) {
1148                         tts_client_s *client = iter->data;
1149                         if (false == tts_client_is_valid_client(client)) {
1150                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Client is not valid");
1151                         } else {
1152                                 tts_core_notify_error_async(client, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
1153                         }
1154
1155                         iter = g_list_next(iter);
1156                 }
1157         }
1158
1159         g_list_free(client_list);
1160
1161         SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Service Reset");
1162         tts_core_reprepare();
1163
1164         return TTS_ERROR_NONE;
1165 }
1166
1167 int tts_core_add_text(tts_client_s* client, const char* text, const char* language, int voice_type, int speed, int* utt_id)
1168 {
1169         RETVM_IF(NULL == text || NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Parameter is invalid.");
1170         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1171
1172         tts_client_set_repeat_text(client, text);
1173
1174         if (NULL != g_language) {
1175                 free(g_language);
1176         }
1177
1178         g_language = (NULL == language ? NULL : strdup(language));
1179         g_voice_type = voice_type;
1180         g_speed = speed;
1181
1182         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);
1183         return __request_add_text(client, text, language, voice_type, speed, utt_id);
1184 }
1185
1186 int tts_core_play(tts_client_s* client)
1187 {
1188         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1189
1190         return __request_play(client);
1191 }
1192
1193 int tts_core_stop(tts_client_s* client)
1194 {
1195         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1196
1197         unsigned int uid = tts_client_get_uid(client);
1198         int ret = -1;
1199         tts_client_set_reprepared(client, false);
1200         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1201                 ret = tts_ipc_request_stop(uid);
1202                 if (false == __is_ipc_retry_needed(client, ret)) {
1203                         break;
1204                 }
1205         }
1206
1207         if (TTS_ERROR_NONE != ret) {
1208                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1209                 return ret;
1210         }
1211
1212         return tts_core_notify_state_changed(client, TTS_STATE_READY);
1213 }
1214
1215 int tts_core_pause(tts_client_s* client)
1216 {
1217         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1218
1219         unsigned int uid = tts_client_get_uid(client);
1220         int ret = -1;
1221         tts_client_set_reprepared(client, false);
1222         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1223                 ret = tts_ipc_request_pause(uid);
1224                 if (false == __is_ipc_retry_needed(client, ret)) {
1225                         break;
1226                 }
1227         }
1228
1229         if (TTS_ERROR_NONE != ret) {
1230                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1231                 return ret;
1232         }
1233
1234         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_pause");
1235         return tts_core_notify_state_changed(client, TTS_STATE_PAUSED);
1236 }
1237
1238 int tts_core_repeat(tts_client_s* client, char** text_repeat, int* utt_id)
1239 {
1240         RETVM_IF(NULL == text_repeat || NULL == utt_id, TTS_ERROR_INVALID_PARAMETER, "[ERROR] Parameter is invalid.");
1241         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1242
1243         const char* repeat_text = tts_client_get_repeat_text(client);
1244         if (NULL == repeat_text) {
1245                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] There is no previous added texts. Please add texts");
1246                 return TTS_ERROR_OPERATION_FAILED;
1247         }
1248
1249         int new_utt_id = -1;
1250         int ret = __request_add_text(client, repeat_text, g_language, g_voice_type, g_speed, &new_utt_id);
1251         if (TTS_ERROR_NONE != ret) {
1252                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to add texts for repetition.");
1253                 return ret;
1254         }
1255
1256         /* Play added texts */
1257         ret = __request_play(client);
1258         if (TTS_ERROR_NONE != ret) {
1259                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to play texts for repetition.");
1260                 return ret;
1261         }
1262
1263         SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] text to repeat(%s), utt_id(%d)", repeat_text, new_utt_id);
1264
1265         *utt_id = new_utt_id;
1266         *text_repeat = strdup(repeat_text);
1267         return TTS_ERROR_NONE;
1268 }
1269
1270 int tts_core_add_pcm(tts_client_s* client, int event, const void* data, unsigned int data_size, int audio_type, int rate)
1271 {
1272         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1273
1274         unsigned int uid = tts_client_get_uid(client);
1275         int ret = -1;
1276         tts_client_set_reprepared(client, false);
1277         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1278                 ret = tts_ipc_request_add_pcm(uid, event, data, data_size, audio_type, rate);
1279                 if (false == __is_ipc_retry_needed(client, ret)) {
1280                         break;
1281                 }
1282         }
1283
1284         if (TTS_ERROR_NONE != ret) {
1285                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1286                 return ret;
1287         }
1288
1289         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_add_pcm");
1290         return TTS_ERROR_NONE;
1291 }
1292
1293 int tts_core_play_pcm(tts_client_s* client)
1294 {
1295         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1296
1297         unsigned int uid = tts_client_get_uid(client);
1298         int ret = -1;
1299         tts_client_set_reprepared(client, false);
1300         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1301                 ret = tts_ipc_request_play_pcm(uid);
1302                 if (false == __is_ipc_retry_needed(client, ret)) {
1303                         break;
1304                 }
1305         }
1306
1307         if (TTS_ERROR_NONE != ret) {
1308                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1309                 return ret;
1310         }
1311
1312         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_play_pcm");
1313         return tts_core_notify_state_changed(client, TTS_STATE_PLAYING);
1314 }
1315
1316 int tts_core_stop_pcm(tts_client_s* client)
1317 {
1318         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1319
1320         unsigned int uid = tts_client_get_uid(client);
1321         int ret = -1;
1322         tts_client_set_reprepared(client, false);
1323         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1324                 ret = tts_ipc_request_stop_pcm(uid);
1325                 if (false == __is_ipc_retry_needed(client, ret)) {
1326                         break;
1327                 }
1328         }
1329
1330         if (TTS_ERROR_NONE != ret) {
1331                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1332                 return ret;
1333         }
1334
1335         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_stop_pcm");
1336         return tts_core_notify_state_changed(client, TTS_STATE_READY);
1337 }
1338
1339 int tts_core_set_private_data(tts_client_s* client, const char* key, const char* data)
1340 {
1341         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1342
1343         unsigned int uid = tts_client_get_uid(client);
1344         int ret = -1;
1345         tts_client_set_reprepared(client, false);
1346         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1347                 ret = tts_ipc_request_set_private_data(uid, key, data);
1348                 if (false == __is_ipc_retry_needed(client, ret)) {
1349                         break;
1350                 }
1351         }
1352
1353         if (TTS_ERROR_NONE != ret) {
1354                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1355                 return ret;
1356         }
1357
1358         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_set_private_data");
1359         return TTS_ERROR_NONE;
1360 }
1361
1362 int tts_core_get_private_data(tts_client_s* client, const char* key, char** data)
1363 {
1364         RETVM_IF(false == tts_client_is_valid_client(client), TTS_ERROR_INVALID_PARAMETER, "[ERROR] Client is invalid.");
1365
1366         unsigned int uid = tts_client_get_uid(client);
1367         int ret = -1;
1368         tts_client_set_reprepared(client, false);
1369         for (int count = 0; count < TTS_RETRY_COUNT; count++) {
1370                 ret = tts_ipc_request_get_private_data(uid, key, data);
1371                 if (false == __is_ipc_retry_needed(client, ret)) {
1372                         break;
1373                 }
1374         }
1375
1376         if (TTS_ERROR_NONE != ret) {
1377                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
1378                 return ret;
1379         }
1380
1381         if (0 == strncmp(*data, "NULL", strlen(*data))) {
1382                 free(*data);
1383                 *data = NULL;
1384         }
1385
1386         SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_dbus_request_get_private_data");
1387         return TTS_ERROR_NONE;
1388 }