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