projects / platform / core / uifw / stt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[ACR-1449] Add new api to set audio type
[platform/core/uifw/stt.git] / server / sttd_server.c
diff --git a/server/sttd_server.c b/server/sttd_server.c
index 8fcee24..06c8c25 100644 (file)
--- a/server/sttd_server.c
+++ b/server/sttd_server.c
@@ -50,9 +50,11 @@ static GList *g_proc_list = NULL;
 /*
 * STT Server Callback Functions
 */
-void __stop_by_silence(void *data)
+static void __cancel_recognition_internal();
+
+Eina_Bool __stop_by_silence(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by silence detection");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop by silence detection");
 
        int uid = 0;
 
@@ -62,7 +64,8 @@ void __stop_by_silence(void *data)
        if (0 != uid) {
                ret = sttd_server_stop(uid);
                if (0 > ret) {
-                       return;
+                       __cancel_recognition_internal();
+                       return EINA_FALSE;
                }
 
                if (STTD_RESULT_STATE_DONE == ret) {
@@ -79,10 +82,10 @@ void __stop_by_silence(void *data)
                SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] uid is NOT valid");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
-       return;
+       return EINA_FALSE;
 }
 
 static void __cancel_recognition_internal()
@@ -105,6 +108,7 @@ static void __cancel_recognition_internal()
        }
 
        if (0 != uid && (APP_STATE_PROCESSING == state || APP_STATE_RECORDING == state)) {
+               SLOG(LOG_INFO, TAG_STTD, "===== cancel by internal");
                /* cancel engine recognition */
                ret = sttd_server_cancel(uid);
                if (0 != ret) {
@@ -117,7 +121,7 @@ static void __cancel_recognition_internal()
 
 static void __cancel_by_error(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by error");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by error");
 
        __cancel_recognition_internal();
 
@@ -164,7 +168,7 @@ int __server_audio_recorder_callback(const void* data, const unsigned int length
 
 void __server_audio_interrupt_callback()
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by sound interrupt");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by sound interrupt");
 
        __cancel_recognition_internal();
 
@@ -174,7 +178,7 @@ void __server_audio_interrupt_callback()
 
 void __cancel_by_no_record(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Cancel by no record");
+       SLOG(LOG_INFO, TAG_STTD, "===== Cancel by no record");
 
        __cancel_recognition_internal();
 
@@ -190,7 +194,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
        // critical section
        pthread_mutex_lock(&stte_result_mutex);
 
-       SLOG(LOG_DEBUG, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
+       SLOG(LOG_INFO, TAG_STTD, "===== RESULT event[%d] type[%s] data[%p] data_count[%d]", event, type, data, data_count);
 
        /* check uid */
        int uid = stt_client_get_current_recognition();
@@ -204,24 +208,29 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
+       SLOG(LOG_INFO, TAG_STTD, "[Server] uid (%d), event(%d)", uid, event);
 
        /* send result to client */
        if (STTE_RESULT_EVENT_FINAL_RESULT == event) {
                if (APP_STATE_PROCESSING != state) {
                        SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current state is NOT 'Processing'.");
                }
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] the size of result from engine is '%d'", data_count);
 
                /* Delete timer for processing time out */
                if (NULL != g_processing_timer) {
+                       ecore_thread_main_loop_begin();
+                       SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
                        ecore_timer_del(g_processing_timer);
                        g_processing_timer = NULL;
+                       ecore_thread_main_loop_end();
                }
 
                sttd_config_time_save();
                sttd_config_time_reset();
 
+               sttd_recorder_clear();
+
                sttd_client_set_state(uid, APP_STATE_READY);
                stt_client_unset_current_recognition();
 
@@ -250,7 +259,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
 //             stt_client_unset_current_recognition();
 
        } else if (STTE_RESULT_EVENT_PARTIAL_RESULT == event) {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] The partial result from engine is event[%d] data_count[%d]", event,  data_count);
 
                sttd_config_time_save();
                sttd_config_time_reset();
@@ -269,8 +278,11 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
 
                /* Delete timer for processing time out */
                if (NULL != g_processing_timer) {
+                       ecore_thread_main_loop_begin();
+                       SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
                        ecore_timer_del(g_processing_timer);
                        g_processing_timer = NULL;
+                       ecore_thread_main_loop_end();
                }
                sttd_config_time_reset();
 
@@ -302,7 +314,7 @@ int __server_recognition_result_callback(stte_result_event_e event, const char*
                /* nothing */
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
        pthread_mutex_unlock(&stte_result_mutex);
 
@@ -313,7 +325,7 @@ bool __server_result_time_callback(int index, stte_result_time_event_e event, co
 {
        pthread_mutex_lock(&stte_result_time_mutex);
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
+       SECURE_SLOG(LOG_INFO, TAG_STTD, "[Server] index(%d) event(%d) text(%s) start(%ld) end(%ld)",
                index, event, text, start_time, end_time);
 
        int ret;
@@ -331,7 +343,7 @@ bool __server_result_time_callback(int index, stte_result_time_event_e event, co
 
 int __server_speech_status_callback(stte_speech_status_e status, void *user_param)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Speech status detected Callback");
+       SLOG(LOG_INFO, TAG_STTD, "===== Speech status detected Callback");
 
        int uid = stt_client_get_current_recognition();
        if (0 != uid) {
@@ -351,13 +363,15 @@ int __server_speech_status_callback(stte_speech_status_e status, void *user_para
                        sttdc_send_speech_status(uid, status);
                } else if (STTE_SPEECH_STATUS_END_POINT_DETECTED == status) {
                        SLOG(LOG_DEBUG, TAG_STTD, "End Speech detected");
-                       ecore_main_loop_thread_safe_call_async(__stop_by_silence, NULL);
+                       ecore_thread_main_loop_begin();
+                       ecore_timer_add(0, __stop_by_silence, NULL);
+                       ecore_thread_main_loop_end();
                }
        } else {
-               SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recogntion uid is not valid ");
+               SLOG(LOG_WARN, TAG_STTD, "[Server WARNING] Current recognition uid is not valid ");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
        return STTD_ERROR_NONE;
@@ -365,7 +379,7 @@ int __server_speech_status_callback(stte_speech_status_e status, void *user_para
 
 int __server_error_callback(stte_error_e error, const char* msg)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Error Callback is called");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Error Callback is called");
        ecore_main_loop_thread_safe_call_async(__cancel_by_error, NULL);
 
        return STTD_ERROR_NONE;
@@ -377,7 +391,7 @@ void __sttd_server_engine_changed_cb(const char* engine_id, const char* language
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Engine id is NULL");
                return;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] New default engine : %s", engine_id);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] New default engine : %s", engine_id);
        }
 
 #if 0
@@ -419,7 +433,7 @@ void __sttd_server_language_changed_cb(const char* language, void* user_data)
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] language is NULL");
                return;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get language changed : %s", language);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] Get language changed : %s", language);
        }
 
        int ret = sttd_engine_agent_set_default_language(language);
@@ -431,7 +445,7 @@ void __sttd_server_language_changed_cb(const char* language, void* user_data)
 
 void __sttd_server_silence_changed_cb(bool value, void* user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Get silence detection changed : %s", value ? "on" : "off");
 
        int ret = 0;
        ret = sttd_engine_agent_set_silence_detection(value);
@@ -487,7 +501,7 @@ int sttd_initialize(stte_request_callback_s *callback)
                SLOG(LOG_WARN, TAG_STTD, "[Main Warning] Fail to create timer of client check");
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] initialize");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] initialize");
 
        return 0;
 }
@@ -524,6 +538,8 @@ int sttd_finalize()
                SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete ecore timer handle");
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] finalize");
+
        return STTD_ERROR_NONE;
 }
 
