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 static void __tts_dbus_connection_free()
 158 {
 159         if (NULL != g_conn_listener) {
 160                 dbus_connection_close(g_conn_listener);
 161                 g_conn_listener = NULL;
 162         }
 163         if (NULL != g_conn_sender) {
 164                 dbus_connection_close(g_conn_sender);
 165                 g_conn_sender = NULL;
 166         }
 167 }
 168
 169 int tts_dbus_open_connection()
 170 {
 171         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 172                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 173                 return 0;
 174         }
 175
 176         DBusError err;
 177
 178         /* initialise the error value */
 179         dbus_error_init(&err);
 180
 181         /* connect to the DBUS system bus, and check for errors */
 182         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 183         if (dbus_error_is_set(&err)) {
 184                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 185                 dbus_error_free(&err);
 186         }
 187
 188         if (NULL == g_conn_sender) {
 189                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection");
 190                 return TTS_ERROR_OPERATION_FAILED;
 191         }
 192
 193         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 194
 195         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 196         if (dbus_error_is_set(&err)) {
 197                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 198                 dbus_error_free(&err);
 199         }
 200
 201         if (NULL == g_conn_listener) {
 202                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection for listener");
 203                 __tts_dbus_connection_free();
 204                 return TTS_ERROR_OPERATION_FAILED;
 205         }
 206
 207         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 208
 209         char rule[128] = {0, };
 210         snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 211
 212         /* add a rule for which messages we want to see */
 213         dbus_bus_add_match(g_conn_listener, rule, &err);
 214         dbus_connection_flush(g_conn_listener);
 215
 216         int fd = 0;
 217         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 218                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
 219                 __tts_dbus_connection_free();
 220                 return TTS_ERROR_OPERATION_FAILED;
 221         } else {
 222                 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
 223         }
 224
 225         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
 226         if (NULL == g_dbus_fd_handler) {
 227                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
 228                 __tts_dbus_connection_free();
 229                 return TTS_ERROR_OPERATION_FAILED;
 230         }
 231
 232         return 0;
 233 }
 234
 235 int tts_dbus_close_connection()
 236 {
 237         DBusError err;
 238         dbus_error_init(&err);
 239
 240         if (NULL != g_dbus_fd_handler) {
 241                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 242                 g_dbus_fd_handler = NULL;
 243         }
 244
 245         __tts_dbus_connection_free();
 246
 247         return 0;
 248 }
 249
 250 int tts_dbus_reconnect()
 251 {
 252         if (!g_conn_sender || !g_conn_listener) {
 253                 tts_dbus_close_connection();
 254
 255                 if (0 != tts_dbus_open_connection()) {
 256                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 257                         return -1;
 258                 }
 259
 260                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 261                 return 0;
 262         }
 263
 264         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 265         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 266         SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
 267                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 268
 269         if (false == sender_connected || false == listener_connected) {
 270                 tts_dbus_close_connection();
 271
 272                 if (0 != tts_dbus_open_connection()) {
 273                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 274                         return -1;
 275                 }
 276
 277                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 278         }
 279
 280         return 0;
 281 }
 282
 283 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 284 {
 285         if (NULL == method) {
 286                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
 287                 return NULL;
 288         }
 289
 290         tts_client_s* client = tts_client_get_by_uid(uid);
 291
 292         /* check handle */
 293         if (NULL == client) {
 294                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
 295                 return NULL;
 296         }
 297
 298         DBusMessage* msg;
 299
 300         if (TTS_MODE_DEFAULT == client->mode) {
 301                 msg = dbus_message_new_method_call(
 302                         TTS_SERVER_SERVICE_NAME,
 303                         TTS_SERVER_SERVICE_OBJECT_PATH,
 304                         TTS_SERVER_SERVICE_INTERFACE,
 305                         method);
 306         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 307                 msg = dbus_message_new_method_call(
 308                         TTS_NOTI_SERVER_SERVICE_NAME,
 309                         TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
 310                         TTS_NOTI_SERVER_SERVICE_INTERFACE,
 311                         method);
 312         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 313                 msg = dbus_message_new_method_call(
 314                         TTS_SR_SERVER_SERVICE_NAME,
 315                         TTS_SR_SERVER_SERVICE_OBJECT_PATH,
 316                         TTS_SR_SERVER_SERVICE_INTERFACE,
 317                         method);
 318         } else {
 319                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
 320                 return NULL;
 321         }
 322
 323         return msg;
 324 }
 325
 326 int tts_dbus_request_hello(int uid)
 327 {
 328         DBusError err;
 329         dbus_error_init(&err);
 330         DBusMessage* msg;
 331
 332         msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
 333
 334         if (dbus_error_is_set(&err)) {
 335 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 336                 dbus_error_free(&err);
 337         }
 338
 339         if (NULL == msg) {
 340                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
 341                 return TTS_ERROR_OPERATION_FAILED;
 342         }
 343
 344         DBusMessage* result_msg = NULL;
 345         int result = 0;
 346
 347         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
 348         dbus_message_unref(msg);
 349         if (dbus_error_is_set(&err)) {
 350 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 351                 dbus_error_free(&err);
 352         }
 353
 354         if (NULL != result_msg) {
 355                 dbus_message_unref(result_msg);
 356
 357 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 358                 result = 0;
 359         } else {
 360                 result = TTS_ERROR_TIMED_OUT;
 361         }
 362
 363         return result;
 364 }
 365
 366 int tts_dbus_request_initialize(int uid, bool* credential_needed)
 367 {
 368         DBusMessage* msg;
 369         DBusError err;
 370         dbus_error_init(&err);
 371
 372         msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
 373
 374         if (NULL == msg) {
 375                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
 376                 return TTS_ERROR_OPERATION_FAILED;
 377         } else {
 378                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 379         }
 380
 381         int pid = getpid();
 382         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 383                 dbus_message_unref(msg);
 384                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 385
 386                 return TTS_ERROR_OPERATION_FAILED;
 387         }
 388
 389         DBusMessage* result_msg;
 390         int result = TTS_ERROR_OPERATION_FAILED;
 391
 392         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 393         dbus_message_unref(msg);
 394         if (dbus_error_is_set(&err)) {
 395                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 396                 dbus_error_free(&err);
 397         }
 398
 399         int temp = 0;
 400         if (NULL != result_msg) {
 401                 dbus_message_get_args(result_msg, &err,
 402                                   DBUS_TYPE_INT32, &result,
 403                                   DBUS_TYPE_INT32, &temp,
 404                                   DBUS_TYPE_INVALID);
 405
 406                 if (dbus_error_is_set(&err)) {
 407                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 408                         dbus_error_free(&err);
 409                         result = TTS_ERROR_OPERATION_FAILED;
 410                 }
 411
 412                 dbus_message_unref(result_msg);
 413
 414                 if (0 == result) {
 415                         *credential_needed = (bool)temp;
 416                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d, credential_needed(%d)", result, *credential_needed);
 417
 418                         /* add a rule for daemon error */
 419                         char rule_err[256] = {0, };
 420                         tts_client_s* client = tts_client_get_by_uid(uid);
 421                         if (NULL == client) {
 422                                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
 423                                 return TTS_ERROR_OPERATION_FAILED;
 424                         }
 425
 426                         if (TTS_ERROR_SERVICE_RESET != client->reason) {
 427                                 if (TTS_MODE_DEFAULT == client->mode) {
 428                                         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);
 429                                 } else if (TTS_MODE_NOTIFICATION == client->mode) {
 430                                         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);
 431                                 } else if (TTS_MODE_SCREEN_READER == client->mode) {
 432                                         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);
 433                                 }
 434                                 dbus_bus_add_match(g_conn_listener, rule_err, &err);
 435                                 dbus_connection_flush(g_conn_listener);
 436
 437                                 if (dbus_error_is_set(&err)) {
 438                                         SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 439                                         dbus_error_free(&err);
 440                                         return TTS_ERROR_OPERATION_FAILED;
 441                                 }
 442                                 client->reason = 0; // default value
 443                         }
 444                 } else {
 445                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 446                 }
 447         } else {
 448                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 449                 tts_dbus_reconnect();
 450                 result = TTS_ERROR_TIMED_OUT;
 451         }
 452
 453         return result;
 454 }
 455
 456
 457 int tts_dbus_request_finalize(int uid)
 458 {
 459         DBusMessage* msg;
 460         DBusError err;
 461         dbus_error_init(&err);
 462
 463         /* remove a rule for daemon error */
 464         char rule_err[256] = {0, };
 465         tts_client_s* client = tts_client_get_by_uid(uid);
 466         if (NULL == client) {
 467                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
 468                 return TTS_ERROR_OPERATION_FAILED;
 469         }
 470
 471         if (TTS_MODE_DEFAULT == client->mode) {
 472                 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);
 473         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 474                 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);
 475         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 476                 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);
 477         }
 478         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
 479         dbus_connection_flush(g_conn_listener);
 480         if (dbus_error_is_set(&err)) {
 481                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 482                 dbus_error_free(&err);
 483         }
 484
 485         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 486
 487         if (NULL == msg) {
 488                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 489                 return TTS_ERROR_OPERATION_FAILED;
 490         } else {
 491                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 492         }
 493
 494         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 495                 dbus_message_unref(msg);
 496                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 497
 498                 return TTS_ERROR_OPERATION_FAILED;
 499         }
 500
 501         DBusMessage* result_msg;
 502         int result = TTS_ERROR_OPERATION_FAILED;
 503
 504         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 505         dbus_message_unref(msg);
 506         if (dbus_error_is_set(&err)) {
 507                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 508                 dbus_error_free(&err);
 509         }
 510
 511         if (NULL != result_msg) {
 512                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 513
 514                 if (dbus_error_is_set(&err)) {
 515                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 516                         dbus_error_free(&err);
 517                         result = TTS_ERROR_OPERATION_FAILED;
 518                 }
 519
 520                 dbus_message_unref(result_msg);
 521
 522                 if (0 == result) {
 523                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 524                 } else {
 525                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 526                 }
 527         } else {
 528                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 529                 tts_dbus_reconnect();
 530                 result = TTS_ERROR_TIMED_OUT;
 531         }
 532
 533         return result;
 534 }
 535
 536 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 537 {
 538         if (NULL == text || NULL == lang) {
 539                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 540                 return TTS_ERROR_INVALID_PARAMETER;
 541         }
 542
 543         DBusMessage* msg;
 544         DBusError err;
 545         dbus_error_init(&err);
 546
 547         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 548
 549         if (NULL == msg) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 551                 return TTS_ERROR_OPERATION_FAILED;
 552         } else {
 553                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
 554                          uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
 555         }
 556
 557         char *temp = NULL;
 558         if (NULL == credential) {
 559                 temp = strdup("NULL");
 560         } else {
 561                 temp = strdup(credential);
 562         }
 563
 564         if (true != dbus_message_append_args(msg,
 565                 DBUS_TYPE_INT32, &uid,
 566                 DBUS_TYPE_STRING, &text,
 567                 DBUS_TYPE_STRING, &lang,
 568                 DBUS_TYPE_INT32, &vctype,
 569                 DBUS_TYPE_INT32, &speed,
 570                 DBUS_TYPE_INT32, &uttid,
 571                 DBUS_TYPE_STRING, &temp,
 572                 DBUS_TYPE_INVALID)) {
 573                 dbus_message_unref(msg);
 574                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 575
 576                 if (NULL != temp) {
 577                         free(temp);
 578                         temp = NULL;
 579                 }
 580                 return TTS_ERROR_OPERATION_FAILED;
 581         }
 582
 583         DBusMessage* result_msg;
 584         int result = TTS_ERROR_OPERATION_FAILED;
 585
 586         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 587         dbus_message_unref(msg);
 588         if (dbus_error_is_set(&err)) {
 589                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 590                 dbus_error_free(&err);
 591         }
 592
 593         if (NULL != result_msg) {
 594                 dbus_message_get_args(result_msg, &err,
 595                         DBUS_TYPE_INT32, &result,
 596                         DBUS_TYPE_INVALID);
 597
 598                 if (dbus_error_is_set(&err)) {
 599                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 600                         dbus_error_free(&err);
 601                         result = TTS_ERROR_OPERATION_FAILED;
 602                 }
 603                 dbus_message_unref(result_msg);
 604
 605                 if (0 == result) {
 606                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 607                 } else {
 608                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 609                 }
 610         } else {
 611                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 612                 tts_dbus_reconnect();
 613                 result = TTS_ERROR_TIMED_OUT;
 614         }
 615
 616         if (NULL != temp) {
 617                 free(temp);
 618                 temp = NULL;
 619         }
 620         return result;
 621 }
 622
 623 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
 624 {
 625         if (NULL == key || NULL == data) {
 626                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 627                 return TTS_ERROR_INVALID_PARAMETER;
 628         }
 629
 630         DBusMessage* msg;
 631         DBusError err;
 632         dbus_error_init(&err);
 633
 634         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 635
 636         if (NULL == msg) {
 637                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 638                 return TTS_ERROR_OPERATION_FAILED;
 639         } else {
 640                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 641         }
 642
 643         if (true != dbus_message_append_args(msg,
 644                 DBUS_TYPE_INT32, &uid,
 645                 DBUS_TYPE_STRING, &key,
 646                 DBUS_TYPE_STRING, &data,
 647                 DBUS_TYPE_INVALID)) {
 648                 dbus_message_unref(msg);
 649                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 650
 651                 return TTS_ERROR_OPERATION_FAILED;
 652         }
 653
 654         DBusMessage* result_msg;
 655         int result = TTS_ERROR_OPERATION_FAILED;
 656
 657         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 658         dbus_message_unref(msg);
 659         if (dbus_error_is_set(&err)) {
 660                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 661                 dbus_error_free(&err);
 662         }
 663
 664         if (NULL != result_msg) {
 665                 dbus_message_get_args(result_msg, &err,
 666                         DBUS_TYPE_INT32, &result,
 667                         DBUS_TYPE_INVALID);
 668
 669                 if (dbus_error_is_set(&err)) {
 670                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 671                         dbus_error_free(&err);
 672                         result = TTS_ERROR_OPERATION_FAILED;
 673                 }
 674                 dbus_message_unref(result_msg);
 675
 676                 if (0 == result) {
 677                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 678                 } else {
 679                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 680                 }
 681         } else {
 682                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 683                 tts_dbus_reconnect();
 684                 result = TTS_ERROR_TIMED_OUT;
 685         }
 686
 687         return result;
 688 }
 689
 690 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 691 {
 692         if (NULL == key || NULL == data) {
 693                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 694                 return TTS_ERROR_INVALID_PARAMETER;
 695         }
 696
 697         DBusMessage* msg;
 698         DBusError err;
 699         dbus_error_init(&err);
 700
 701         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 702
 703         if (NULL == msg) {
 704                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 705                 return TTS_ERROR_OPERATION_FAILED;
 706         } else {
 707                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 708         }
 709
 710         if (true != dbus_message_append_args(msg,
 711                 DBUS_TYPE_INT32, &uid,
 712                 DBUS_TYPE_STRING, &key,
 713                 DBUS_TYPE_INVALID)) {
 714                 dbus_message_unref(msg);
 715                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 716
 717                 return TTS_ERROR_OPERATION_FAILED;
 718         }
 719
 720         DBusMessage* result_msg;
 721         int result = TTS_ERROR_OPERATION_FAILED;
 722
 723         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 724         dbus_message_unref(msg);
 725         if (dbus_error_is_set(&err)) {
 726                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 727                 dbus_error_free(&err);
 728         }
 729
 730         char* temp = NULL;
 731         if (NULL != result_msg) {
 732                 dbus_message_get_args(result_msg, &err,
 733                         DBUS_TYPE_INT32, &result,
 734                         DBUS_TYPE_STRING, &temp,
 735                         DBUS_TYPE_INVALID);
 736
 737                 if (dbus_error_is_set(&err)) {
 738                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 739                         dbus_error_free(&err);
 740                         result = TTS_ERROR_OPERATION_FAILED;
 741                 }
 742                 dbus_message_unref(result_msg);
 743
 744                 if (0 == result) {
 745                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 746                         if (NULL != temp) {
 747                                 *data = strdup(temp);
 748                         }
 749                 } else {
 750                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 751                 }
 752         } else {
 753                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 754                 tts_dbus_reconnect();
 755                 result = TTS_ERROR_TIMED_OUT;
 756         }
 757
 758         return result;
 759 }
 760
 761 int tts_dbus_request_play(int uid, const char* credential)
 762 {
 763         DBusMessage* msg;
 764         DBusError err;
 765         dbus_error_init(&err);
 766
 767         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 768
 769         if (NULL == msg) {
 770                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 771                 return TTS_ERROR_OPERATION_FAILED;
 772         } else {
 773                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 774         }
 775
 776         char *temp = NULL;
 777         if (NULL == credential) {
 778                 temp = strdup("NULL");
 779         } else {
 780                 temp = strdup(credential);
 781         }
 782
 783         if (true != dbus_message_append_args(msg,
 784                 DBUS_TYPE_INT32, &uid,
 785                 DBUS_TYPE_STRING, &temp,
 786                 DBUS_TYPE_INVALID)) {
 787                 dbus_message_unref(msg);
 788                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 789
 790                 if (NULL != temp) {
 791                         free(temp);
 792                         temp = NULL;
 793                 }
 794                 return TTS_ERROR_OPERATION_FAILED;
 795         }
 796
 797         DBusMessage* result_msg;
 798         int result = TTS_ERROR_OPERATION_FAILED;
 799
 800         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 801         dbus_message_unref(msg);
 802         if (dbus_error_is_set(&err)) {
 803                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 804                 dbus_error_free(&err);
 805         }
 806
 807         if (NULL != result_msg) {
 808                 dbus_message_get_args(result_msg, &err,
 809                         DBUS_TYPE_INT32, &result,
 810                         DBUS_TYPE_INVALID);
 811
 812                 if (dbus_error_is_set(&err)) {
 813                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 814                         dbus_error_free(&err);
 815                         result = TTS_ERROR_OPERATION_FAILED;
 816                 }
 817                 dbus_message_unref(result_msg);
 818
 819                 if (0 == result) {
 820                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 821                 } else {
 822                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 823                 }
 824         } else {
 825                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 826                 tts_dbus_reconnect();
 827                 result = TTS_ERROR_TIMED_OUT;
 828         }
 829
 830         if (NULL != temp) {
 831                 free(temp);
 832                 temp = NULL;
 833         }
 834         return result;
 835 }
 836
 837 int tts_dbus_request_stop(int uid)
 838 {
 839         DBusMessage* msg;
 840         DBusError err;
 841         dbus_error_init(&err);
 842
 843         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 844
 845         if (NULL == msg) {
 846                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 847                 return TTS_ERROR_OPERATION_FAILED;
 848         } else {
 849                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 850         }
 851
 852         DBusMessage* result_msg;
 853         int result = TTS_ERROR_OPERATION_FAILED;
 854
 855         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 856                 dbus_message_unref(msg);
 857                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 858
 859                 return TTS_ERROR_OPERATION_FAILED;
 860         }
 861
 862         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 863         dbus_message_unref(msg);
 864         if (dbus_error_is_set(&err)) {
 865                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 866                 dbus_error_free(&err);
 867         }
 868
 869         if (NULL != result_msg) {
 870                 dbus_message_get_args(result_msg, &err,
 871                         DBUS_TYPE_INT32, &result,
 872                         DBUS_TYPE_INVALID);
 873
 874                 if (dbus_error_is_set(&err)) {
 875                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 876                         dbus_error_free(&err);
 877                         result = TTS_ERROR_OPERATION_FAILED;
 878                 }
 879                 dbus_message_unref(result_msg);
 880
 881                 if (0 == result) {
 882                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 883                 } else {
 884                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 885                 }
 886         } else {
 887                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 888                 tts_dbus_reconnect();
 889                 result = TTS_ERROR_TIMED_OUT;
 890         }
 891
 892         return result;
 893 }
 894
 895 int tts_dbus_request_pause(int uid)
 896 {
 897         DBusMessage* msg;
 898         DBusError err;
 899         dbus_error_init(&err);
 900
 901         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 902
 903         if (NULL == msg) {
 904                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 905                 return TTS_ERROR_OPERATION_FAILED;
 906         } else {
 907                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 908         }
 909
 910         DBusMessage* result_msg;
 911         int result = TTS_ERROR_OPERATION_FAILED;
 912
 913         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 914                 dbus_message_unref(msg);
 915                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 916
 917                 return TTS_ERROR_OPERATION_FAILED;
 918         }
 919
 920         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 921         dbus_message_unref(msg);
 922         if (dbus_error_is_set(&err)) {
 923                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 924                 dbus_error_free(&err);
 925         }
 926
 927         if (NULL != result_msg) {
 928                 dbus_message_get_args(result_msg, &err,
 929                         DBUS_TYPE_INT32, &result,
 930                         DBUS_TYPE_INVALID);
 931
 932                 if (dbus_error_is_set(&err)) {
 933                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 934                         dbus_error_free(&err);
 935                         result = TTS_ERROR_OPERATION_FAILED;
 936                 }
 937                 dbus_message_unref(result_msg);
 938
 939                 if (0 == result) {
 940                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 941                 } else {
 942                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 943                 }
 944         } else {
 945                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 946                 tts_dbus_reconnect();
 947                 result = TTS_ERROR_TIMED_OUT;
 948         }
 949
 950         return result;
 951 }
 952
 953 int tts_dbus_request_play_pcm(int uid)
 954 {
 955         DBusMessage* msg;
 956         DBusError err;
 957         dbus_error_init(&err);
 958
 959         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY_PCM);
 960
 961         if (NULL == msg) {
 962                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
 963                 return TTS_ERROR_OPERATION_FAILED;
 964         } else {
 965                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
 966         }
 967
 968         if (true != dbus_message_append_args(msg,
 969                 DBUS_TYPE_INT32, &uid,
 970                 DBUS_TYPE_INVALID)) {
 971                 dbus_message_unref(msg);
 972                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 973                 return TTS_ERROR_OPERATION_FAILED;
 974         }
 975
 976         DBusMessage* result_msg;
 977         int result = TTS_ERROR_OPERATION_FAILED;
 978
 979         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 980         dbus_message_unref(msg);
 981         if (dbus_error_is_set(&err)) {
 982                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 983                 dbus_error_free(&err);
 984         }
 985
 986         if (NULL != result_msg) {
 987                 dbus_message_get_args(result_msg, &err,
 988                         DBUS_TYPE_INT32, &result,
 989                         DBUS_TYPE_INVALID);
 990
 991                 if (dbus_error_is_set(&err)) {
 992                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : Get arguments error (%s)", err.message);
 993                         dbus_error_free(&err);
 994                         result = TTS_ERROR_OPERATION_FAILED;
 995                 }
 996                 dbus_message_unref(result_msg);
 997
 998                 if (0 == result) {
 999                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1000                 } else {
1001                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1002                 }
1003         } else {
1004                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1005                 tts_dbus_reconnect();
1006                 result = TTS_ERROR_TIMED_OUT;
1007         }
1008
1009         return result;
1010 }
1011
1012 int tts_dbus_request_stop_pcm(int uid)
1013 {
1014         DBusMessage* msg;
1015         DBusError err;
1016         dbus_error_init(&err);
1017
1018         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP_PCM);
1019
1020         if (NULL == msg) {
1021                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
1022                 return TTS_ERROR_OPERATION_FAILED;
1023         } else {
1024                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
1025         }
1026
1027         if (true != dbus_message_append_args(msg,
1028                 DBUS_TYPE_INT32, &uid,
1029                 DBUS_TYPE_INVALID)) {
1030                 dbus_message_unref(msg);
1031                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1032                 return TTS_ERROR_OPERATION_FAILED;
1033         }
1034
1035         DBusMessage* result_msg;
1036         int result = TTS_ERROR_OPERATION_FAILED;
1037
1038         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1039         dbus_message_unref(msg);
1040         if (dbus_error_is_set(&err)) {
1041                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1042                 dbus_error_free(&err);
1043         }
1044
1045         if (NULL != result_msg) {
1046                 dbus_message_get_args(result_msg, &err,
1047                         DBUS_TYPE_INT32, &result,
1048                         DBUS_TYPE_INVALID);
1049
1050                 if (dbus_error_is_set(&err)) {
1051                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : Get arguments error (%s)", err.message);
1052                         dbus_error_free(&err);
1053                         result = TTS_ERROR_OPERATION_FAILED;
1054                 }
1055                 dbus_message_unref(result_msg);
1056
1057                 if (0 == result) {
1058                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1059                 } else {
1060                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1061                 }
1062         } else {
1063                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1064                 tts_dbus_reconnect();
1065                 result = TTS_ERROR_TIMED_OUT;
1066         }
1067
1068         return result;
1069 }
1070
1071 int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
1072 {
1073         DBusMessage* msg;
1074         DBusError err;
1075         dbus_error_init(&err);
1076
1077         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_PCM);
1078
1079         if (NULL == msg) {
1080                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
1081                 return TTS_ERROR_OPERATION_FAILED;
1082         } else {
1083                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
1084         }
1085
1086         if (true != dbus_message_append_args(msg,
1087                 DBUS_TYPE_INT32, &uid,
1088                 DBUS_TYPE_INT32, &event,
1089                 DBUS_TYPE_INT32, &audio_type,
1090                 DBUS_TYPE_INT32, &rate,
1091                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1092                 &data, data_size,
1093                 DBUS_TYPE_INVALID)) {
1094                 dbus_message_unref(msg);
1095                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1096                 return TTS_ERROR_OPERATION_FAILED;
1097         }
1098
1099         DBusMessage* result_msg;
1100         int result = TTS_ERROR_OPERATION_FAILED;
1101
1102         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1103         dbus_message_unref(msg);
1104         if (dbus_error_is_set(&err)) {
1105                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1106                 dbus_error_free(&err);
1107         }
1108
1109         if (NULL != result_msg) {
1110                 dbus_message_get_args(result_msg, &err,
1111                         DBUS_TYPE_INT32, &result,
1112                         DBUS_TYPE_INVALID);
1113
1114                 if (dbus_error_is_set(&err)) {
1115                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : Get arguments error (%s)", err.message);
1116                         dbus_error_free(&err);
1117                         result = TTS_ERROR_OPERATION_FAILED;
1118                 }
1119                 dbus_message_unref(result_msg);
1120
1121                 if (0 == result) {
1122                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1123                 } else {
1124                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1125                 }
1126         } else {
1127                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1128                 tts_dbus_reconnect();
1129                 result = TTS_ERROR_TIMED_OUT;
1130         }
1131
1132         return result;
1133 }