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_MODE_DEFAULT == client->mode) {
 427                                 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);
 428                         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 429                                 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);
 430                         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 431                                 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);
 432                         }
 433                         dbus_bus_add_match(g_conn_listener, rule_err, &err);
 434                         dbus_connection_flush(g_conn_listener);
 435
 436                         if (dbus_error_is_set(&err)) {
 437                                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 438                                 dbus_error_free(&err);
 439                                 return TTS_ERROR_OPERATION_FAILED;
 440                         }
 441                 } else {
 442                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 443                 }
 444         } else {
 445                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 446                 tts_dbus_reconnect();
 447                 result = TTS_ERROR_TIMED_OUT;
 448         }
 449
 450         return result;
 451 }
 452
 453
 454 int tts_dbus_request_finalize(int uid)
 455 {
 456         DBusMessage* msg;
 457         DBusError err;
 458         dbus_error_init(&err);
 459
 460         /* remove a rule for daemon error */
 461         char rule_err[256] = {0, };
 462         tts_client_s* client = tts_client_get_by_uid(uid);
 463         if (NULL == client) {
 464                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
 465                 return TTS_ERROR_OPERATION_FAILED;
 466         }
 467
 468         if (TTS_MODE_DEFAULT == client->mode) {
 469                 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);
 470         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 471                 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);
 472         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 473                 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);
 474         }
 475         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
 476         dbus_connection_flush(g_conn_listener);
 477         if (dbus_error_is_set(&err)) {
 478                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 479                 dbus_error_free(&err);
 480         }
 481
 482         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 483
 484         if (NULL == msg) {
 485                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 486                 return TTS_ERROR_OPERATION_FAILED;
 487         } else {
 488                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 489         }
 490
 491         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 492                 dbus_message_unref(msg);
 493                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 494
 495                 return TTS_ERROR_OPERATION_FAILED;
 496         }
 497
 498         DBusMessage* result_msg;
 499         int result = TTS_ERROR_OPERATION_FAILED;
 500
 501         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 502         dbus_message_unref(msg);
 503         if (dbus_error_is_set(&err)) {
 504                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 505                 dbus_error_free(&err);
 506         }
 507
 508         if (NULL != result_msg) {
 509                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 510
 511                 if (dbus_error_is_set(&err)) {
 512                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 513                         dbus_error_free(&err);
 514                         result = TTS_ERROR_OPERATION_FAILED;
 515                 }
 516
 517                 dbus_message_unref(result_msg);
 518
 519                 if (0 == result) {
 520                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 521                 } else {
 522                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 523                 }
 524         } else {
 525                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 526                 tts_dbus_reconnect();
 527                 result = TTS_ERROR_TIMED_OUT;
 528         }
 529
 530         return result;
 531 }
 532
 533 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 534 {
 535         if (NULL == text || NULL == lang) {
 536                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 537                 return TTS_ERROR_INVALID_PARAMETER;
 538         }
 539
 540         DBusMessage* msg;
 541         DBusError err;
 542         dbus_error_init(&err);
 543
 544         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 545
 546         if (NULL == msg) {
 547                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 548                 return TTS_ERROR_OPERATION_FAILED;
 549         } else {
 550                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
 551                          uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
 552         }
 553
 554         char *temp = NULL;
 555         if (NULL == credential) {
 556                 temp = strdup("NULL");
 557         } else {
 558                 temp = strdup(credential);
 559         }
 560
 561         if (true != dbus_message_append_args(msg,
 562                 DBUS_TYPE_INT32, &uid,
 563                 DBUS_TYPE_STRING, &text,
 564                 DBUS_TYPE_STRING, &lang,
 565                 DBUS_TYPE_INT32, &vctype,
 566                 DBUS_TYPE_INT32, &speed,
 567                 DBUS_TYPE_INT32, &uttid,
 568                 DBUS_TYPE_STRING, &temp,
 569                 DBUS_TYPE_INVALID)) {
 570                 dbus_message_unref(msg);
 571                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 572
 573                 if (NULL != temp) {
 574                         free(temp);
 575                         temp = NULL;
 576                 }
 577                 return TTS_ERROR_OPERATION_FAILED;
 578         }
 579
 580         DBusMessage* result_msg;
 581         int result = TTS_ERROR_OPERATION_FAILED;
 582
 583         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 584         dbus_message_unref(msg);
 585         if (dbus_error_is_set(&err)) {
 586                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 587                 dbus_error_free(&err);
 588         }
 589
 590         if (NULL != result_msg) {
 591                 dbus_message_get_args(result_msg, &err,
 592                         DBUS_TYPE_INT32, &result,
 593                         DBUS_TYPE_INVALID);
 594
 595                 if (dbus_error_is_set(&err)) {
 596                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 597                         dbus_error_free(&err);
 598                         result = TTS_ERROR_OPERATION_FAILED;
 599                 }
 600                 dbus_message_unref(result_msg);
 601
 602                 if (0 == result) {
 603                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 604                 } else {
 605                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 606                 }
 607         } else {
 608                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 609                 tts_dbus_reconnect();
 610                 result = TTS_ERROR_TIMED_OUT;
 611         }
 612
 613         if (NULL != temp) {
 614                 free(temp);
 615                 temp = NULL;
 616         }
 617         return result;
 618 }
 619
 620 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
 621 {
 622         if (NULL == key || NULL == data) {
 623                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 624                 return TTS_ERROR_INVALID_PARAMETER;
 625         }
 626
 627         DBusMessage* msg;
 628         DBusError err;
 629         dbus_error_init(&err);
 630
 631         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 632
 633         if (NULL == msg) {
 634                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 635                 return TTS_ERROR_OPERATION_FAILED;
 636         } else {
 637                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 638         }
 639
 640         if (true != dbus_message_append_args(msg,
 641                 DBUS_TYPE_INT32, &uid,
 642                 DBUS_TYPE_STRING, &key,
 643                 DBUS_TYPE_STRING, &data,
 644                 DBUS_TYPE_INVALID)) {
 645                 dbus_message_unref(msg);
 646                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 647
 648                 return TTS_ERROR_OPERATION_FAILED;
 649         }
 650
 651         DBusMessage* result_msg;
 652         int result = TTS_ERROR_OPERATION_FAILED;
 653
 654         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 655         dbus_message_unref(msg);
 656         if (dbus_error_is_set(&err)) {
 657                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 658                 dbus_error_free(&err);
 659         }
 660
 661         if (NULL != result_msg) {
 662                 dbus_message_get_args(result_msg, &err,
 663                         DBUS_TYPE_INT32, &result,
 664                         DBUS_TYPE_INVALID);
 665
 666                 if (dbus_error_is_set(&err)) {
 667                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 668                         dbus_error_free(&err);
 669                         result = TTS_ERROR_OPERATION_FAILED;
 670                 }
 671                 dbus_message_unref(result_msg);
 672
 673                 if (0 == result) {
 674                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 675                 } else {
 676                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 677                 }
 678         } else {
 679                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 680                 tts_dbus_reconnect();
 681                 result = TTS_ERROR_TIMED_OUT;
 682         }
 683
 684         return result;
 685 }
 686
 687 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 688 {
 689         if (NULL == key || NULL == data) {
 690                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 691                 return TTS_ERROR_INVALID_PARAMETER;
 692         }
 693
 694         DBusMessage* msg;
 695         DBusError err;
 696         dbus_error_init(&err);
 697
 698         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 699
 700         if (NULL == msg) {
 701                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 702                 return TTS_ERROR_OPERATION_FAILED;
 703         } else {
 704                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 705         }
 706
 707         if (true != dbus_message_append_args(msg,
 708                 DBUS_TYPE_INT32, &uid,
 709                 DBUS_TYPE_STRING, &key,
 710                 DBUS_TYPE_INVALID)) {
 711                 dbus_message_unref(msg);
 712                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 713
 714                 return TTS_ERROR_OPERATION_FAILED;
 715         }
 716
 717         DBusMessage* result_msg;
 718         int result = TTS_ERROR_OPERATION_FAILED;
 719
 720         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 721         dbus_message_unref(msg);
 722         if (dbus_error_is_set(&err)) {
 723                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 724                 dbus_error_free(&err);
 725         }
 726
 727         char* temp = NULL;
 728         if (NULL != result_msg) {
 729                 dbus_message_get_args(result_msg, &err,
 730                         DBUS_TYPE_INT32, &result,
 731                         DBUS_TYPE_STRING, &temp,
 732                         DBUS_TYPE_INVALID);
 733
 734                 if (dbus_error_is_set(&err)) {
 735                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 736                         dbus_error_free(&err);
 737                         result = TTS_ERROR_OPERATION_FAILED;
 738                 }
 739                 dbus_message_unref(result_msg);
 740
 741                 if (0 == result) {
 742                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 743                         if (NULL != temp) {
 744                                 *data = strdup(temp);
 745                         }
 746                 } else {
 747                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 748                 }
 749         } else {
 750                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 751                 tts_dbus_reconnect();
 752                 result = TTS_ERROR_TIMED_OUT;
 753         }
 754
 755         return result;
 756 }
 757
 758 int tts_dbus_request_play(int uid, const char* credential)
 759 {
 760         DBusMessage* msg;
 761         DBusError err;
 762         dbus_error_init(&err);
 763
 764         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 765
 766         if (NULL == msg) {
 767                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 768                 return TTS_ERROR_OPERATION_FAILED;
 769         } else {
 770                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 771         }
 772
 773         char *temp = NULL;
 774         if (NULL == credential) {
 775                 temp = strdup("NULL");
 776         } else {
 777                 temp = strdup(credential);
 778         }
 779
 780         if (true != dbus_message_append_args(msg,
 781                 DBUS_TYPE_INT32, &uid,
 782                 DBUS_TYPE_STRING, &temp,
 783                 DBUS_TYPE_INVALID)) {
 784                 dbus_message_unref(msg);
 785                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 786
 787                 if (NULL != temp) {
 788                         free(temp);
 789                         temp = NULL;
 790                 }
 791                 return TTS_ERROR_OPERATION_FAILED;
 792         }
 793
 794         DBusMessage* result_msg;
 795         int result = TTS_ERROR_OPERATION_FAILED;
 796
 797         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 798         dbus_message_unref(msg);
 799         if (dbus_error_is_set(&err)) {
 800                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 801                 dbus_error_free(&err);
 802         }
 803
 804         if (NULL != result_msg) {
 805                 dbus_message_get_args(result_msg, &err,
 806                         DBUS_TYPE_INT32, &result,
 807                         DBUS_TYPE_INVALID);
 808
 809                 if (dbus_error_is_set(&err)) {
 810                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 811                         dbus_error_free(&err);
 812                         result = TTS_ERROR_OPERATION_FAILED;
 813                 }
 814                 dbus_message_unref(result_msg);
 815
 816                 if (0 == result) {
 817                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 818                 } else {
 819                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 820                 }
 821         } else {
 822                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 823                 tts_dbus_reconnect();
 824                 result = TTS_ERROR_TIMED_OUT;
 825         }
 826
 827         if (NULL != temp) {
 828                 free(temp);
 829                 temp = NULL;
 830         }
 831         return result;
 832 }
 833
 834 int tts_dbus_request_stop(int uid)
 835 {
 836         DBusMessage* msg;
 837         DBusError err;
 838         dbus_error_init(&err);
 839
 840         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 841
 842         if (NULL == msg) {
 843                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 844                 return TTS_ERROR_OPERATION_FAILED;
 845         } else {
 846                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 847         }
 848
 849         DBusMessage* result_msg;
 850         int result = TTS_ERROR_OPERATION_FAILED;
 851
 852         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 853                 dbus_message_unref(msg);
 854                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 855
 856                 return TTS_ERROR_OPERATION_FAILED;
 857         }
 858
 859         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 860         dbus_message_unref(msg);
 861         if (dbus_error_is_set(&err)) {
 862                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 863                 dbus_error_free(&err);
 864         }
 865
 866         if (NULL != result_msg) {
 867                 dbus_message_get_args(result_msg, &err,
 868                         DBUS_TYPE_INT32, &result,
 869                         DBUS_TYPE_INVALID);
 870
 871                 if (dbus_error_is_set(&err)) {
 872                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 873                         dbus_error_free(&err);
 874                         result = TTS_ERROR_OPERATION_FAILED;
 875                 }
 876                 dbus_message_unref(result_msg);
 877
 878                 if (0 == result) {
 879                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 880                 } else {
 881                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 882                 }
 883         } else {
 884                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 885                 tts_dbus_reconnect();
 886                 result = TTS_ERROR_TIMED_OUT;
 887         }
 888
 889         return result;
 890 }
 891
 892 int tts_dbus_request_pause(int uid)
 893 {
 894         DBusMessage* msg;
 895         DBusError err;
 896         dbus_error_init(&err);
 897
 898         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 899
 900         if (NULL == msg) {
 901                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 902                 return TTS_ERROR_OPERATION_FAILED;
 903         } else {
 904                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 905         }
 906
 907         DBusMessage* result_msg;
 908         int result = TTS_ERROR_OPERATION_FAILED;
 909
 910         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 911                 dbus_message_unref(msg);
 912                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 913
 914                 return TTS_ERROR_OPERATION_FAILED;
 915         }
 916
 917         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 918         dbus_message_unref(msg);
 919         if (dbus_error_is_set(&err)) {
 920                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 921                 dbus_error_free(&err);
 922         }
 923
 924         if (NULL != result_msg) {
 925                 dbus_message_get_args(result_msg, &err,
 926                         DBUS_TYPE_INT32, &result,
 927                         DBUS_TYPE_INVALID);
 928
 929                 if (dbus_error_is_set(&err)) {
 930                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 931                         dbus_error_free(&err);
 932                         result = TTS_ERROR_OPERATION_FAILED;
 933                 }
 934                 dbus_message_unref(result_msg);
 935
 936                 if (0 == result) {
 937                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 938                 } else {
 939                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 940                 }
 941         } else {
 942                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 943                 tts_dbus_reconnect();
 944                 result = TTS_ERROR_TIMED_OUT;
 945         }
 946
 947         return result;
 948 }
 949
 950 int tts_dbus_request_play_pcm(int uid)
 951 {
 952         DBusMessage* msg;
 953         DBusError err;
 954         dbus_error_init(&err);
 955
 956         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY_PCM);
 957
 958         if (NULL == msg) {
 959                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
 960                 return TTS_ERROR_OPERATION_FAILED;
 961         } else {
 962                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
 963         }
 964
 965         if (true != dbus_message_append_args(msg,
 966                 DBUS_TYPE_INT32, &uid,
 967                 DBUS_TYPE_INVALID)) {
 968                 dbus_message_unref(msg);
 969                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 970                 return TTS_ERROR_OPERATION_FAILED;
 971         }
 972
 973         DBusMessage* result_msg;
 974         int result = TTS_ERROR_OPERATION_FAILED;
 975
 976         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 977         dbus_message_unref(msg);
 978         if (dbus_error_is_set(&err)) {
 979                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 980                 dbus_error_free(&err);
 981         }
 982
 983         if (NULL != result_msg) {
 984                 dbus_message_get_args(result_msg, &err,
 985                         DBUS_TYPE_INT32, &result,
 986                         DBUS_TYPE_INVALID);
 987
 988                 if (dbus_error_is_set(&err)) {
 989                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : Get arguments error (%s)", err.message);
 990                         dbus_error_free(&err);
 991                         result = TTS_ERROR_OPERATION_FAILED;
 992                 }
 993                 dbus_message_unref(result_msg);
 994
 995                 if (0 == result) {
 996                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
 997                 } else {
 998                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
 999                 }
1000         } else {
1001                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1002                 tts_dbus_reconnect();
1003                 result = TTS_ERROR_TIMED_OUT;
1004         }
1005
1006         return result;
1007 }
1008
1009 int tts_dbus_request_stop_pcm(int uid)
1010 {
1011         DBusMessage* msg;
1012         DBusError err;
1013         dbus_error_init(&err);
1014
1015         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP_PCM);
1016
1017         if (NULL == msg) {
1018                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
1019                 return TTS_ERROR_OPERATION_FAILED;
1020         } else {
1021                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
1022         }
1023
1024         if (true != dbus_message_append_args(msg,
1025                 DBUS_TYPE_INT32, &uid,
1026                 DBUS_TYPE_INVALID)) {
1027                 dbus_message_unref(msg);
1028                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1029                 return TTS_ERROR_OPERATION_FAILED;
1030         }
1031
1032         DBusMessage* result_msg;
1033         int result = TTS_ERROR_OPERATION_FAILED;
1034
1035         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1036         dbus_message_unref(msg);
1037         if (dbus_error_is_set(&err)) {
1038                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1039                 dbus_error_free(&err);
1040         }
1041
1042         if (NULL != result_msg) {
1043                 dbus_message_get_args(result_msg, &err,
1044                         DBUS_TYPE_INT32, &result,
1045                         DBUS_TYPE_INVALID);
1046
1047                 if (dbus_error_is_set(&err)) {
1048                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : Get arguments error (%s)", err.message);
1049                         dbus_error_free(&err);
1050                         result = TTS_ERROR_OPERATION_FAILED;
1051                 }
1052                 dbus_message_unref(result_msg);
1053
1054                 if (0 == result) {
1055                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1056                 } else {
1057                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1058                 }
1059         } else {
1060                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1061                 tts_dbus_reconnect();
1062                 result = TTS_ERROR_TIMED_OUT;
1063         }
1064
1065         return result;
1066 }
1067
1068 int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
1069 {
1070         DBusMessage* msg;
1071         DBusError err;
1072         dbus_error_init(&err);
1073
1074         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_PCM);
1075
1076         if (NULL == msg) {
1077                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
1078                 return TTS_ERROR_OPERATION_FAILED;
1079         } else {
1080                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
1081         }
1082
1083         if (true != dbus_message_append_args(msg,
1084                 DBUS_TYPE_INT32, &uid,
1085                 DBUS_TYPE_INT32, &event,
1086                 DBUS_TYPE_INT32, &audio_type,
1087                 DBUS_TYPE_INT32, &rate,
1088                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1089                 &data, data_size,
1090                 DBUS_TYPE_INVALID)) {
1091                 dbus_message_unref(msg);
1092                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1093                 return TTS_ERROR_OPERATION_FAILED;
1094         }
1095
1096         DBusMessage* result_msg;
1097         int result = TTS_ERROR_OPERATION_FAILED;
1098
1099         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1100         dbus_message_unref(msg);
1101         if (dbus_error_is_set(&err)) {
1102                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1103                 dbus_error_free(&err);
1104         }
1105
1106         if (NULL != result_msg) {
1107                 dbus_message_get_args(result_msg, &err,
1108                         DBUS_TYPE_INT32, &result,
1109                         DBUS_TYPE_INVALID);
1110
1111                 if (dbus_error_is_set(&err)) {
1112                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : Get arguments error (%s)", err.message);
1113                         dbus_error_free(&err);
1114                         result = TTS_ERROR_OPERATION_FAILED;
1115                 }
1116                 dbus_message_unref(result_msg);
1117
1118                 if (0 == result) {
1119                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1120                 } else {
1121                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1122                 }
1123         } else {
1124                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1125                 tts_dbus_reconnect();
1126                 result = TTS_ERROR_TIMED_OUT;
1127         }
1128
1129         return result;
1130 }