projects / platform / core / uifw / stt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fix dbus delay when requesting hello
[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 358357d..b3ab460 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
@@ -54,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;
 
@@ -61,7 +62,7 @@ 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)) {
@@ -69,22 +70,27 @@ int sttd_dbus_server_initialize(DBusConnection* conn, DBusMessage* msg)
                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);
                }
@@ -121,7 +127,7 @@ int sttd_dbus_server_finalize(DBusConnection* conn, DBusMessage* msg)
                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);
        }
 
@@ -172,7 +178,7 @@ int sttd_dbus_server_get_support_engines(DBusConnection* conn, DBusMessage* msg)
                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);
        }
 
@@ -203,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));
@@ -213,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");
                                        }
@@ -256,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,
@@ -270,22 +287,26 @@ int sttd_dbus_server_set_current_engine(DBusConnection* conn, DBusMessage* msg)
                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);
                }
@@ -324,7 +345,7 @@ int sttd_dbus_server_get_current_engine(DBusConnection* conn, DBusMessage* msg)
                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);
        }
 
@@ -386,8 +407,8 @@ int sttd_dbus_server_check_app_agreed(DBusConnection* conn, DBusMessage* msg)
                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;
@@ -440,7 +461,7 @@ int sttd_dbus_server_get_support_lang(DBusConnection* conn, DBusMessage* msg)
                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);
        }
 
@@ -519,7 +540,7 @@ int sttd_dbus_server_get_default_lang(DBusConnection* conn, DBusMessage* msg)
                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);
        }
 
@@ -559,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;
@@ -578,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);
        }
 
@@ -593,7 +729,7 @@ 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);
                }
@@ -632,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);
        }
 
@@ -646,7 +782,7 @@ 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);
                }
@@ -684,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);
        }
 
@@ -698,7 +834,7 @@ 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);
                }
@@ -737,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);
        }
 
@@ -789,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);
        }
 
@@ -803,7 +939,7 @@ 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);
                }
@@ -834,14 +970,16 @@ 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");
@@ -851,11 +989,21 @@ int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
                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);
 
@@ -877,6 +1025,7 @@ int sttd_dbus_server_start(DBusConnection* conn, DBusMessage* msg)
        } else {
                SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
+#endif
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
@@ -900,10 +1049,19 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
                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);
 
@@ -925,6 +1083,7 @@ int sttd_dbus_server_stop(DBusConnection* conn, DBusMessage* msg)
        } else {
                SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
+#endif
 
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
@@ -948,10 +1107,19 @@ int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
                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);
 
@@ -973,7 +1141,97 @@ int sttd_dbus_server_cancel(DBusConnection* conn, DBusMessage* msg)
        } else {
                SLOG(LOG_ERROR, TAG_STTD, "[OUT ERROR] Fail to create reply message!!");
        }
+#endif
+       SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+       SLOG(LOG_DEBUG, TAG_STTD, "  ");
+
+       return 0;
+}
 
+int sttd_dbus_server_start_file(DBusConnection* conn, DBusMessage* msg)
+{
+       DBusError err;
+       dbus_error_init(&err);
+
+       int uid;
+       char* lang;
+       char* type;
+       char* appid;
+       int silence;
+       char* credential;
+       char* filepath;
+       stte_audio_type_e audio_type;
+       int sample_rate;
+
+       int ret = STTD_ERROR_OPERATION_FAILED;
+
+       dbus_message_get_args(msg, &err,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_STRING, &lang,
+               DBUS_TYPE_STRING, &type,
+               DBUS_TYPE_INT32, &silence,
+               DBUS_TYPE_STRING, &appid,
+               DBUS_TYPE_STRING, &credential,
+               DBUS_TYPE_STRING, &filepath,
+               DBUS_TYPE_INT32, &audio_type,
+               DBUS_TYPE_INT32, &sample_rate,
+               DBUS_TYPE_INVALID);
+
+       SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Start File");
+
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt start file: get arguments error (%s)", err.message);
+               dbus_error_free(&err);
+               ret = STTD_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt start file : uid(%d), lang(%s), type(%s), silence(%d) appid(%s) filepath(%s), audio_type(%d), sample_rate(%d)"
+                       , uid, lang, type, silence, appid, filepath, audio_type, sample_rate);
+               ret = sttd_server_start_file(uid, lang, type, silence, appid, credential, filepath, audio_type, sample_rate);
+       }
+
+       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 file")) {
+                       SLOG(LOG_ERROR, TAG_STTD, "[ERROR] Fail to send error signal");
+               }
+       }
+
+       SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
+       SLOG(LOG_DEBUG, TAG_STTD, "  ");
+
+       return 0;
+}
+
+int sttd_dbus_server_cancel_file(DBusConnection* conn, DBusMessage* msg)
+{
+       DBusError err;
+       dbus_error_init(&err);
+
+       int uid;
+       int ret = STTD_ERROR_OPERATION_FAILED;
+       dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
+
+       SLOG(LOG_DEBUG, TAG_STTD, ">>>>> STT Cancel File");
+
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_STTD, "[IN ERROR] stt cancel file : get arguments error (%s)", err.message);
+               dbus_error_free(&err);
+               ret = STTD_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_STTD, "[IN] stt cancel file : uid(%d)", uid);
+               ret = sttd_server_cancel_file(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");
+               }
+       }
        SLOG(LOG_DEBUG, TAG_STTD, "<<<<<");
        SLOG(LOG_DEBUG, TAG_STTD, "  ");
 
Domain: UI Framework / Voice;