projects / platform / core / uifw / stt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix memory leak and Delete an unnecessary file
[platform/core/uifw/stt.git] / server / sttd_dbus_server.c
diff --git a/server/sttd_dbus_server.c b/server/sttd_dbus_server.c
index bcd6c82..2428cb0 100644 (file)
--- a/server/sttd_dbus_server.c
+++ b/server/sttd_dbus_server.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2011-2014 Samsung Electronics Co., Ltd All Rights Reserved 
+* Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
@@ -21,7 +21,7 @@
 
 /*
 * Dbus Client-Daemon Server
-*/ 
+*/
 
 int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
 {
@@ -29,17 +29,7 @@ int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
 
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
-
-       int status = -1;
-       if (EINA_TRUE == sttd_get_daemon_exist()) {
-               status = STTD_DAEMON_NORMAL;
-       } else {
-               status = STTD_DAEMON_ON_TERMINATING;
-       }
-
        if (NULL != reply) {
-               dbus_message_append_args(reply, DBUS_TYPE_INT32, &status, DBUS_TYPE_INVALID);
-
                if (!dbus_connection_send(conn, reply, NULL)) {
                        SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
                }
@@ -47,7 +37,7 @@ int sttd_dbus_server_hello(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -64,6 +54,7 @@ int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
        int pid;
        int uid;
        bool silence_supported = false;
+       bool credential_needed = false;
 
        int ret = STTD_ERROR_OPERATION_FAILED;
 
@@ -71,32 +62,37 @@ int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                DBUS_TYPE_INT32, &pid,
                DBUS_TYPE_INT32, &uid,
                DBUS_TYPE_INVALID);
-       
+
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Initialize");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt initialize : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid); 
-               ret =  sttd_server_initialize(pid, uid, &silence_supported);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt initialize : pid(%d), uid(%d)", pid , uid);
+               ret =  sttd_server_initialize(pid, uid, &silence_supported, &credential_needed);
        }
 
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
 
        if (NULL != reply) {
+               int int_silence_supported = (int)silence_supported;
+               int int_credential_needed = (int)credential_needed;
+
                dbus_message_append_args(reply, 
                        DBUS_TYPE_INT32, &ret, 
-                       DBUS_TYPE_INT32, &silence_supported,
+                       DBUS_TYPE_INT32, &int_silence_supported,
+                       DBUS_TYPE_INT32, &int_credential_needed,
                        DBUS_TYPE_INVALID);
 
+
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d)", 
-                               ret, silence_supported); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)", 
+                               ret, silence_supported, credential_needed);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -106,7 +102,7 @@ int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -126,26 +122,26 @@ int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Finalize");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt finalize : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt finalize : uid(%d)", uid);
                ret =  sttd_server_finalize(uid);
        }
 
        DBusMessage* reply;
-       
+
        reply = dbus_message_new_method_return(msg);
 
        if (NULL != reply) {
                dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -155,7 +151,7 @@ int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -177,12 +173,12 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported engines");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported engines : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported engines : uid(%d)", uid);
                ret = sttd_server_get_supported_engines(uid, &engine_list);
        }
 
@@ -195,7 +191,7 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
                dbus_message_iter_init_append(reply, &args);
 
                /* Append result*/
-               dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret) );
+               dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(ret));
 
                if (0 == ret) {
                        /* Append size */
@@ -213,7 +209,7 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
 
                                        if (NULL != engine) {
                                                if (NULL != engine->engine_id && NULL != engine->engine_name && NULL != engine->ug_name) {
-                                                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s", 
+                                                       SLOG(LOG_DEBUG, TAG_STTD, "engine id : %s, engine name : %s, ug_name, : %s", 
                                                                engine->engine_id, engine->engine_name, engine->ug_name);
 
                                                        dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(engine->engine_id));
@@ -223,11 +219,21 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
                                                        SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
                                                }
 
-                                               if (NULL != engine->engine_id)          free(engine->engine_id);
-                                               if (NULL != engine->engine_name)        free(engine->engine_name);
-                                               if (NULL != engine->ug_name)            free(engine->ug_name);
+                                               if (NULL != engine->engine_id) {
+                                                       free(engine->engine_id);
+                                                       engine->engine_id = NULL;
+                                               }
+                                               if (NULL != engine->engine_name) {
+                                                       free(engine->engine_name);
+                                                       engine->engine_name = NULL;
+                                               }
+                                               if (NULL != engine->ug_name) {
+                                                       free(engine->ug_name);
+                                                       engine->ug_name = NULL;
+                                               }
 
                                                free(engine);
+                                               engine = NULL;
                                        } else {
                                                SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Engine info is NULL");
                                        }