@@ -576,7 +592,7 @@ Eina_Bool sttd_cleanup_client(void *data)
        }
 
        if (NULL != client_list) {
-               SLOG(LOG_DEBUG, TAG_STTD, "===== Clean up client ");
+               SLOG(LOG_INFO, TAG_STTD, "===== Clean up client ");
 
                __read_proc();
 
@@ -616,7 +632,7 @@ Eina_Bool sttd_cleanup_client(void *data)
 #endif
                }
 
-               SLOG(LOG_DEBUG, TAG_STTD, "=====");
+               SLOG(LOG_INFO, TAG_STTD, "=====");
                SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
                free(client_list);
@@ -633,6 +649,8 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
 {
        int ret = STTD_ERROR_NONE;
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server] server initialize");
+
        /* check if uid is valid */
        app_state_e state;
        if (0 == sttd_client_get_state(uid, &state)) {
@@ -659,25 +677,29 @@ int sttd_server_initialize(int pid, int uid, bool* silence, bool* credential)
                return ret;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server Success] server initialize");
+
        return STTD_ERROR_NONE;
 }
 
 static Eina_Bool __quit_ecore_loop(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Quit");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Quit");
 
        stt_network_finalize();
        sttd_finalize();
        sttd_dbus_close_connection();
        ecore_main_loop_quit();
 
