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