@@ -235,11 +241,11 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
                                        engine_list = g_slist_remove_link(engine_list, iter);
 
                                        iter = g_slist_nth(engine_list, 0);
-                               } 
+                               }
                        }
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -249,7 +255,7 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -266,6 +272,7 @@ int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
        int uid;
        char* engine_id;
        bool silence_supported = false;
+       bool credential_needed = false;
        int ret = STTD_ERROR_OPERATION_FAILED;
 
        dbus_message_get_args(msg, &err,
@@ -275,29 +282,33 @@ int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set current engine");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set current engine : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d)", uid); 
-               ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set current engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
+               ret = sttd_server_set_current_engine(uid, engine_id, &silence_supported, &credential_needed);
        }
 
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
 
        if (NULL != reply) {
+               int int_silence_supported = (int)silence_supported;
+               int int_credential_needed = (int)credential_needed;
+
                dbus_message_append_args(reply, 
                        DBUS_TYPE_INT32, &ret, 
-                       DBUS_TYPE_INT32, &silence_supported,
+                       DBUS_TYPE_INT32, &int_silence_supported,
+                       DBUS_TYPE_INT32, &int_credential_needed,
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d)", 
-                               ret, silence_supported);
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), silence(%d), credential(%d)", 
+                               ret, silence_supported, credential_needed);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d) ", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -307,7 +318,7 @@ int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -329,12 +340,12 @@ int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get current engine");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get current engine : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get current engine : uid(%d)", uid);
                ret = sttd_server_get_current_engine(uid, &engine);
        }
 
@@ -344,16 +355,16 @@ int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
        if (NULL != reply) {
                if (0 == ret) {
                        /* Append result and language */
-                       dbus_message_append_args( reply, 
+                       dbus_message_append_args(reply,
                                DBUS_TYPE_INT32, &ret,
                                DBUS_TYPE_STRING, &engine,
                                DBUS_TYPE_INVALID);
 
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
                        dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -363,7 +374,7 @@ int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        if (NULL != engine)     free(engine);
@@ -384,20 +395,20 @@ int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
        int ret = STTD_ERROR_OPERATION_FAILED;
        bool available = false;
 
-       dbus_message_get_args(msg, &err, 
+       dbus_message_get_args(msg, &err,
                DBUS_TYPE_INT32, &uid, 
                DBUS_TYPE_STRING, &appid, 
                DBUS_TYPE_INVALID);
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Is engine available");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt Is engine available : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid); 
-               ret = sttd_server_check_agg_agreed(uid, appid, &available);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt Is engine available : uid(%d)", uid);
+               ret = sttd_server_check_app_agreed(uid, appid, &available);
        }
 
        DBusMessage* reply;
@@ -411,9 +422,9 @@ int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -423,7 +434,7 @@ int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -445,12 +456,12 @@ int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get supported langs");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt supported langs : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt supported langs : uid(%d)", uid);
                ret = sttd_server_get_supported_languages(uid, &lang_list);
        }
 
@@ -469,7 +480,7 @@ int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
                        int size = g_slist_length(lang_list);
 
                        if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &(size))) {
-                               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type"); 
+                               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to append type");
                                ret = STTD_ERROR_OPERATION_FAILED;
                        } else {
                                GSList *iter = NULL;
@@ -480,21 +491,21 @@ int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
                                while (NULL != iter) {
                                        temp_lang = iter->data;
 
-                                       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang) );
-                                       
+                                       dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &(temp_lang));
+
                                        if (NULL != temp_lang)
                                                free(temp_lang);
-                                       
+
                                        lang_list = g_slist_remove_link(lang_list, iter);
 
                                        iter = g_slist_nth(lang_list, 0);
-                               } 
+                               }
                        }
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
-               
+
                if (!dbus_connection_send(conn, reply, NULL)) {
                        SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
                }