-       SLOG(LOG_DEBUG, TAG_STTD, "");
+       SLOG(LOG_INFO, TAG_STTD, "");
 
        return EINA_FALSE;
 }
 
 int sttd_server_finalize(int uid)
 {
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter Finalize");
+
        /* check if uid is valid */
        app_state_e state;
        if (0 != sttd_client_get_state(uid, &state)) {
@@ -696,11 +718,14 @@ int sttd_server_finalize(int uid)
 
                if (APP_STATE_PROCESSING == state) {
                        if (NULL != g_processing_timer) {
+                               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
                                ecore_timer_del(g_processing_timer);
                                g_processing_timer = NULL;
                        }
                }
 
+               SLOG(LOG_INFO, TAG_STTD, "[Server INFO] stt_cancel is invoked while state is (%d)", state);
+
                if (0 != sttd_engine_agent_recognize_cancel(uid)) {
                        SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to cancel recognition");
                }
@@ -719,6 +744,8 @@ int sttd_server_finalize(int uid)
                ecore_timer_add(0, __quit_ecore_loop, NULL);
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End Finalize");
+
        return STTD_ERROR_NONE;
 }
 
@@ -737,6 +764,8 @@ int sttd_server_get_supported_engines(int uid, GSList** engine_list)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported egnines");
+
        int ret;
        ret = sttd_engine_agent_get_engine_list(engine_list);
        if (0 != ret) {
@@ -762,6 +791,8 @@ int sttd_server_set_current_engine(int uid, const char* engine_id, bool* silence
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] set current egnines, uid(%d), engine_id(%s)", uid, engine_id);
+
        int ret;
        ret = sttd_engine_agent_load_current_engine(NULL);
        if (0 != ret) {
@@ -798,6 +829,8 @@ int sttd_server_get_current_engine(int uid, char** engine_id)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get current egnines, uid(%d)", uid);
+
        int ret;
        ret = sttd_engine_agent_get_current_engine(engine_id);
        if (0 != ret) {
@@ -823,6 +856,8 @@ int sttd_server_check_app_agreed(int uid, const char* appid, bool* available)
                return STTD_ERROR_INVALID_STATE;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] check app agreed");
+
        /* Ask engine available */
        int ret;
        bool temp = false;
@@ -852,6 +887,8 @@ int sttd_server_get_supported_languages(int uid, GSList** lang_list)
                return STTD_ERROR_INVALID_PARAMETER;
        }
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] get supported languages");
+
        /* get language list from engine */
        int ret = sttd_engine_agent_supported_langs(lang_list);
        if (0 != ret) {
@@ -885,7 +922,7 @@ int sttd_server_get_current_langauage(int uid, char** current_lang)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get default language");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get default language, current_lang(%s)", *current_lang);
 
        return STTD_ERROR_NONE;
 }
