Change uid and gid for service files
[platform/core/uifw/tts.git] / client / tts_dbus.c
index df39b69..0c60f4a 100644 (file)
@@ -21,9 +21,9 @@
 #include "tts_dbus.h"
 #include "tts_defs.h"
 #include "tts_main.h"
+#include "tts_internal.h"
 
-
-#define HELLO_WAITING_TIME 500
+#define HELLO_WAITING_TIME -1
 #define WAITING_TIME 5000
 
 static DBusConnection* g_conn_sender = NULL;
@@ -136,9 +136,9 @@ static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handle
                } /* TTSD_SIGNAL_ERROR */
 
                else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
-                       SLOG(LOG_DEBUG, TAG_TTSC, "===== Owner Changed");
+                       SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Owner Changed");
                        __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
-                       SLOG(LOG_DEBUG, TAG_TTSC, "=====");
+                       SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
                        SLOG(LOG_DEBUG, TAG_TTSC, " ");
                } /* NameOwnerChanged */
 
@@ -177,11 +177,11 @@ int tts_dbus_open_connection()
 
        DBusError err;
 
-       /* initialise the error value */
+       /* initialize the error value */
        dbus_error_init(&err);
 
        /* connect to the DBUS system bus, and check for errors */
-       g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
+       g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
        if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
                dbus_error_free(&err);
@@ -194,7 +194,7 @@ int tts_dbus_open_connection()
 
        dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 
-       g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
+       g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
        if (dbus_error_is_set(&err)) {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
                dbus_error_free(&err);
@@ -206,6 +206,8 @@ int tts_dbus_open_connection()
                return TTS_ERROR_OPERATION_FAILED;
        }
 
+       dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
+
        char rule[128] = {0, };
        snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 
@@ -299,21 +301,27 @@ DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 
        if (TTS_MODE_DEFAULT == client->mode) {
                msg = dbus_message_new_method_call(
-                       TTS_SERVER_SERVICE_NAME, 
-                       TTS_SERVER_SERVICE_OBJECT_PATH, 
-                       TTS_SERVER_SERVICE_INTERFACE, 
+                       TTS_SERVER_SERVICE_NAME,
+                       TTS_SERVER_SERVICE_OBJECT_PATH,
+                       TTS_SERVER_SERVICE_INTERFACE,
                        method);
        } else if (TTS_MODE_NOTIFICATION == client->mode) {
                msg = dbus_message_new_method_call(
-                       TTS_NOTI_SERVER_SERVICE_NAME, 
-                       TTS_NOTI_SERVER_SERVICE_OBJECT_PATH, 
-                       TTS_NOTI_SERVER_SERVICE_INTERFACE, 
+                       TTS_NOTI_SERVER_SERVICE_NAME,
+                       TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
+                       TTS_NOTI_SERVER_SERVICE_INTERFACE,
                        method);
        } else if (TTS_MODE_SCREEN_READER == client->mode) {
                msg = dbus_message_new_method_call(
-                       TTS_SR_SERVER_SERVICE_NAME, 
-                       TTS_SR_SERVER_SERVICE_OBJECT_PATH, 
-                       TTS_SR_SERVER_SERVICE_INTERFACE, 
+                       TTS_SR_SERVER_SERVICE_NAME,
+                       TTS_SR_SERVER_SERVICE_OBJECT_PATH,
+                       TTS_SR_SERVER_SERVICE_INTERFACE,
+                       method);
+       } else if (TTS_MODE_INTERRUPT == client->mode) {
+               msg = dbus_message_new_method_call(
+                       TTS_INTERRUPT_SERVER_SERVICE_NAME,
+                       TTS_INTERRUPT_SERVER_SERVICE_OBJECT_PATH,
+                       TTS_INTERRUPT_SERVER_SERVICE_INTERFACE,
                        method);
        } else {
                SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
@@ -347,7 +355,7 @@ int tts_dbus_request_hello(int uid)
        result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
        dbus_message_unref(msg);
        if (dbus_error_is_set(&err)) {
-//             SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
+               SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err.message);
                dbus_error_free(&err);
        }
 
@@ -418,20 +426,30 @@ int tts_dbus_request_initialize(int uid, bool* credential_needed)
                        /* add a rule for daemon error */
                        char rule_err[256] = {0, };
                        tts_client_s* client = tts_client_get_by_uid(uid);