@@ -502,7 +513,7 @@ int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -524,12 +535,12 @@ int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get default langs");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get default lang : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get default lang : uid(%d)", uid);
                ret = sttd_server_get_current_langauage(uid, &lang);
        }
 
@@ -539,16 +550,16 @@ int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
        if (NULL != reply) {
                if (0 == ret) {
                        /* Append result and language */
-                       dbus_message_append_args( reply, 
+                       dbus_message_append_args(reply,
                                DBUS_TYPE_INT32, &ret,
                                DBUS_TYPE_STRING, &lang,
                                DBUS_TYPE_INVALID);
 
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
                        dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -558,7 +569,7 @@ int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        if (NULL != lang)       free(lang);
@@ -569,6 +580,121 @@ int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
        return 0;
 }
 
+int sttd_dbus_server_set_private_data(DBusConnection* conn, DBusMessage* msg)
+{
+       DBusError err;
+       dbus_error_init(&err);
+
+       int uid;
+       char* key;
+       char* data;
+       int ret = STTD_ERROR_OPERATION_FAILED;
+       dbus_message_get_args(msg, &err,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_STRING, &key,
+               DBUS_TYPE_STRING, &data,
+               DBUS_TYPE_INVALID);
+
+       SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Set private data");
+
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt set private data : get arguments error (%s)", err.message);
+               dbus_error_free(&err);
+               ret = STTD_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set private data : uid(%d)", uid);
+               ret = sttd_server_set_private_data(uid, key, data);
+       }
+
+       DBusMessage* reply;
+       reply = dbus_message_new_method_return(msg);
+
+       if (NULL != reply) {
+               dbus_message_append_args(reply,
+                       DBUS_TYPE_INT32, &ret,
+                       DBUS_TYPE_INVALID);
+
+               if (0 == ret) {
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+               } else {
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+               }
+
+               if (!dbus_connection_send(conn, reply, NULL)) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
+               }
+
+               dbus_connection_flush(conn);
+               dbus_message_unref(reply);
+       } else {
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+       }
+
+       SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+       SLOG(LOG_DEBUG, TAG_STTD, "  ");
+
+       return 0;
+}
+
+int sttd_dbus_server_get_private_data(DBusConnection* conn, DBusMessage* msg)
+{
+       DBusError err;
+       dbus_error_init(&err);
+
+       int uid;
+       char* key = NULL;
+       char* data = NULL;
+       int ret = STTD_ERROR_OPERATION_FAILED;
+       dbus_message_get_args(msg, &err,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_STRING, &key,
+               DBUS_TYPE_INVALID);
+
+       SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Get private data");
+
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt get private data : get arguments error (%s)", err.message);
+               dbus_error_free(&err);
+               ret = STTD_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt get private data : uid(%d), key(%s)", uid, (NULL == key) ? "NULL" : key);
+               ret = sttd_server_get_private_data(uid, key, &data);
+       }
+
+       DBusMessage* reply;
+       reply = dbus_message_new_method_return(msg);
+
+       if (NULL != reply) {
+               /* Append result and private data */
+               dbus_message_append_args(reply,
+                       DBUS_TYPE_INT32, &ret,
+                       DBUS_TYPE_STRING, &data,
+                       DBUS_TYPE_INVALID);
+
+               if (0 == ret) {
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), data(%s)", ret, (NULL == data) ? "NULL" : data);
+               } else {
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+               }
+
+               if (!dbus_connection_send(conn, reply, NULL)) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Out Of Memory!");
+               }
+
+               dbus_connection_flush(conn);
+               dbus_message_unref(reply);
+       } else {
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
+       }
+
+       if (NULL != data)       free(data);
+
+       SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+       SLOG(LOG_DEBUG, TAG_STTD, "  ");
+
+       return 0;
+}
+
 int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMessage* msg)
 {
        DBusError err;
@@ -588,7 +714,7 @@ int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMes
                dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt is recognition type supported : uid(%d)", uid);
                ret = sttd_server_is_recognition_type_supported(uid, type, &support);
        }
 
@@ -603,9 +729,9 @@ int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMes
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false"); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d), Support(%s)", ret, support ? "true" : "false");
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -615,7 +741,7 @@ int sttd_dbus_server_is_recognition_type_supported(DBusConnection* conn, DBusMes
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -642,7 +768,7 @@ int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set start sound : uid(%d) file(%s)", uid, file);
                ret = sttd_server_set_start_sound(uid, file);
        }
 