@@ -912,7 +949,7 @@ int sttd_server_set_private_data(int uid, const char* key, const char* data)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Set private data");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Set private data");
 
        return STTD_ERROR_NONE;
 }
@@ -939,7 +976,7 @@ int sttd_server_get_private_data(int uid, const char* key, char** data)
                return ret;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Get private data, key(%s), data(%s)", key, *data);
 
        return STTD_ERROR_NONE;
 }
@@ -967,7 +1004,7 @@ int sttd_server_is_recognition_type_supported(int uid, const char* type, int* su
 
        *support = (int)temp;
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
+       SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] recognition type supporting is %s", *support ? "true" : "false");
 
        return STTD_ERROR_NONE;
 }
@@ -1045,9 +1082,12 @@ Eina_Bool __check_recording_state(void *data)
 
 Eina_Bool __stop_by_recording_timeout(void *data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop by timeout");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop by timeout");
 
-       g_recording_timer = NULL;
+       if (NULL != g_recording_timer)  {
+               ecore_timer_del(g_recording_timer);
+               g_recording_timer = NULL;
+       }
 
        int uid = 0;
        uid = stt_client_get_current_recognition();
@@ -1059,7 +1099,7 @@ Eina_Bool __stop_by_recording_timeout(void *data)
                }
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
        return EINA_FALSE;
@@ -1082,20 +1122,26 @@ void __sttd_server_recorder_start(void* data)
                return;
        }
 
-       /* Notify uid state change */
-       sttdc_send_set_state(uid, APP_STATE_RECORDING);
-
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+       app_state_e temp_app_state;
+       if (0 != sttd_client_get_state(uid, &temp_app_state)) {
+               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid ");
+               return;
+       }
+       if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
+               /* Notify uid state change */
+               sttdc_send_set_state(uid, APP_STATE_RECORDING);
+               SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+       }
 }
 
 void __sttd_start_sound_completed_cb(int id, void *user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Start sound completed");
+       SLOG(LOG_INFO, TAG_STTD, "===== Start sound completed");
 
        /* After wav play callback, recorder start */
        ecore_main_loop_thread_safe_call_async(__sttd_server_recorder_start, user_data);
 
-       SLOG(LOG_DEBUG, TAG_STTD, "=====");
+       SLOG(LOG_INFO, TAG_STTD, "=====");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
        return;
 }
@@ -1145,6 +1191,17 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
                }
        }
 
+       if (NULL != g_recording_timer) {
+               ecore_timer_del(g_recording_timer);
+               g_recording_timer = NULL;
+       }
+
+       if (NULL != g_processing_timer) {
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+               ecore_timer_del(g_processing_timer);
+               g_processing_timer = NULL;
+       }
+
        char* sound = NULL;
        ret = sttd_client_get_start_sound(uid, &sound);
        if (0 != ret) {
@@ -1159,10 +1216,10 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
        }
 
        /* engine start recognition */
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
+       SLOG(LOG_INFO, TAG_STTD, "[Server] start : uid(%d), lang(%s), recog_type(%s)",
                        uid, lang, recognition_type);
        if (NULL != sound)
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] start sound : %s", sound);
+               SLOG(LOG_INFO, TAG_STTD, "[Server] start sound : %s", sound);
 
        /* 1. Set audio session */
        ret = sttd_recorder_set_audio_session();
@@ -1179,10 +1236,20 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
        if (NULL != sound) {
                int id = 0;
                intptr_t puid = (intptr_t)uid;
-               ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_start_sound_completed_cb, (void*)puid, &id);
-               if (WAV_PLAYER_ERROR_NONE != ret) {
-                       SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+               sound_stream_info_h wav_stream_info_h;
+               if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
                        is_sound_done = true;
+               } else {
+                       ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_start_sound_completed_cb, (void*)puid, &id);
+                       if (WAV_PLAYER_ERROR_NONE != ret) {
+                               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+                               is_sound_done = true;
+                       }
+
+                       if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
+                               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
+                       }
                }
                free(sound);
                sound = NULL;
