Clear data when AUDIO_POLICY_BLOCKED is occurred

[platform/core/uifw/tts.git] / client / tts.c

diff --git a/client/tts.c b/client/tts.c
index 5ca6f36..64c073e 100644 (file)
--- a/client/tts.c
+++ b/client/tts.c
@@ -27,6 +27,7 @@
 #include "tts_dbus.h"
 #include "tts_main.h"
 
+#include "tts_internal.h"
 
 static bool g_screen_reader;
 
@@ -217,13 +218,12 @@ int tts_create(tts_h* tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Create TTS");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Create TTS");
 
        /* check param */
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -259,7 +259,7 @@ int tts_create(tts_h* tts)
                return __tts_convert_config_error_code(ret);
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        SLOG(LOG_DEBUG, TAG_TTSC, " ");
 
        return TTS_ERROR_NONE;
@@ -271,7 +271,7 @@ int tts_destroy(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Destroy TTS");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Destroy TTS");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
@@ -357,8 +357,7 @@ int tts_destroy(tts_h tts)
 
        tts = NULL;
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -374,31 +373,30 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Set TTS mode(%d)", mode);
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Set TTS mode(%d)", mode);
 
        tts_client_s* client = tts_client_get(tts);
 
        /* check handle */
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
        /* check state */
        if (client->current_state != TTS_STATE_CREATED) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                SLOG(LOG_DEBUG, TAG_TTSC, " ");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_SCREEN_READER) {
+       if (TTS_MODE_DEFAULT <= mode && mode <= TTS_MODE_INTERRUPT) {
                client->mode = mode;
        } else {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] mode is not valid : %d", mode);
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                SLOG(LOG_DEBUG, TAG_TTSC, " ");
                return TTS_ERROR_INVALID_PARAMETER;
        }
@@ -417,8 +415,7 @@ int tts_set_mode(tts_h tts, tts_mode_e mode)
                tts_config_unset_screen_reader_callback(client->uid);
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -429,14 +426,14 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Get TTS mode");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get TTS mode");
 
        tts_client_s* client = tts_client_get(tts);
 
        /* check handle */
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                SLOG(LOG_DEBUG, TAG_TTSC, " ");
                return TTS_ERROR_INVALID_PARAMETER;
        }
@@ -444,7 +441,7 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
        /* check state */
        if (client->current_state != TTS_STATE_CREATED) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                SLOG(LOG_DEBUG, TAG_TTSC, " ");
                return TTS_ERROR_INVALID_STATE;
        }
@@ -456,7 +453,7 @@ int tts_get_mode(tts_h tts, tts_mode_e* mode)
 
        *mode = client->mode;
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
        SLOG(LOG_DEBUG, TAG_TTSC, " ");
 
        return TTS_ERROR_NONE;
@@ -491,8 +488,7 @@ int tts_set_credential(tts_h tts, const char* credential)
        }
        client->credential = strdup(credential);
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -533,6 +529,10 @@ int tts_set_server_tts(tts_h tts, const char* credential)
                client->credential = strdup(credential);
                if (NULL == client->credential) {
                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to allocate memory");
+                       if (NULL != key) {
+                               free(key);
+                               key = NULL;
+                       }
                        return TTS_ERROR_OUT_OF_MEMORY;
                }
        } else {
@@ -547,10 +547,14 @@ int tts_set_server_tts(tts_h tts, const char* credential)
        int pid = getpid();
        char* appid = NULL;
        int ret = app_manager_get_app_id(pid, &appid);
-       if (0 != ret) {
+       if (0 != ret || NULL == appid) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get appid, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
                free(key);
                key = NULL;
+               if (NULL != appid) {
+                       free(appid);
+                       appid = NULL;
+               }
                return TTS_ERROR_OPERATION_FAILED;
        }
 
@@ -559,6 +563,8 @@ int tts_set_server_tts(tts_h tts, const char* credential)
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to set private data, ret(%d), pid(%d), appid(%s)", ret, pid, appid);
                free(key);
                key = NULL;
+               free(appid);
+               appid = NULL;
                return ret;
        }
 