@@ -656,9 +782,9 @@ int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -668,7 +794,7 @@ int sttd_dbus_server_set_start_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -694,7 +820,7 @@ int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset start sound : uid(%d)", uid);
                ret = sttd_server_set_start_sound(uid, NULL);
        }
 
@@ -708,9 +834,9 @@ int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -720,7 +846,7 @@ int sttd_dbus_server_unset_start_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -747,7 +873,7 @@ int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt set stop sound : uid(%d) file(%s)", uid, file);
                ret = sttd_server_set_stop_sound(uid, file);
        }
 
@@ -761,9 +887,9 @@ int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -773,7 +899,7 @@ int sttd_dbus_server_set_stop_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -799,7 +925,7 @@ int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt unset stop sound : uid(%d)", uid);
                ret = sttd_server_set_stop_sound(uid, NULL);
        }
 
@@ -813,9 +939,9 @@ int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
                        DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -825,7 +951,7 @@ int sttd_dbus_server_unset_stop_sound(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
@@ -844,28 +970,40 @@ int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
        char* type;
        char* appid;
        int silence;
+       char* credential;
        int ret = STTD_ERROR_OPERATION_FAILED;
 
        dbus_message_get_args(msg, &err, 
                DBUS_TYPE_INT32, &uid, 
-               DBUS_TYPE_STRING, &lang,   
+               DBUS_TYPE_STRING, &lang,
                DBUS_TYPE_STRING, &type,
                DBUS_TYPE_INT32, &silence,
                DBUS_TYPE_STRING, &appid,
+               DBUS_TYPE_STRING, &credential,
                DBUS_TYPE_INVALID);
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s)"
-                       , uid, lang, type, silence, appid); 
-               ret = sttd_server_start(uid, lang, type, silence, appid);
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) credential(%s)"
+                       , uid, lang, type, silence, appid, credential);
+               ret = sttd_server_start(uid, lang, type, silence, appid, credential);
        }
 
+       if (0 <= ret) {
+               SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+       } else {
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+               if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to start")) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+               }
+       }
+
+#if 0
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
 
@@ -873,9 +1011,9 @@ int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
                dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
                if (0 <= ret) {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -885,8 +1023,9 @@ int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
+#endif
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
@@ -905,15 +1044,24 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Stop");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt stop : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt stop : uid(%d)", uid);
                ret = sttd_server_stop(uid);
        }
 
+       if (0 <= ret) {
+               SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+       } else {
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+               if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to stop")) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+               }
+       }
+#if 0
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
 
@@ -921,9 +1069,9 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
                dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
                if (0 <= ret) {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -933,8 +1081,9 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
+#endif
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
@@ -953,15 +1102,24 @@ int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
 
        SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel");
 
-       if (dbus_error_is_set(&err)) { 
+       if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel : get arguments error (%s)", err.message);
-               dbus_error_free(&err); 
+               dbus_error_free(&err);
                ret = STTD_ERROR_OPERATION_FAILED;
        } else {
-               SECURE_SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid); 
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel : uid(%d)", uid);
                ret = sttd_server_cancel(uid);
        }
 
+       if (0 <= ret) {
+               SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
+       } else {
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
+               if (0 != sttdc_send_error_signal(uid, ret, "[ERROR] Fail to cancel")) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+               }
+       }
+#if 0
        DBusMessage* reply;
        reply = dbus_message_new_method_return(msg);
 
@@ -969,9 +1127,9 @@ int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
                dbus_message_append_args(reply, DBUS_TYPE_INT32, &ret, DBUS_TYPE_INVALID);
 
                if (0 == ret) {
-                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret); 
+                       SLOG(LOG_DEBUG, TAG_STTD, "[OUT SUCCESS] Result(%d)", ret);
                } else {
-                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret); 
+                       SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Result(%d)", ret);
                }
 
                if (!dbus_connection_send(conn, reply, NULL)) {
@@ -981,9 +1139,9 @@ int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
                dbus_connection_flush(conn);
                dbus_message_unref(reply);
        } else {
-               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!"); 
+               SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
-
+#endif
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
Domain: UI Framework / Voice;