@@ -1208,8 +1275,10 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
 
        g_recording_log_count = 0;
 
+       app_state_e temp_app_state;
+
        if (true == is_sound_done) {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+               SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
 
                ret = sttd_engine_agent_recognize_start_recorder(uid);
                if (0 != ret) {
@@ -1217,33 +1286,50 @@ int sttd_server_start(int uid, const char* lang, const char* recognition_type, i
                        sttd_recorder_unset_audio_session();
 
                        sttd_engine_agent_recognize_cancel();
-                       ecore_timer_del(g_recording_timer);
+                       if (NULL != g_recording_timer)  {
+                               ecore_timer_del(g_recording_timer);
+                               g_recording_timer = NULL;
+                       }
                        sttd_client_set_state(uid, APP_STATE_READY);
 
                        SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to start recorder : result(%d)", ret);
                        return ret;
                }
 
-               /* Notify uid state change */
-               sttdc_send_set_state(uid, APP_STATE_RECORDING);
+               if (0 != sttd_client_get_state(uid, &temp_app_state)) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] uid is NOT valid");
+                       return STTD_ERROR_INVALID_PARAMETER;
+               }
+               if (APP_STATE_READY != temp_app_state && 0 != stt_client_get_current_recognition()) {
+                       /* Notify uid state change */
+                       sttdc_send_set_state(uid, APP_STATE_RECORDING);
+               }
 
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Start recognition");
+               SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Start recognition");
                return STTD_RESULT_STATE_DONE;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Wait sound finish");
+       SLOG(LOG_INFO, TAG_STTD, "[Server] Wait sound finish");
 
        return STTD_RESULT_STATE_NOT_DONE;
 }
 
 Eina_Bool __time_out_for_processing(void *data)
 {
-       g_processing_timer = NULL;
+       if (NULL != g_processing_timer) {
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+               ecore_timer_del(g_processing_timer);
+               g_processing_timer = NULL;
+       }
+
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter __time_out_for_processing");
 
        /* current uid */
        int uid = stt_client_get_current_recognition();
        if (0 == uid)   return EINA_FALSE;
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by timeout for processing");
+
        /* Cancel engine */
        int ret = sttd_engine_agent_recognize_cancel();
        if (0 != ret) {
@@ -1265,6 +1351,8 @@ Eina_Bool __time_out_for_processing(void *data)
 
        stt_client_unset_current_recognition();
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End __time_out_for_processing");
+
        return EINA_FALSE;
 }
 
@@ -1297,7 +1385,7 @@ void __sttd_server_engine_stop(void* data)
 
 void __sttd_stop_sound_completed_cb(int id, void *user_data)
 {
-       SLOG(LOG_DEBUG, TAG_STTD, "===== Stop sound completed");
+       SLOG(LOG_INFO, TAG_STTD, "===== Stop sound completed");
 
        /* After wav play callback, engine stop */
        ecore_main_loop_thread_safe_call_async(__sttd_server_engine_stop, user_data);
@@ -1327,13 +1415,19 @@ int sttd_server_stop(int uid)
                g_recording_timer = NULL;
        }
 
+       if (NULL != g_processing_timer) {
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
+               ecore_timer_del(g_processing_timer);
+               g_processing_timer = NULL;
+       }
+
        char* sound = NULL;
        if (0 != sttd_client_get_stop_sound(uid, &sound)) {
                SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to get start beep sound");
                return STTD_ERROR_OPERATION_FAILED;
        }
 
-       SLOG(LOG_DEBUG, TAG_STTD, "[Server] stop sound path : %s", sound);
+       SLOG(LOG_INFO, TAG_STTD, "[Server] stop sound path : %s", sound);
 
        int ret;
        /* 1. Stop recorder */
@@ -1351,20 +1445,29 @@ int sttd_server_stop(int uid)
        if (NULL != sound) {
                int id = 0;
                intptr_t puid = (intptr_t)uid;
-               ret = wav_player_start(sound, SOUND_TYPE_MEDIA, __sttd_stop_sound_completed_cb, (void*)puid, &id);
-               if (WAV_PLAYER_ERROR_NONE != ret) {
-                       SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+               sound_stream_info_h wav_stream_info_h;
+               if (0 != sound_manager_create_stream_information(SOUND_STREAM_TYPE_MEDIA, NULL, NULL, &wav_stream_info_h)) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to create stream info for playing wav");
                } else {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
-               }
+                       ret = wav_player_start_new(sound, wav_stream_info_h, __sttd_stop_sound_completed_cb, (void*)puid, &id);
+                       if (WAV_PLAYER_ERROR_NONE != ret) {
+                               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to play wav");
+                       } else {
+                               SLOG(LOG_DEBUG, TAG_STTD, "[Server] Play wav : %s", sound);
+                       }
 
+                       if (0 != sound_manager_destroy_stream_information(wav_stream_info_h)) {
+                               SLOG(LOG_ERROR, TAG_STTD, "[Server ERROR] Fail to destroy stream info for playing wav");
+                       }
+               }
                free(sound);
 
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
                g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
 
                return STTD_RESULT_STATE_NOT_DONE;
        } else {
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server] No sound play");
+               SLOG(LOG_INFO, TAG_STTD, "[Server] No sound play");
 
                /* Unset audio session */
                ret = sttd_recorder_unset_audio_session();
