client/tts_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14 #include <Ecore.h>
  15 #include <errno.h>
  16 #include <fcntl.h>
  17 #include <sys/inotify.h>
  18
  19 #include "tts_client.h"
  20 #include "tts_config_mgr.h"
  21 #include "tts_dbus.h"
  22 #include "tts_defs.h"
  23 #include "tts_main.h"
  24
  25
  26 #define HELLO_WAITING_TIME 500
  27 #define WAITING_TIME 5000
  28
  29 static DBusConnection* g_conn_sender = NULL;
  30 static DBusConnection* g_conn_listener = NULL;
  31
  32 static Ecore_Fd_Handler* g_dbus_fd_handler = NULL;
  33
  34
  35 extern int __tts_cb_error(int uid, tts_error_e reason, int utt_id, char *err_msg);
  36
  37 extern int __tts_cb_set_state(int uid, int state);
  38
  39 extern int __tts_cb_utt_started(int uid, int utt_id);
  40
  41 extern int __tts_cb_utt_completed(int uid, int utt_id);
  42
  43
  44 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  45 {
  46         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
  47
  48         dbus_connection_read_write_dispatch(g_conn_listener, 50);
  49
  50         while (1) {
  51                 DBusMessage* msg = NULL;
  52                 msg = dbus_connection_pop_message(g_conn_listener);
  53
  54                 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
  55                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Connection is disconnected");
  56                         break;
  57                 }
  58
  59                 /* loop again if we haven't read a message */
  60                 if (NULL == msg) {
  61                         break;
  62                 }
  63
  64                 DBusError err;
  65                 dbus_error_init(&err);
  66
  67                 char if_name[64] = {0, };
  68                 snprintf(if_name, 64, "%s", TTS_CLIENT_SERVICE_INTERFACE);
  69
  70                 if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) {
  71                         int uid = 0;
  72                         int uttid = 0;
  73
  74                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
  75                         if (dbus_error_is_set(&err)) {
  76                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
  77                                 dbus_error_free(&err);
  78                         }
  79
  80                         if (0 == __tts_cb_utt_started(uid, uttid)) {
  81                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance started : uid(%d) uttid(%d)", uid, uttid);
  82                         }
  83                 } /* TTSD_METHOD_UTTERANCE_STARTED */
  84
  85                 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) {
  86                         int uid = 0;
  87                         int uttid = 0;
  88
  89                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
  90                         if (dbus_error_is_set(&err)) {
  91                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
  92                                 dbus_error_free(&err);
  93                         }
  94
  95                         if (0 == __tts_cb_utt_completed(uid, uttid)) {
  96                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance completed : uid(%d) uttid(%d)", uid, uttid);
  97                         }
  98                 } /* TTS_SIGNAL_UTTERANCE_STARTED */
  99
 100                 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_SET_STATE)) {
 101                         int uid = 0;
 102                         int state = 0;
 103
 104                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 105                         if (dbus_error_is_set(&err)) {
 106                                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
 107                                 dbus_error_free(&err);
 108                         }
 109
 110                         if (0 == __tts_cb_set_state(uid, state)) {
 111                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts state changed : uid(%d) state(%d)", uid, state);
 112                         }
 113                 } /* TTSD_SIGNAL_SET_STATE */
 114
 115                 else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_ERROR)) {
 116                         int uid;
 117                         int uttid;
 118                         int reason;
 119                         char* err_msg;
 120
 121                         dbus_message_get_args(msg, &err,
 122                                 DBUS_TYPE_INT32, &uid,
 123                                 DBUS_TYPE_INT32, &uttid,
 124                                 DBUS_TYPE_INT32, &reason,
 125                                 DBUS_TYPE_STRING, &err_msg,
 126                                 DBUS_TYPE_INVALID);
 127
 128                         if (dbus_error_is_set(&err)) {
 129                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message - Get arguments error (%s)", err.message);
 130                                 dbus_error_free(&err);
 131                         } else {
 132                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%d), error(%d), uttid(%d), err_msg(%s)", uid, reason, uttid, (NULL == err_msg) ? "NULL" : err_msg);
 133                                 __tts_cb_error(uid, reason, uttid, err_msg);
 134
 135                         }
 136                 } /* TTSD_SIGNAL_ERROR */
 137
 138                 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 139                         SLOG(LOG_DEBUG, TAG_TTSC, "===== Owner Changed");
 140                         __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
 141                         SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 142                         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 143                 } /* NameOwnerChanged */
 144
 145                 else {
 146                         SLOG(LOG_DEBUG, TAG_TTSC, "Message is NOT valid");
 147                         dbus_message_unref(msg);
 148                         break;
 149                 }
 150
 151                 /* free the message */
 152                 dbus_message_unref(msg);
 153         }
 154         return ECORE_CALLBACK_PASS_ON;
 155 }
 156
 157 int tts_dbus_open_connection()
 158 {
 159         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 160                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 161                 return 0;
 162         }
 163
 164         DBusError err;
 165
 166         /* initialise the error value */
 167         dbus_error_init(&err);
 168
 169         /* connect to the DBUS system bus, and check for errors */
 170         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 171         if (dbus_error_is_set(&err)) {
 172                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 173                 dbus_error_free(&err);
 174         }
 175
 176         if (NULL == g_conn_sender) {
 177                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection");
 178                 return TTS_ERROR_OPERATION_FAILED;
 179         }
 180
 181         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 182
 183         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 184         if (dbus_error_is_set(&err)) {
 185                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 186                 dbus_error_free(&err);
 187         }
 188
 189         if (NULL == g_conn_listener) {
 190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection for listener");
 191                 return TTS_ERROR_OPERATION_FAILED;
 192         }
 193
 194         char rule[128] = {0, };
 195         snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 196
 197         /* add a rule for which messages we want to see */
 198         dbus_bus_add_match(g_conn_listener, rule, &err);
 199         dbus_connection_flush(g_conn_listener);
 200
 201         int fd = 0;
 202         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 203                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
 204                 return TTS_ERROR_OPERATION_FAILED;
 205         } else {
 206                 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
 207         }
 208
 209         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
 210         if (NULL == g_dbus_fd_handler) {
 211                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
 212                 return TTS_ERROR_OPERATION_FAILED;
 213         }
 214
 215         return 0;
 216 }
 217
 218 int tts_dbus_close_connection()
 219 {
 220         DBusError err;
 221         dbus_error_init(&err);
 222
 223         if (NULL != g_dbus_fd_handler) {
 224                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 225                 g_dbus_fd_handler = NULL;
 226         }
 227
 228         dbus_connection_close(g_conn_sender);
 229         dbus_connection_close(g_conn_listener);
 230
 231         dbus_connection_unref(g_conn_sender);
 232         dbus_connection_unref(g_conn_listener);
 233
 234         g_conn_sender = NULL;
 235         g_conn_listener = NULL;
 236
 237         return 0;
 238 }
 239
 240 int tts_dbus_reconnect()
 241 {
 242         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 243         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 244         SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
 245                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 246
 247         if (false == sender_connected || false == listener_connected) {
 248                 tts_dbus_close_connection();
 249
 250                 if (0 != tts_dbus_open_connection()) {
 251                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 252                         return -1;
 253                 }
 254
 255                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 256         }
 257
 258         return 0;
 259 }
 260
 261 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 262 {
 263         if (NULL == method) {
 264                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
 265                 return NULL;
 266         }
 267
 268         tts_client_s* client = tts_client_get_by_uid(uid);
 269
 270         /* check handle */
 271         if (NULL == client) {
 272                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
 273                 return NULL;
 274         }
 275
 276         DBusMessage* msg;
 277
 278         if (TTS_MODE_DEFAULT == client->mode) {
 279                 msg = dbus_message_new_method_call(
 280                         TTS_SERVER_SERVICE_NAME,
 281                         TTS_SERVER_SERVICE_OBJECT_PATH,
 282                         TTS_SERVER_SERVICE_INTERFACE,
 283                         method);
 284         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 285                 msg = dbus_message_new_method_call(
 286                         TTS_NOTI_SERVER_SERVICE_NAME,
 287                         TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
 288                         TTS_NOTI_SERVER_SERVICE_INTERFACE,
 289                         method);
 290         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 291                 msg = dbus_message_new_method_call(
 292                         TTS_SR_SERVER_SERVICE_NAME,
 293                         TTS_SR_SERVER_SERVICE_OBJECT_PATH,
 294                         TTS_SR_SERVER_SERVICE_INTERFACE,
 295                         method);
 296         } else {
 297                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
 298                 return NULL;
 299         }
 300
 301         return msg;
 302 }
 303
 304 int tts_dbus_request_hello(int uid)
 305 {
 306         DBusError err;
 307         dbus_error_init(&err);
 308         DBusMessage* msg;
 309
 310         msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
 311
 312         if (dbus_error_is_set(&err)) {
 313 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 314                 dbus_error_free(&err);
 315         }
 316
 317         if (NULL == msg) {
 318                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
 319                 return TTS_ERROR_OPERATION_FAILED;
 320         }
 321
 322         DBusMessage* result_msg = NULL;
 323         int result = 0;
 324
 325         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
 326         dbus_message_unref(msg);
 327         if (dbus_error_is_set(&err)) {
 328 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 329                 dbus_error_free(&err);
 330         }
 331
 332         if (NULL != result_msg) {
 333                 dbus_message_unref(result_msg);
 334
 335 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 336                 result = 0;
 337         } else {
 338                 result = TTS_ERROR_TIMED_OUT;
 339         }
 340
 341         return result;
 342 }
 343
 344 int tts_dbus_request_initialize(int uid, bool* credential_needed)
 345 {
 346         DBusMessage* msg;
 347         DBusError err;
 348         dbus_error_init(&err);
 349
 350         msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
 351
 352         if (NULL == msg) {
 353                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
 354                 return TTS_ERROR_OPERATION_FAILED;
 355         } else {
 356                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 357         }
 358
 359         int pid = getpid();
 360         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 361                 dbus_message_unref(msg);
 362                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 363
 364                 return TTS_ERROR_OPERATION_FAILED;
 365         }
 366
 367         DBusMessage* result_msg;
 368         int result = TTS_ERROR_OPERATION_FAILED;
 369
 370         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 371         dbus_message_unref(msg);
 372         if (dbus_error_is_set(&err)) {
 373                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 374                 dbus_error_free(&err);
 375         }
 376
 377         int temp = 0;
 378         if (NULL != result_msg) {
 379                 dbus_message_get_args(result_msg, &err,
 380                                   DBUS_TYPE_INT32, &result,
 381                                   DBUS_TYPE_INT32, &temp,
 382                                   DBUS_TYPE_INVALID);
 383
 384                 if (dbus_error_is_set(&err)) {
 385                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 386                         dbus_error_free(&err);
 387                         result = TTS_ERROR_OPERATION_FAILED;
 388                 }
 389
 390                 dbus_message_unref(result_msg);
 391
 392                 if (0 == result) {
 393                         *credential_needed = (bool)temp;
 394                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d, credential_needed(%d)", result, *credential_needed);
 395
 396                         /* add a rule for daemon error */
 397                         char rule_err[256] = {0, };
 398                         tts_client_s* client = tts_client_get_by_uid(uid);
 399                         if (TTS_MODE_DEFAULT == client->mode) {
 400                                 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);
 401                         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 402                                 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);
 403                         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 404                                 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);
 405                         }
 406                         dbus_bus_add_match(g_conn_listener, rule_err, &err);
 407                         dbus_connection_flush(g_conn_listener);
 408
 409                         if (dbus_error_is_set(&err)) {
 410                                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 411                                 dbus_error_free(&err);
 412                                 return TTS_ERROR_OPERATION_FAILED;
 413                         }
 414                 } else {
 415                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 416                 }
 417         } else {
 418                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 419                 tts_dbus_reconnect();
 420                 result = TTS_ERROR_TIMED_OUT;
 421         }
 422
 423         return result;
 424 }
 425
 426
 427 int tts_dbus_request_finalize(int uid)
 428 {
 429         DBusMessage* msg;
 430         DBusError err;
 431         dbus_error_init(&err);
 432
 433         /* remove a rule for daemon error */
 434         char rule_err[256] = {0, };
 435         tts_client_s* client = tts_client_get_by_uid(uid);
 436         if (TTS_MODE_DEFAULT == client->mode) {
 437                 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);
 438         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 439                 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);
 440         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 441                 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);
 442         }
 443         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
 444         dbus_connection_flush(g_conn_listener);
 445         if (dbus_error_is_set(&err)) {
 446                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 447                 dbus_error_free(&err);
 448         }
 449
 450         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 451
 452         if (NULL == msg) {
 453                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 454                 return TTS_ERROR_OPERATION_FAILED;
 455         } else {
 456                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 457         }
 458
 459         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 460                 dbus_message_unref(msg);
 461                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 462
 463                 return TTS_ERROR_OPERATION_FAILED;
 464         }
 465
 466         DBusMessage* result_msg;
 467         int result = TTS_ERROR_OPERATION_FAILED;
 468
 469         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 470         dbus_message_unref(msg);
 471         if (dbus_error_is_set(&err)) {
 472                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 473                 dbus_error_free(&err);
 474         }
 475
 476         if (NULL != result_msg) {
 477                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 478
 479                 if (dbus_error_is_set(&err)) {
 480                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 481                         dbus_error_free(&err);
 482                         result = TTS_ERROR_OPERATION_FAILED;
 483                 }
 484
 485                 dbus_message_unref(result_msg);
 486
 487                 if (0 == result) {
 488                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 489                 } else {
 490                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 491                 }
 492         } else {
 493                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 494                 tts_dbus_reconnect();
 495                 result = TTS_ERROR_TIMED_OUT;
 496         }
 497
 498         return result;
 499 }
 500
 501 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 502 {
 503         if (NULL == text || NULL == lang) {
 504                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 505                 return TTS_ERROR_INVALID_PARAMETER;
 506         }
 507
 508         DBusMessage* msg;
 509         DBusError err;
 510         dbus_error_init(&err);
 511
 512         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 513
 514         if (NULL == msg) {
 515                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 516                 return TTS_ERROR_OPERATION_FAILED;
 517         } else {
 518                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
 519                          uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
 520         }
 521
 522         char *temp = NULL;
 523         if (NULL == credential) {
 524                 temp = strdup("NULL");
 525         } else {
 526                 temp = strdup(credential);
 527         }
 528
 529         if (true != dbus_message_append_args(msg,
 530                 DBUS_TYPE_INT32, &uid,
 531                 DBUS_TYPE_STRING, &text,
 532                 DBUS_TYPE_STRING, &lang,
 533                 DBUS_TYPE_INT32, &vctype,
 534                 DBUS_TYPE_INT32, &speed,
 535                 DBUS_TYPE_INT32, &uttid,
 536                 DBUS_TYPE_STRING, &temp,
 537                 DBUS_TYPE_INVALID)) {
 538                 dbus_message_unref(msg);
 539                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 540
 541                 if (NULL != temp) {
 542                         free(temp);
 543                         temp = NULL;
 544                 }
 545                 return TTS_ERROR_OPERATION_FAILED;
 546         }
 547
 548         DBusMessage* result_msg;
 549         int result = TTS_ERROR_OPERATION_FAILED;
 550
 551         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 552         dbus_message_unref(msg);
 553         if (dbus_error_is_set(&err)) {
 554                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 555                 dbus_error_free(&err);
 556         }
 557
 558         if (NULL != result_msg) {
 559                 dbus_message_get_args(result_msg, &err,
 560                         DBUS_TYPE_INT32, &result,
 561                         DBUS_TYPE_INVALID);
 562
 563                 if (dbus_error_is_set(&err)) {
 564                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 565                         dbus_error_free(&err);
 566                         result = TTS_ERROR_OPERATION_FAILED;
 567                 }
 568                 dbus_message_unref(result_msg);
 569
 570                 if (0 == result) {
 571                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 572                 } else {
 573                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 574                 }
 575         } else {
 576                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 577                 tts_dbus_reconnect();
 578                 result = TTS_ERROR_TIMED_OUT;
 579         }
 580
 581         if (NULL != temp) {
 582                 free(temp);
 583                 temp = NULL;
 584         }
 585         return result;
 586 }
 587
 588 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
 589 {
 590         if (NULL == key || NULL == data) {
 591                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 592                 return TTS_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         DBusMessage* msg;
 596         DBusError err;
 597         dbus_error_init(&err);
 598
 599         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 600
 601         if (NULL == msg) {
 602                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 603                 return TTS_ERROR_OPERATION_FAILED;
 604         } else {
 605                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 606         }
 607
 608         if (true != dbus_message_append_args(msg,
 609                 DBUS_TYPE_INT32, &uid,
 610                 DBUS_TYPE_STRING, &key,
 611                 DBUS_TYPE_STRING, &data,
 612                 DBUS_TYPE_INVALID)) {
 613                 dbus_message_unref(msg);
 614                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 615
 616                 return TTS_ERROR_OPERATION_FAILED;
 617         }
 618
 619         DBusMessage* result_msg;
 620         int result = TTS_ERROR_OPERATION_FAILED;
 621
 622         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 623         dbus_message_unref(msg);
 624         if (dbus_error_is_set(&err)) {
 625                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 626                 dbus_error_free(&err);
 627         }
 628
 629         if (NULL != result_msg) {
 630                 dbus_message_get_args(result_msg, &err,
 631                         DBUS_TYPE_INT32, &result,
 632                         DBUS_TYPE_INVALID);
 633
 634                 if (dbus_error_is_set(&err)) {
 635                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 636                         dbus_error_free(&err);
 637                         result = TTS_ERROR_OPERATION_FAILED;
 638                 }
 639                 dbus_message_unref(result_msg);
 640
 641                 if (0 == result) {
 642                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 643                 } else {
 644                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 645                 }
 646         } else {
 647                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 648                 tts_dbus_reconnect();
 649                 result = TTS_ERROR_TIMED_OUT;
 650         }
 651
 652         return result;
 653 }
 654
 655 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 656 {
 657         if (NULL == key || NULL == data) {
 658                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 659                 return TTS_ERROR_INVALID_PARAMETER;
 660         }
 661
 662         DBusMessage* msg;
 663         DBusError err;
 664         dbus_error_init(&err);
 665
 666         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 667
 668         if (NULL == msg) {
 669                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 670                 return TTS_ERROR_OPERATION_FAILED;
 671         } else {
 672                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 673         }
 674
 675         if (true != dbus_message_append_args(msg,
 676                 DBUS_TYPE_INT32, &uid,
 677                 DBUS_TYPE_STRING, &key,
 678                 DBUS_TYPE_INVALID)) {
 679                 dbus_message_unref(msg);
 680                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 681
 682                 return TTS_ERROR_OPERATION_FAILED;
 683         }
 684
 685         DBusMessage* result_msg;
 686         int result = TTS_ERROR_OPERATION_FAILED;
 687
 688         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 689         dbus_message_unref(msg);
 690         if (dbus_error_is_set(&err)) {
 691                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 692                 dbus_error_free(&err);
 693         }
 694
 695         char* temp = NULL;
 696         if (NULL != result_msg) {
 697                 dbus_message_get_args(result_msg, &err,
 698                         DBUS_TYPE_INT32, &result,
 699                         DBUS_TYPE_STRING, &temp,
 700                         DBUS_TYPE_INVALID);
 701
 702                 if (dbus_error_is_set(&err)) {
 703                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 704                         dbus_error_free(&err);
 705                         result = TTS_ERROR_OPERATION_FAILED;
 706                 }
 707                 dbus_message_unref(result_msg);
 708
 709                 if (0 == result) {
 710                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 711                         if (NULL != temp) {
 712                                 *data = strdup(temp);
 713                         }
 714                 } else {
 715                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 716                 }
 717         } else {
 718                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 719                 tts_dbus_reconnect();
 720                 result = TTS_ERROR_TIMED_OUT;
 721         }
 722
 723         return result;
 724 }
 725
 726 int tts_dbus_request_play(int uid, const char* credential)
 727 {
 728         DBusMessage* msg;
 729         DBusError err;
 730         dbus_error_init(&err);
 731
 732         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 733
 734         if (NULL == msg) {
 735                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 736                 return TTS_ERROR_OPERATION_FAILED;
 737         } else {
 738                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 739         }
 740
 741         char *temp = NULL;
 742         if (NULL == credential) {
 743                 temp = strdup("NULL");
 744         } else {
 745                 temp = strdup(credential);
 746         }
 747
 748         if (true != dbus_message_append_args(msg,
 749                 DBUS_TYPE_INT32, &uid,
 750                 DBUS_TYPE_STRING, &temp,
 751                 DBUS_TYPE_INVALID)) {
 752                 dbus_message_unref(msg);
 753                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 754
 755                 if (NULL != temp) {
 756                         free(temp);
 757                         temp = NULL;
 758                 }
 759                 return TTS_ERROR_OPERATION_FAILED;
 760         }
 761
 762         DBusMessage* result_msg;
 763         int result = TTS_ERROR_OPERATION_FAILED;
 764
 765         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 766         dbus_message_unref(msg);
 767         if (dbus_error_is_set(&err)) {
 768                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 769                 dbus_error_free(&err);
 770         }
 771
 772         if (NULL != result_msg) {
 773                 dbus_message_get_args(result_msg, &err,
 774                         DBUS_TYPE_INT32, &result,
 775                         DBUS_TYPE_INVALID);
 776
 777                 if (dbus_error_is_set(&err)) {
 778                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 779                         dbus_error_free(&err);
 780                         result = TTS_ERROR_OPERATION_FAILED;
 781                 }
 782                 dbus_message_unref(result_msg);
 783
 784                 if (0 == result) {
 785                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 786                 } else {
 787                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 788                 }
 789         } else {
 790                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 791                 tts_dbus_reconnect();
 792                 result = TTS_ERROR_TIMED_OUT;
 793         }
 794
 795         if (NULL != temp) {
 796                 free(temp);
 797                 temp = NULL;
 798         }
 799         return result;
 800 }
 801
 802 int tts_dbus_request_stop(int uid)
 803 {
 804         DBusMessage* msg;
 805         DBusError err;
 806         dbus_error_init(&err);
 807
 808         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 809
 810         if (NULL == msg) {
 811                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 812                 return TTS_ERROR_OPERATION_FAILED;
 813         } else {
 814                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 815         }
 816
 817         DBusMessage* result_msg;
 818         int result = TTS_ERROR_OPERATION_FAILED;
 819
 820         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 821                 dbus_message_unref(msg);
 822                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 823
 824                 return TTS_ERROR_OPERATION_FAILED;
 825         }
 826
 827         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 828         dbus_message_unref(msg);
 829         if (dbus_error_is_set(&err)) {
 830                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 831                 dbus_error_free(&err);
 832         }
 833
 834         if (NULL != result_msg) {
 835                 dbus_message_get_args(result_msg, &err,
 836                         DBUS_TYPE_INT32, &result,
 837                         DBUS_TYPE_INVALID);
 838
 839                 if (dbus_error_is_set(&err)) {
 840                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 841                         dbus_error_free(&err);
 842                         result = TTS_ERROR_OPERATION_FAILED;
 843                 }
 844                 dbus_message_unref(result_msg);
 845
 846                 if (0 == result) {
 847                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 848                 } else {
 849                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 850                 }
 851         } else {
 852                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 853                 tts_dbus_reconnect();
 854                 result = TTS_ERROR_TIMED_OUT;
 855         }
 856
 857         return result;
 858 }
 859
 860 int tts_dbus_request_pause(int uid)
 861 {
 862         DBusMessage* msg;
 863         DBusError err;
 864         dbus_error_init(&err);
 865
 866         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 867
 868         if (NULL == msg) {
 869                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 870                 return TTS_ERROR_OPERATION_FAILED;
 871         } else {
 872                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 873         }
 874
 875         DBusMessage* result_msg;
 876         int result = TTS_ERROR_OPERATION_FAILED;
 877
 878         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 879                 dbus_message_unref(msg);
 880                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 881
 882                 return TTS_ERROR_OPERATION_FAILED;
 883         }
 884
 885         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 886         dbus_message_unref(msg);
 887         if (dbus_error_is_set(&err)) {
 888                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 889                 dbus_error_free(&err);
 890         }
 891
 892         if (NULL != result_msg) {
 893                 dbus_message_get_args(result_msg, &err,
 894                         DBUS_TYPE_INT32, &result,
 895                         DBUS_TYPE_INVALID);
 896
 897                 if (dbus_error_is_set(&err)) {
 898                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 899                         dbus_error_free(&err);
 900                         result = TTS_ERROR_OPERATION_FAILED;
 901                 }
 902                 dbus_message_unref(result_msg);
 903
 904                 if (0 == result) {
 905                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 906                 } else {
 907                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 908                 }
 909         } else {
 910                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 911                 tts_dbus_reconnect();
 912                 result = TTS_ERROR_TIMED_OUT;
 913         }
 914
 915         return result;
 916 }