@@ -567,8 +573,7 @@ int tts_set_server_tts(tts_h tts, const char* credential)
        free(key);
        key = NULL;
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -589,7 +594,7 @@ static Eina_Bool __tts_connect_daemon(void *data)
                return EINA_TRUE;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Connect daemon");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Connect daemon");
 
        /* do request initialize */
        int ret = -1;
@@ -607,6 +612,16 @@ static Eina_Bool __tts_connect_daemon(void *data)
                client->conn_timer = NULL;
                return EINA_FALSE;
 
+       } else if (TTS_ERROR_PERMISSION_DENIED == ret) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to initialize : %s", __tts_get_error_code(ret));
+
+               client->reason = TTS_ERROR_PERMISSION_DENIED;
+               client->utt_id = -1;
+
+               ecore_timer_add(0, __tts_notify_error, (void*)client->tts);
+               client->conn_timer = NULL;
+               return EINA_FALSE;
+
        } else if (TTS_ERROR_NONE != ret) {
                SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Fail to connection. Retry to connect : %s", __tts_get_error_code(ret));
                return EINA_TRUE;
@@ -637,8 +652,7 @@ static Eina_Bool __tts_connect_daemon(void *data)
                SLOG(LOG_WARN, TAG_TTSC, "State changed callback is NULL");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return EINA_FALSE;
 }
@@ -649,30 +663,66 @@ int tts_prepare(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Prepare TTS");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
 
        tts_client_s* client = tts_client_get(tts);
 
        /* check handle */
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
        /* check state */
        if (client->current_state != TTS_STATE_CREATED) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_STATE;
        }
 
-       client->conn_timer = ecore_timer_add(0, __tts_connect_daemon, (void*)tts);
+       client->conn_timer = ecore_timer_add(0.02, __tts_connect_daemon, (void*)tts);
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+       return TTS_ERROR_NONE;
+}
+
+int tts_prepare_sync(tts_h tts)
+{
+       if (0 != __tts_get_feature_enabled()) {
+               return TTS_ERROR_NOT_SUPPORTED;
+       }
+
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Prepare TTS");
+
+       tts_client_s* client = tts_client_get(tts);
+
+       /* check handle */
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not available");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       /* check state */
+       if (client->current_state != TTS_STATE_CREATED) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Invalid State: Current state is not 'CREATED'");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       int cnt = 0;
+       while (EINA_TRUE == __tts_connect_daemon((void*)tts) && TTS_CONNECTION_RETRY_COUNT > cnt) {
+               cnt++;
+       }
+
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+       if (TTS_CONNECTION_RETRY_COUNT == cnt) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to connect daemon");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
 
        return TTS_ERROR_NONE;
 }
@@ -683,7 +733,7 @@ int tts_unprepare(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Unprepare TTS");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Unprepare TTS");
 
        tts_client_s* client = tts_client_get(tts);
 
@@ -711,11 +761,18 @@ int tts_unprepare(tts_h tts)
                g_screen_reader = (bool)screen_reader;
        }
 
+       bool is_prepared = false;
        if (!(false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode)) {
                do {
                        ret = tts_dbus_request_finalize(client->uid);
                        if (0 != ret) {
-                               if (TTS_ERROR_TIMED_OUT != ret) {
+                               if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                                       client->current_state = TTS_STATE_CREATED;
+                                       if (0 == tts_prepare_sync(tts)) {
+                                               is_prepared = true;
+                                               SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                                       }
+                               } else if (TTS_ERROR_TIMED_OUT != ret) {
                                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                        break;
                                } else {
@@ -743,8 +800,7 @@ int tts_unprepare(tts_h tts)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -775,12 +831,11 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Foreach supported voices");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Foreach supported voices");
 
        if (NULL == tts || NULL == callback) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -789,8 +844,7 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
        /* check handle */
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -820,8 +874,7 @@ int tts_foreach_supported_voices(tts_h tts, tts_supported_voice_cb callback, voi
                ret = TTS_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return ret;
 }
@@ -832,12 +885,11 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Get default voice");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Get default voice");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
 
        }
@@ -845,8 +897,7 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -860,8 +911,7 @@ int tts_get_default_voice(tts_h tts, char** lang, int* vctype)
                SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Default language(%s), type(%d)", *lang, *vctype);
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return ret;
 }
