client/tts_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2014 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);
  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         DBusMessage* msg = NULL;
  51         msg = dbus_connection_pop_message(g_conn_listener);
  52
  53         if (true != dbus_connection_get_is_connected(g_conn_listener)) {
  54                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Connection is disconnected");
  55                 return ECORE_CALLBACK_RENEW;
  56         }
  57
  58         /* loop again if we haven't read a message */
  59         if (NULL == msg) {
  60                 return ECORE_CALLBACK_RENEW;
  61         }
  62
  63         DBusError err;
  64         dbus_error_init(&err);
  65
  66         char if_name[64] = {0, };
  67         snprintf(if_name, 64, "%s", TTS_CLIENT_SERVICE_INTERFACE);
  68
  69         if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) {
  70                 int uid = 0;
  71                 int uttid = 0;
  72
  73                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
  74                 if (dbus_error_is_set(&err)) {
  75                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
  76                         dbus_error_free(&err);
  77                 }
  78
  79                 if (0 == __tts_cb_utt_started(uid, uttid)) {
  80                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance started : uid(%d) uttid(%d)", uid, uttid);
  81                 }
  82         } /* TTSD_METHOD_UTTERANCE_STARTED */
  83
  84         else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) {
  85                 int uid = 0;
  86                 int uttid = 0;
  87
  88                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &uttid, DBUS_TYPE_INVALID);
  89                 if (dbus_error_is_set(&err)) {
  90                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
  91                         dbus_error_free(&err);
  92                 }
  93
  94                 if (0 == __tts_cb_utt_completed(uid, uttid)) {
  95                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts utterance completed : uid(%d) uttid(%d)", uid, uttid);
  96                 }
  97         } /* TTS_SIGNAL_UTTERANCE_STARTED */
  98
  99         else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_SET_STATE)) {
 100                 int uid = 0;
 101                 int state = 0;
 102
 103                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INT32, &state, DBUS_TYPE_INVALID);
 104                 if (dbus_error_is_set(&err)) {
 105                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Get arguments error (%s)", err.message);
 106                         dbus_error_free(&err);
 107                 }
 108
 109                 if (0 == __tts_cb_set_state(uid, state)) {
 110                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts state changed : uid(%d) state(%d)", uid, state);
 111                 }
 112         } /* TTSD_SIGNAL_SET_STATE */
 113
 114         else if (dbus_message_is_signal(msg, if_name, TTSD_METHOD_ERROR)) {
 115                 int uid;
 116                 int uttid;
 117                 int reason;
 118
 119                 dbus_message_get_args(msg, &err,
 120                         DBUS_TYPE_INT32, &uid,
 121                         DBUS_TYPE_INT32, &uttid,
 122                         DBUS_TYPE_INT32, &reason,
 123                         DBUS_TYPE_INVALID);
 124
 125                 if (dbus_error_is_set(&err)) {
 126                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message - Get arguments error (%s)", err.message);
 127                         dbus_error_free(&err);
 128                 }
 129
 130                 if (0 == __tts_cb_error(uid, reason, uttid)) {
 131                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error message : uid(%d), error(%d), uttid(%d)", uid, reason, uttid);
 132                 }
 133         } /* TTSD_SIGNAL_ERROR */
 134
 135         /* free the message */
 136         dbus_message_unref(msg);
 137
 138         return ECORE_CALLBACK_PASS_ON;
 139 }
 140
 141 int tts_dbus_open_connection()
 142 {
 143         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 144                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 145                 return 0;
 146         }
 147
 148         DBusError err;
 149
 150         /* initialise the error value */
 151         dbus_error_init(&err);
 152
 153         /* connect to the DBUS system bus, and check for errors */
 154         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 155         if (dbus_error_is_set(&err)) {
 156                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 157                 dbus_error_free(&err);
 158         }
 159
 160         if (NULL == g_conn_sender) {
 161                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection");
 162                 return TTS_ERROR_OPERATION_FAILED;
 163         }
 164
 165         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 166
 167         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 168         if (dbus_error_is_set(&err)) {
 169                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 170                 dbus_error_free(&err);
 171         }
 172
 173         if (NULL == g_conn_listener) {
 174                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection for listener");
 175                 return TTS_ERROR_OPERATION_FAILED;
 176         }
 177
 178         char rule[128] = {0, };
 179         snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 180
 181         /* add a rule for which messages we want to see */
 182         dbus_bus_add_match(g_conn_listener, rule, &err);
 183         dbus_connection_flush(g_conn_listener);
 184
 185         int fd = 0;
 186         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 187                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
 188                 return TTS_ERROR_OPERATION_FAILED;
 189         } else {
 190                 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
 191         }
 192
 193         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
 194         if (NULL == g_dbus_fd_handler) {
 195                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
 196                 return TTS_ERROR_OPERATION_FAILED;
 197         }
 198
 199         return 0;
 200 }
 201
 202 int tts_dbus_close_connection()
 203 {
 204         DBusError err;
 205         dbus_error_init(&err);
 206
 207         if (NULL != g_dbus_fd_handler) {
 208                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 209                 g_dbus_fd_handler = NULL;
 210         }
 211
 212         dbus_connection_close(g_conn_sender);
 213         dbus_connection_close(g_conn_listener);
 214
 215         dbus_connection_unref(g_conn_sender);
 216         dbus_connection_unref(g_conn_listener);
 217
 218         g_conn_sender = NULL;
 219         g_conn_listener = NULL;
 220
 221         return 0;
 222 }
 223
 224 int tts_dbus_reconnect()
 225 {
 226         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 227         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 228         SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
 229                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 230
 231         if (false == sender_connected || false == listener_connected) {
 232                 tts_dbus_close_connection();
 233
 234                 if (0 != tts_dbus_open_connection()) {
 235                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 236                         return -1;
 237                 }
 238
 239                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 240         }
 241
 242         return 0;
 243 }
 244
 245 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 246 {
 247         if (NULL == method) {
 248                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
 249                 return NULL;
 250         }
 251
 252         tts_client_s* client = tts_client_get_by_uid(uid);
 253
 254         /* check handle */
 255         if (NULL == client) {
 256                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
 257                 return NULL;
 258         }
 259
 260         DBusMessage* msg;
 261
 262         if (TTS_MODE_DEFAULT == client->mode) {
 263                 msg = dbus_message_new_method_call(
 264                         TTS_SERVER_SERVICE_NAME,
 265                         TTS_SERVER_SERVICE_OBJECT_PATH,
 266                         TTS_SERVER_SERVICE_INTERFACE,
 267                         method);
 268         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 269                 msg = dbus_message_new_method_call(
 270                         TTS_NOTI_SERVER_SERVICE_NAME,
 271                         TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
 272                         TTS_NOTI_SERVER_SERVICE_INTERFACE,
 273                         method);
 274         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 275                 msg = dbus_message_new_method_call(
 276                         TTS_SR_SERVER_SERVICE_NAME,
 277                         TTS_SR_SERVER_SERVICE_OBJECT_PATH,
 278                         TTS_SR_SERVER_SERVICE_INTERFACE,
 279                         method);
 280         } else {
 281                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
 282                 return NULL;
 283         }
 284
 285         return msg;
 286 }
 287
 288 int tts_dbus_request_hello(int uid)
 289 {
 290         DBusError err;
 291         dbus_error_init(&err);
 292         DBusMessage* msg;
 293
 294         msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
 295
 296         if (dbus_error_is_set(&err)) {
 297                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 298                 dbus_error_free(&err);
 299         }
 300
 301         if (NULL == msg) {
 302                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
 303                 return TTS_ERROR_OPERATION_FAILED;
 304         }
 305
 306         DBusMessage* result_msg = NULL;
 307         int result = 0;
 308
 309         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
 310         dbus_message_unref(msg);
 311         if (dbus_error_is_set(&err)) {
 312                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 313                 dbus_error_free(&err);
 314         }
 315
 316         if (NULL != result_msg) {
 317                 dbus_message_unref(result_msg);
 318
 319                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 320                 result = 0;
 321         } else {
 322                 result = TTS_ERROR_TIMED_OUT;
 323         }
 324
 325         return result;
 326 }
 327
 328 int tts_dbus_request_initialize(int uid)
 329 {
 330         DBusMessage* msg;
 331         DBusError err;
 332         dbus_error_init(&err);
 333
 334         msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
 335
 336         if (NULL == msg) {
 337                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
 338                 return TTS_ERROR_OPERATION_FAILED;
 339         } else {
 340                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 341         }
 342
 343         int pid = getpid();
 344         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 345                 dbus_message_unref(msg);
 346                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 347
 348                 return TTS_ERROR_OPERATION_FAILED;
 349         }
 350
 351         DBusMessage* result_msg;
 352         int result = TTS_ERROR_OPERATION_FAILED;
 353
 354         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 355         dbus_message_unref(msg);
 356         if (dbus_error_is_set(&err)) {
 357                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 358                 dbus_error_free(&err);
 359         }
 360
 361         if (NULL != result_msg) {
 362                 dbus_message_get_args(result_msg, &err,
 363                                   DBUS_TYPE_INT32, &result,
 364                                   DBUS_TYPE_INVALID);
 365
 366                 if (dbus_error_is_set(&err)) {
 367                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 368                         dbus_error_free(&err);
 369                         result = TTS_ERROR_OPERATION_FAILED;
 370                 }
 371
 372                 dbus_message_unref(result_msg);
 373
 374                 if (0 == result) {
 375                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 376                 } else {
 377                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 378                 }
 379         } else {
 380                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 381                 tts_dbus_reconnect();
 382                 result = TTS_ERROR_TIMED_OUT;
 383         }
 384
 385         return result;
 386 }
 387
 388
 389 int tts_dbus_request_finalize(int uid)
 390 {
 391         DBusMessage* msg;
 392         DBusError err;
 393         dbus_error_init(&err);
 394
 395         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 396
 397         if (NULL == msg) {
 398                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 399                 return TTS_ERROR_OPERATION_FAILED;
 400         } else {
 401                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 402         }
 403
 404         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 405                 dbus_message_unref(msg);
 406                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 407
 408                 return TTS_ERROR_OPERATION_FAILED;
 409         }
 410
 411         DBusMessage* result_msg;
 412         int result = TTS_ERROR_OPERATION_FAILED;
 413
 414         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 415         dbus_message_unref(msg);
 416         if (dbus_error_is_set(&err)) {
 417                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 418                 dbus_error_free(&err);
 419         }
 420
 421         if (NULL != result_msg) {
 422                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 423
 424                 if (dbus_error_is_set(&err)) {
 425                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 426                         dbus_error_free(&err);
 427                         result = TTS_ERROR_OPERATION_FAILED;
 428                 }
 429
 430                 dbus_message_unref(result_msg);
 431
 432                 if (0 == result) {
 433                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 434                 } else {
 435                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 436                 }
 437         } else {
 438                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 439                 tts_dbus_reconnect();
 440                 result = TTS_ERROR_TIMED_OUT;
 441         }
 442
 443         return result;
 444 }
 445
 446 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid)
 447 {
 448         if (NULL == text || NULL == lang) {
 449                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 450                 return TTS_ERROR_INVALID_PARAMETER;
 451         }
 452
 453         DBusMessage* msg;
 454         DBusError err;
 455         dbus_error_init(&err);
 456
 457         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 458
 459         if (NULL == msg) {
 460                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 461                 return TTS_ERROR_OPERATION_FAILED;
 462         } else {
 463                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d)",
 464                          uid, text, lang, vctype, speed, uttid);
 465         }
 466
 467         if (true != dbus_message_append_args(msg,
 468                 DBUS_TYPE_INT32, &uid,
 469                 DBUS_TYPE_STRING, &text,
 470                 DBUS_TYPE_STRING, &lang,
 471                 DBUS_TYPE_INT32, &vctype,
 472                 DBUS_TYPE_INT32, &speed,
 473                 DBUS_TYPE_INT32, &uttid,
 474                 DBUS_TYPE_INVALID)) {
 475                 dbus_message_unref(msg);
 476                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 477
 478                 return TTS_ERROR_OPERATION_FAILED;
 479         }
 480
 481         DBusMessage* result_msg;
 482         int result = TTS_ERROR_OPERATION_FAILED;
 483
 484         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 485         dbus_message_unref(msg);
 486         if (dbus_error_is_set(&err)) {
 487                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 488                 dbus_error_free(&err);
 489         }
 490
 491         if (NULL != result_msg) {
 492                 dbus_message_get_args(result_msg, &err,
 493                         DBUS_TYPE_INT32, &result,
 494                         DBUS_TYPE_INVALID);
 495
 496                 if (dbus_error_is_set(&err)) {
 497                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 498                         dbus_error_free(&err);
 499                         result = TTS_ERROR_OPERATION_FAILED;
 500                 }
 501                 dbus_message_unref(result_msg);
 502
 503                 if (0 == result) {
 504                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 505                 } else {
 506                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 507                 }
 508         } else {
 509                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 510                 tts_dbus_reconnect();
 511                 result = TTS_ERROR_TIMED_OUT;
 512         }
 513
 514         return result;
 515 }
 516
 517 int tts_dbus_request_play(int uid)
 518 {
 519         DBusMessage* msg;
 520         DBusError err;
 521         dbus_error_init(&err);
 522
 523         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 524
 525         if (NULL == msg) {
 526                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 527                 return TTS_ERROR_OPERATION_FAILED;
 528         } else {
 529                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 530         }
 531
 532         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 533                 dbus_message_unref(msg);
 534                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 535
 536                 return TTS_ERROR_OPERATION_FAILED;
 537         }
 538
 539         DBusMessage* result_msg;
 540         int result = TTS_ERROR_OPERATION_FAILED;
 541
 542         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 543         dbus_message_unref(msg);
 544         if (dbus_error_is_set(&err)) {
 545                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 546                 dbus_error_free(&err);
 547         }
 548
 549         if (NULL != result_msg) {
 550                 dbus_message_get_args(result_msg, &err,
 551                         DBUS_TYPE_INT32, &result,
 552                         DBUS_TYPE_INVALID);
 553
 554                 if (dbus_error_is_set(&err)) {
 555                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 556                         dbus_error_free(&err);
 557                         result = TTS_ERROR_OPERATION_FAILED;
 558                 }
 559                 dbus_message_unref(result_msg);
 560
 561                 if (0 == result) {
 562                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 563                 } else {
 564                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 565                 }
 566         } else {
 567                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 568                 tts_dbus_reconnect();
 569                 result = TTS_ERROR_TIMED_OUT;
 570         }
 571
 572         return result;
 573 }
 574
 575 int tts_dbus_request_stop(int uid)
 576 {
 577         DBusMessage* msg;
 578         DBusError err;
 579         dbus_error_init(&err);
 580
 581         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 582
 583         if (NULL == msg) {
 584                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 585                 return TTS_ERROR_OPERATION_FAILED;
 586         } else {
 587                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 588         }
 589
 590         DBusMessage* result_msg;
 591         int result = TTS_ERROR_OPERATION_FAILED;
 592
 593         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 594                 dbus_message_unref(msg);
 595                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 596
 597                 return TTS_ERROR_OPERATION_FAILED;
 598         }
 599
 600         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 601         dbus_message_unref(msg);
 602         if (dbus_error_is_set(&err)) {
 603                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 604                 dbus_error_free(&err);
 605         }
 606
 607         if (NULL != result_msg) {
 608                 dbus_message_get_args(result_msg, &err,
 609                         DBUS_TYPE_INT32, &result,
 610                         DBUS_TYPE_INVALID);
 611
 612                 if (dbus_error_is_set(&err)) {
 613                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 614                         dbus_error_free(&err);
 615                         result = TTS_ERROR_OPERATION_FAILED;
 616                 }
 617                 dbus_message_unref(result_msg);
 618
 619                 if (0 == result) {
 620                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 621                 } else {
 622                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 623                 }
 624         } else {
 625                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 626                 tts_dbus_reconnect();
 627                 result = TTS_ERROR_TIMED_OUT;
 628         }
 629
 630         return result;
 631 }
 632
 633 int tts_dbus_request_pause(int uid)
 634 {
 635         DBusMessage* msg;
 636         DBusError err;
 637         dbus_error_init(&err);
 638
 639         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 640
 641         if (NULL == msg) {
 642                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 643                 return TTS_ERROR_OPERATION_FAILED;
 644         } else {
 645                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 646         }
 647
 648         DBusMessage* result_msg;
 649         int result = TTS_ERROR_OPERATION_FAILED;
 650
 651         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 652                 dbus_message_unref(msg);
 653                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 654
 655                 return TTS_ERROR_OPERATION_FAILED;
 656         }
 657
 658         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 659         dbus_message_unref(msg);
 660         if (dbus_error_is_set(&err)) {
 661                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 662                 dbus_error_free(&err);
 663         }
 664
 665         if (NULL != result_msg) {
 666                 dbus_message_get_args(result_msg, &err,
 667                         DBUS_TYPE_INT32, &result,
 668                         DBUS_TYPE_INVALID);
 669
 670                 if (dbus_error_is_set(&err)) {
 671                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 672                         dbus_error_free(&err);
 673                         result = TTS_ERROR_OPERATION_FAILED;
 674                 }
 675                 dbus_message_unref(result_msg);
 676
 677                 if (0 == result) {
 678                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 679                 } else {
 680                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 681                 }
 682         } else {
 683                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 684                 tts_dbus_reconnect();
 685                 result = TTS_ERROR_TIMED_OUT;
 686         }
 687
 688         return result;
 689 }