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