@@ -889,7 +939,6 @@ int tts_get_max_text_size(tts_h tts, unsigned int* size)
                return TTS_ERROR_INVALID_STATE;
        }
 
-//     *size = TTS_MAX_TEXT_SIZE;
        if (0 != tts_config_mgr_get_max_text_size(size)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get max text size");
                return TTS_ERROR_INVALID_PARAMETER;
@@ -983,8 +1032,7 @@ int tts_get_error_message(tts_h tts, char** err_msg)
                SLOG(LOG_DEBUG, TAG_TTSC, "[SUCCESS] Error msg (NULL)");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1007,12 +1055,11 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Add text");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Add text");
 
        if (NULL == tts || NULL == utt_id) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input parameter is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1020,8 +1067,7 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1040,25 +1086,23 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
 
        if (0 == g_max_text_size) {
                if (strlen(text) <= 0) {
+                       SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] Max Text Size is %d", g_max_text_size);
                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid. (max text size is unlimited.)");
-                       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-                       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+                       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                        return TTS_ERROR_INVALID_PARAMETER;
                }
        } else {
                SLOG(LOG_DEBUG, TAG_TTSC, "[DEBUG] g_max_text_size is %d", g_max_text_size);
                if (g_max_text_size < strlen(text) || strlen(text) <= 0) {
                        SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input text size is invalid.");
-                       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-                       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+                       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                        return TTS_ERROR_INVALID_PARAMETER;
                }
        }
 
        if (TTS_SPEED_AUTO > speed || TTS_SPEED_MAX < speed) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] speed value(%d) is invalid.", speed);
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1107,10 +1151,17 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
        /* do request */
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_add_text(client->uid, text, temp, voice_type, speed, client->current_utt_id, client->credential);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                break;
                        } else {
@@ -1132,8 +1183,7 @@ int tts_add_text(tts_h tts, const char* text, const char* language, int voice_ty
                temp = NULL;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return ret;
 }
@@ -1151,10 +1201,17 @@ static void __tts_play_async(void *data)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_play(client->uid, client->credential);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                break;
                        } else {
@@ -1189,8 +1246,7 @@ static void __tts_play_async(void *data)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return;
 }