@@ -1387,8 +1490,9 @@ int sttd_server_stop(int uid)
                /* Notify uid state change */
                sttdc_send_set_state(uid, APP_STATE_PROCESSING);
 
-               SLOG(LOG_DEBUG, TAG_STTD, "[Server SUCCESS] Stop recognition");
+               SLOG(LOG_INFO, TAG_STTD, "[Server SUCCESS] Stop recognition");
 
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Add g_processing_timer");
                g_processing_timer = ecore_timer_add(g_processing_timeout, __time_out_for_processing, NULL);
 
                return STTD_RESULT_STATE_DONE;
@@ -1399,6 +1503,8 @@ int sttd_server_stop(int uid)
 
 int sttd_server_cancel(int uid)
 {
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] Enter sttd_server_cancel");
+
        /* check if uid is valid */
        app_state_e state;
        if (0 != sttd_client_get_state(uid, &state)) {
@@ -1420,6 +1526,7 @@ int sttd_server_cancel(int uid)
        }
 
        if (NULL != g_processing_timer) {
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
                ecore_timer_del(g_processing_timer);
                g_processing_timer = NULL;
        }
@@ -1436,6 +1543,8 @@ int sttd_server_cancel(int uid)
        /* change uid state */
        sttd_client_set_state(uid, APP_STATE_READY);
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server Info] stt cancel is invoked by app's request");
+
        /* cancel engine recognition */
        int ret = sttd_engine_agent_recognize_cancel();
        if (0 != ret) {
@@ -1446,6 +1555,8 @@ int sttd_server_cancel(int uid)
        /* Notify uid state change */
        sttdc_send_set_state(uid, APP_STATE_READY);
 
+       SLOG(LOG_INFO, TAG_STTD, "[Server INFO] End sttd_server_cancel");
+
        return STTD_ERROR_NONE;
 }
 
@@ -1589,6 +1700,7 @@ int sttd_server_cancel_file(int uid)
        }
 
        if (NULL != g_processing_timer) {
+               SLOG(LOG_INFO, TAG_STTD, "[INFO] Delete g_processing_timer");
                ecore_timer_del(g_processing_timer);
                g_processing_timer = NULL;
        }
@@ -1617,3 +1729,4 @@ int sttd_server_cancel_file(int uid)
 
        return STTD_ERROR_NONE;
 }
+
Domain: UI Framework / Voice;