-                       if (TTS_MODE_DEFAULT == client->mode) {
-                               snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
-                       } else if (TTS_MODE_NOTIFICATION == client->mode) {
-                               snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
-                       } else if (TTS_MODE_SCREEN_READER == client->mode) {
-                               snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
+                       if (NULL == client) {
+                               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
+                               return TTS_ERROR_OPERATION_FAILED;
                        }
-                       dbus_bus_add_match(g_conn_listener, rule_err, &err);
-                       dbus_connection_flush(g_conn_listener);
 
-                       if (dbus_error_is_set(&err)) {
-                               SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
-                               dbus_error_free(&err);
-                               return TTS_ERROR_OPERATION_FAILED;
+                       if (TTS_ERROR_SERVICE_RESET != client->reason) {
+                               if (TTS_MODE_DEFAULT == client->mode) {
+                                       snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
+                               } else if (TTS_MODE_NOTIFICATION == client->mode) {
+                                       snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
+                               } else if (TTS_MODE_SCREEN_READER == client->mode) {
+                                       snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
+                               } else if (TTS_MODE_INTERRUPT == client->mode) {
+                                       snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
+                               }
+                               dbus_bus_add_match(g_conn_listener, rule_err, &err);
+                               dbus_connection_flush(g_conn_listener);
+
+                               if (dbus_error_is_set(&err)) {
+                                       SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
+                                       dbus_error_free(&err);
+                                       return TTS_ERROR_OPERATION_FAILED;
+                               }
+                               client->reason = 0; // default value
                        }
                } else {
                        SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
@@ -455,12 +473,19 @@ int tts_dbus_request_finalize(int uid)
        /* remove a rule for daemon error */
        char rule_err[256] = {0, };
        tts_client_s* client = tts_client_get_by_uid(uid);
+       if (NULL == client) {
+               SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
+
        if (TTS_MODE_DEFAULT == client->mode) {
                snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
        } else if (TTS_MODE_NOTIFICATION == client->mode) {
                snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
        } else if (TTS_MODE_SCREEN_READER == client->mode) {
                snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
+       } else if (TTS_MODE_INTERRUPT == client->mode) {
+               snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
        }
        dbus_bus_remove_match(g_conn_listener, rule_err, &err);
        dbus_connection_flush(g_conn_listener);
@@ -936,3 +961,187 @@ int tts_dbus_request_pause(int uid)
 
        return result;
 }
+
+//LCOV_EXCL_START
+int tts_dbus_request_play_pcm(int uid)
+{
+       DBusMessage* msg;
+       DBusError err;
+       dbus_error_init(&err);
+
+       msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY_PCM);
+
+       if (NULL == msg) {
+               SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
+               return TTS_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
+       }
+
+       if (true != dbus_message_append_args(msg,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_INVALID)) {
+               dbus_message_unref(msg);
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
+
+       DBusMessage* result_msg;
+       int result = TTS_ERROR_OPERATION_FAILED;
+
+       result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
+       dbus_message_unref(msg);
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
+               dbus_error_free(&err);
+       }
+
+       if (NULL != result_msg) {
+               dbus_message_get_args(result_msg, &err,
+                       DBUS_TYPE_INT32, &result,
+                       DBUS_TYPE_INVALID);
+
+               if (dbus_error_is_set(&err)) {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : Get arguments error (%s)", err.message);
+                       dbus_error_free(&err);
+                       result = TTS_ERROR_OPERATION_FAILED;
+               }
+               dbus_message_unref(result_msg);
+
+               if (0 == result) {
+                       SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
+               } else {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
+               }
+       } else {
+               SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
+               tts_dbus_reconnect();
+               result = TTS_ERROR_TIMED_OUT;
+       }
+
+       return result;
+}
+
+int tts_dbus_request_stop_pcm(int uid)
+{
+       DBusMessage* msg;
+       DBusError err;
+       dbus_error_init(&err);
+
+       msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP_PCM);
+
+       if (NULL == msg) {
+               SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
+               return TTS_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
+       }
+
+       if (true != dbus_message_append_args(msg,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_INVALID)) {
+               dbus_message_unref(msg);
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
+
+       DBusMessage* result_msg;
+       int result = TTS_ERROR_OPERATION_FAILED;
+
+       result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
+       dbus_message_unref(msg);
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
+               dbus_error_free(&err);
+       }
+
+       if (NULL != result_msg) {
+               dbus_message_get_args(result_msg, &err,
+                       DBUS_TYPE_INT32, &result,
+                       DBUS_TYPE_INVALID);
+
+               if (dbus_error_is_set(&err)) {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : Get arguments error (%s)", err.message);
+                       dbus_error_free(&err);
+                       result = TTS_ERROR_OPERATION_FAILED;
+               }
+               dbus_message_unref(result_msg);
+
+               if (0 == result) {
+                       SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
+               } else {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
+               }
+       } else {
+               SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
+               tts_dbus_reconnect();
+               result = TTS_ERROR_TIMED_OUT;
+       }
+
+       return result;
+}
+
+int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
+{
+       DBusMessage* msg;
+       DBusError err;
+       dbus_error_init(&err);
+
+       msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_PCM);
+
+       if (NULL == msg) {
+               SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
+               return TTS_ERROR_OPERATION_FAILED;
+       } else {
+               SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
+       }
+
+       if (true != dbus_message_append_args(msg,
+               DBUS_TYPE_INT32, &uid,
+               DBUS_TYPE_INT32, &event,
+               DBUS_TYPE_INT32, &audio_type,
+               DBUS_TYPE_INT32, &rate,
+               DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
+               &data, data_size,
+               DBUS_TYPE_INVALID)) {
+               dbus_message_unref(msg);
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
+               return TTS_ERROR_OPERATION_FAILED;
+       }
+
+       DBusMessage* result_msg;
+       int result = TTS_ERROR_OPERATION_FAILED;
+
+       result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
+       dbus_message_unref(msg);
+       if (dbus_error_is_set(&err)) {
+               SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
+               dbus_error_free(&err);
+       }
+
+       if (NULL != result_msg) {
+               dbus_message_get_args(result_msg, &err,
+                       DBUS_TYPE_INT32, &result,
+                       DBUS_TYPE_INVALID);
+
+               if (dbus_error_is_set(&err)) {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : Get arguments error (%s)", err.message);
+                       dbus_error_free(&err);
+                       result = TTS_ERROR_OPERATION_FAILED;
+               }
+               dbus_message_unref(result_msg);
+
+               if (0 == result) {
+                       SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
+               } else {
+                       SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
+               }
+       } else {
+               SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
+               tts_dbus_reconnect();
+               result = TTS_ERROR_TIMED_OUT;
+       }
+
+       return result;
+}
+// LCOV_EXCL_STOP