@@ -1201,12 +1257,11 @@ int tts_play_async(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Play tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Play tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1214,8 +1269,7 @@ int tts_play_async(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1236,8 +1290,7 @@ int tts_play_async(tts_h tts)
 
        ecore_main_loop_thread_safe_call_async(__tts_play_async, (void*)tts);
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1248,12 +1301,11 @@ int tts_play(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Play tts");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Play tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1261,7 +1313,7 @@ int tts_play(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                SLOG(LOG_DEBUG, TAG_TTSC, " ");
                return TTS_ERROR_INVALID_PARAMETER;
        }
@@ -1283,10 +1335,17 @@ int tts_play(tts_h tts)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_play(client->uid, client->credential);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                return ret;
                        } else {
@@ -1311,8 +1370,7 @@ int tts_play(tts_h tts)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1330,10 +1388,17 @@ static void __tts_stop_async(void *data)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_stop(client->uid);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                break;
                        } else {
@@ -1368,8 +1433,7 @@ static void __tts_stop_async(void *data)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return;
 }
@@ -1380,12 +1444,11 @@ int tts_stop_aync(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Stop tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Stop tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1393,8 +1456,7 @@ int tts_stop_aync(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1410,8 +1472,7 @@ int tts_stop_aync(tts_h tts)
 
        ecore_main_loop_thread_safe_call_async(__tts_stop_async, (void*)tts);
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1422,12 +1483,11 @@ int tts_stop(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Stop tts");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1435,8 +1495,7 @@ int tts_stop(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1452,10 +1511,17 @@ int tts_stop(tts_h tts)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_stop(client->uid);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                return ret;
                        } else {
@@ -1480,8 +1546,7 @@ int tts_stop(tts_h tts)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1499,10 +1564,17 @@ static void __tts_pause_async(void *data)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_pause(client->uid);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                break;
                        } else {
@@ -1537,8 +1609,7 @@ static void __tts_pause_async(void *data)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return;
 }
@@ -1549,12 +1620,11 @@ int tts_pause_async(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "===== Pause tts");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Pause tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1562,15 +1632,13 @@ int tts_pause_async(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
        if (TTS_STATE_PLAYING != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_STATE;
        }
 
@@ -1581,8 +1649,7 @@ int tts_pause_async(tts_h tts)
 
        ecore_main_loop_thread_safe_call_async(__tts_pause_async, (void*)tts);
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1593,12 +1660,11 @@ int tts_pause(tts_h tts)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Pause tts");
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Pause tts");
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
@@ -1606,15 +1672,13 @@ int tts_pause(tts_h tts)
 
        if (NULL == client) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_PARAMETER;
        }
 
        if (TTS_STATE_PLAYING != client->current_state) {
                SLOG(LOG_ERROR, TAG_TTSC, "[Error] The Current state is NOT 'playing'. So this request should be not running.");
-               SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-               SLOG(LOG_DEBUG, TAG_TTSC, " ");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                return TTS_ERROR_INVALID_STATE;
        }
 
@@ -1625,10 +1689,17 @@ int tts_pause(tts_h tts)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_pause(client->uid);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                return ret;
                        } else {
@@ -1653,8 +1724,7 @@ int tts_pause(tts_h tts)
                SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, " ");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return TTS_ERROR_NONE;
 }
@@ -1665,7 +1735,7 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Set private data, key(%s), data(%s)", key, data);
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Set private data, key(%s), data(%s)", key, data);
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle isnull");
@@ -1696,10 +1766,17 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_set_private_data(client->uid, key, data);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                return ret;
                        } else {
@@ -1714,8 +1791,7 @@ int tts_set_private_data(tts_h tts, const char* key, const char* data)
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, "");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return 0;
 }
@@ -1726,7 +1802,7 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
                return TTS_ERROR_NOT_SUPPORTED;
        }
 
-       SLOG(LOG_INFO, TAG_TTSC, "===== Get private data, key(%s)", key);
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Get private data, key(%s)", key);
 
        if (NULL == tts) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null");
@@ -1752,10 +1828,17 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
 
        int ret = -1;
        int count = 0;
+       bool is_prepared = false;
        while (0 != ret) {
                ret = tts_dbus_request_get_private_data(client->uid, key, data);
                if (0 != ret) {
-                       if (TTS_ERROR_TIMED_OUT != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
                                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
                                return ret;
                        } else {
@@ -1775,8 +1858,7 @@ int tts_get_private_data(tts_h tts, const char* key, char** data)
                *data = NULL;
        }
 
-       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
-       SLOG(LOG_DEBUG, TAG_TTSC, "");
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 
        return 0;
 }
@@ -2365,3 +2447,214 @@ int tts_unset_engine_changed_cb(tts_h tts)
        return 0;
 }
 
+int tts_add_pcm(tts_h tts, int event, const void* data, unsigned int data_size, int audio_type, int rate)
+{
+       if (0 != __tts_get_feature_enabled()) {
+               return TTS_ERROR_NOT_SUPPORTED;
+       }
+
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Add pcm tts");
+
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_client_s* client = tts_client_get(tts);
+
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       if (TTS_STATE_CREATED == client->current_state) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       int ret = -1;
+       int count = 0;
+       bool is_prepared = false;
+       while (0 != ret) {
+               ret = tts_dbus_request_add_pcm(client->uid, event, data, data_size, audio_type, rate);
+               if (0 != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+                               return ret;
+                       } else {
+                               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry add pcm : %s", __tts_get_error_code(ret));
+                               usleep(10000);
+                               count++;
+                               if (TTS_RETRY_COUNT == count) {
+                                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+                                       return ret;
+                               }
+                       }
+               }
+       }
+
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+       return TTS_ERROR_NONE;
+}
+
+int tts_play_pcm(tts_h tts)
+{
+       if (0 != __tts_get_feature_enabled()) {
+               return TTS_ERROR_NOT_SUPPORTED;
+       }
+
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Play pcm tts");
+
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_client_s* client = tts_client_get(tts);
+
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       if (TTS_STATE_PLAYING == client->current_state || TTS_STATE_CREATED == client->current_state) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       int ret = -1;
+       int count = 0;
+       bool is_prepared = false;
+       while (0 != ret) {
+               ret = tts_dbus_request_play_pcm(client->uid);
+               if (0 != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+                               return ret;
+                       } else {
+                               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry play pcm : %s", __tts_get_error_code(ret));
+                               usleep(10000);
+                               count++;
+                               if (TTS_RETRY_COUNT == count) {
+                                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+                                       return ret;
+                               }
+                       }
+               }
+       }
+
+       client->before_state = client->current_state;
+       client->current_state = TTS_STATE_PLAYING;
+
+       if (NULL != client->state_changed_cb) {
+               tts_client_use_callback(client);
+               client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
+               tts_client_not_use_callback(client);
+               SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
+       }
+
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+       return TTS_ERROR_NONE;
+}
+
+int tts_stop_pcm(tts_h tts)
+{
+       if (0 != __tts_get_feature_enabled()) {
+               return TTS_ERROR_NOT_SUPPORTED;
+       }
+
+       SLOG(LOG_INFO, TAG_TTSC, "@@@ Stop pcm tts");
+
+       if (NULL == tts) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input handle is null.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       tts_client_s* client = tts_client_get(tts);
+
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] A handle is not valid.");
+               SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+               return TTS_ERROR_INVALID_PARAMETER;
+       }
+
+       if (TTS_STATE_CREATED == client->current_state) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] The current state is invalid.");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       if (false == g_screen_reader && TTS_MODE_SCREEN_READER == client->mode) {
+               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] Screen reader option is NOT available. Ignore this request");
+               return TTS_ERROR_INVALID_STATE;
+       }
+
+       int ret = -1;
+       int count = 0;
+       bool is_prepared = false;
+       while (0 != ret) {
+               ret = tts_dbus_request_stop_pcm(client->uid);
+               if (0 != ret) {
+                       if (TTS_ERROR_INVALID_PARAMETER == ret && false == is_prepared) {
+                               client->current_state = TTS_STATE_CREATED;
+                               if (0 == tts_prepare_sync(tts)) {
+                                       is_prepared = true;
+                                       SLOG(LOG_INFO, TAG_TTSC, "[INFO] Success tts_prepare_sync");
+                               }
+                       } else if (TTS_ERROR_TIMED_OUT != ret) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] result : %s", __tts_get_error_code(ret));
+                               return ret;
+                       } else {
+                               SLOG(LOG_WARN, TAG_TTSC, "[WARNING] retry stop pcm : %s", __tts_get_error_code(ret));
+                               usleep(10000);
+                               count++;
+                               if (TTS_RETRY_COUNT == count) {
+                                       SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to request");
+                                       return ret;
+                               }
+                       }
+               }
+       }
+
+       client->before_state = client->current_state;
+       client->current_state = TTS_STATE_READY;
+
+       if (NULL != client->state_changed_cb) {
+               tts_client_use_callback(client);
+               client->state_changed_cb(client->tts, client->before_state, client->current_state, client->state_changed_user_data);
+               tts_client_not_use_callback(client);
+               SLOG(LOG_DEBUG, TAG_TTSC, "State changed callback is called");
+       }
+
+       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
+
+       return TTS_ERROR_NONE;
+}