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         } /* TTSD_METHOD_UTTERANCE_COMPLETED */
  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_METHOD_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_METHOD_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 #if 0
 179         int pid = getpid();
 180
 181         char service_name[64];
 182         memset(service_name, 0, 64);
 183         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 184
 185         SLOG(LOG_DEBUG, TAG_TTSC, "Service name is %s", service_name);
 186
 187         /* register our name on the bus, and check for errors */
 188         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
 189         if (dbus_error_is_set(&err)) {
 190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Name Error (%s)", err.message);
 191                 dbus_error_free(&err);
 192         }
 193 #endif
 194         char rule[128] = {0, };
 195         snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 196         SLOG(LOG_DEBUG, TAG_TTSC, "rule is %s", rule);
 197
 198         /* add a rule for which messages we want to see */
 199         dbus_bus_add_match(g_conn_listener, rule, &err);
 200         dbus_connection_flush(g_conn_listener);
 201
 202         int fd = 0;
 203         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 204                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
 205                 return TTS_ERROR_OPERATION_FAILED;
 206         } else {
 207                 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
 208         }
 209
 210         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
 211         if (NULL == g_dbus_fd_handler) {
 212                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
 213                 return TTS_ERROR_OPERATION_FAILED;
 214         }
 215
 216         return 0;
 217 }
 218
 219 int tts_dbus_close_connection()
 220 {
 221         DBusError err;
 222         dbus_error_init(&err);
 223
 224         if (NULL != g_dbus_fd_handler) {
 225                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 226                 g_dbus_fd_handler = NULL;
 227         }
 228 #if 0
 229         int pid = getpid();
 230
 231         char service_name[64];
 232         memset(service_name, 0, 64);
 233         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 234         snprintf(service_name, 64, "%s", TTS_CLIENT_SERVICE_NAME);
 235
 236         dbus_bus_release_name(g_conn_listener, service_name, &err);
 237         if (dbus_error_is_set(&err)) {
 238                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Release name error (%s)", err.message);
 239                 dbus_error_free(&err);
 240         }
 241 #endif
 242         g_conn_sender = NULL;
 243         g_conn_listener = NULL;
 244
 245         return 0;
 246 }
 247
 248 int tts_dbus_reconnect()
 249 {
 250         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 251         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 252         SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
 253                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 254
 255         if (false == sender_connected || false == listener_connected) {
 256                 tts_dbus_close_connection();
 257
 258                 if (0 != tts_dbus_open_connection()) {
 259                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 260                         return -1;
 261                 }
 262
 263                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 264         }
 265
 266         return 0;
 267 }
 268
 269 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 270 {
 271         if (NULL == method) {
 272                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
 273                 return NULL;
 274         }
 275
 276         tts_client_s* client = tts_client_get_by_uid(uid);
 277
 278         /* check handle */
 279         if (NULL == client) {
 280                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
 281                 return NULL;
 282         }
 283
 284         DBusMessage* msg;
 285
 286         if (TTS_MODE_DEFAULT == client->mode) {
 287                 msg = dbus_message_new_method_call(
 288                         TTS_SERVER_SERVICE_NAME,
 289                         TTS_SERVER_SERVICE_OBJECT_PATH,
 290                         TTS_SERVER_SERVICE_INTERFACE,
 291                         method);
 292         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 293                 msg = dbus_message_new_method_call(
 294                         TTS_NOTI_SERVER_SERVICE_NAME,
 295                         TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
 296                         TTS_NOTI_SERVER_SERVICE_INTERFACE,
 297                         method);
 298         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 299                 msg = dbus_message_new_method_call(
 300                         TTS_SR_SERVER_SERVICE_NAME,
 301                         TTS_SR_SERVER_SERVICE_OBJECT_PATH,
 302                         TTS_SR_SERVER_SERVICE_INTERFACE,
 303                         method);
 304         } else {
 305                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
 306                 return NULL;
 307         }
 308
 309         return msg;
 310 }
 311
 312 int tts_dbus_request_hello(int uid)
 313 {
 314         DBusError err;
 315         dbus_error_init(&err);
 316         DBusMessage* msg;
 317
 318         msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
 319
 320         if (dbus_error_is_set(&err)) {
 321                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 322                 dbus_error_free(&err);
 323         }
 324
 325         if (NULL == msg) {
 326                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
 327                 return TTS_ERROR_OPERATION_FAILED;
 328         }
 329
 330         DBusMessage* result_msg = NULL;
 331         int result = 0;
 332
 333         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
 334         dbus_message_unref(msg);
 335         if (dbus_error_is_set(&err)) {
 336                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 337                 dbus_error_free(&err);
 338         }
 339
 340         if (NULL != result_msg) {
 341                 dbus_message_unref(result_msg);
 342
 343                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 344                 result = 0;
 345         } else {
 346                 result = TTS_ERROR_TIMED_OUT;
 347         }
 348
 349         return result;
 350 }
 351
 352 int tts_dbus_request_initialize(int uid)
 353 {
 354         DBusMessage* msg;
 355         DBusError err;
 356         dbus_error_init(&err);
 357
 358         msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
 359
 360         if (NULL == msg) {
 361                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
 362                 return TTS_ERROR_OPERATION_FAILED;
 363         } else {
 364                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 365         }
 366
 367         int pid = getpid();
 368         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 369                 dbus_message_unref(msg);
 370                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 371
 372                 return TTS_ERROR_OPERATION_FAILED;
 373         }
 374
 375         DBusMessage* result_msg;
 376         int result = TTS_ERROR_OPERATION_FAILED;
 377
 378         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 379         dbus_message_unref(msg);
 380         if (dbus_error_is_set(&err)) {
 381                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 382                 dbus_error_free(&err);
 383         }
 384
 385         if (NULL != result_msg) {
 386                 dbus_message_get_args(result_msg, &err,
 387                                   DBUS_TYPE_INT32, &result,
 388                                   DBUS_TYPE_INVALID);
 389
 390                 if (dbus_error_is_set(&err)) {
 391                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 392                         dbus_error_free(&err);
 393                         result = TTS_ERROR_OPERATION_FAILED;
 394                 }
 395
 396                 dbus_message_unref(result_msg);
 397
 398                 if (0 == result) {
 399                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 400                 } else {
 401                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 402                 }
 403         } else {
 404                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 405                 tts_dbus_reconnect();
 406                 result = TTS_ERROR_TIMED_OUT;
 407         }
 408
 409         return result;
 410 }
 411
 412
 413 int tts_dbus_request_finalize(int uid)
 414 {
 415         DBusMessage* msg;
 416         DBusError err;
 417         dbus_error_init(&err);
 418
 419         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 420
 421         if (NULL == msg) {
 422                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 423                 return TTS_ERROR_OPERATION_FAILED;
 424         } else {
 425                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 426         }
 427
 428         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 429                 dbus_message_unref(msg);
 430                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 431
 432                 return TTS_ERROR_OPERATION_FAILED;
 433         }
 434
 435         DBusMessage* result_msg;
 436         int result = TTS_ERROR_OPERATION_FAILED;
 437
 438         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 439         dbus_message_unref(msg);
 440         if (dbus_error_is_set(&err)) {
 441                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 442                 dbus_error_free(&err);
 443         }
 444
 445         if (NULL != result_msg) {
 446                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 447
 448                 if (dbus_error_is_set(&err)) {
 449                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 450                         dbus_error_free(&err);
 451                         result = TTS_ERROR_OPERATION_FAILED;
 452                 }
 453
 454                 dbus_message_unref(result_msg);
 455
 456                 if (0 == result) {
 457                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 458                 } else {
 459                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 460                 }
 461         } else {
 462                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 463                 tts_dbus_reconnect();
 464                 result = TTS_ERROR_TIMED_OUT;
 465         }
 466
 467         return result;
 468 }
 469
 470 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid)
 471 {
 472         if (NULL == text || NULL == lang) {
 473                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 474                 return TTS_ERROR_INVALID_PARAMETER;
 475         }
 476
 477         DBusMessage* msg;
 478         DBusError err;
 479         dbus_error_init(&err);
 480
 481         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 482
 483         if (NULL == msg) {
 484                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 485                 return TTS_ERROR_OPERATION_FAILED;
 486         } else {
 487                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d)",
 488                          uid, text, lang, vctype, speed, uttid);
 489         }
 490
 491         if (true != dbus_message_append_args(msg,
 492                 DBUS_TYPE_INT32, &uid,
 493                 DBUS_TYPE_STRING, &text,
 494                 DBUS_TYPE_STRING, &lang,
 495                 DBUS_TYPE_INT32, &vctype,
 496                 DBUS_TYPE_INT32, &speed,
 497                 DBUS_TYPE_INT32, &uttid,
 498                 DBUS_TYPE_INVALID)) {
 499                 dbus_message_unref(msg);
 500                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 501
 502                 return TTS_ERROR_OPERATION_FAILED;
 503         }
 504
 505         DBusMessage* result_msg;
 506         int result = TTS_ERROR_OPERATION_FAILED;
 507
 508         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 509         dbus_message_unref(msg);
 510         if (dbus_error_is_set(&err)) {
 511                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 512                 dbus_error_free(&err);
 513         }
 514
 515         if (NULL != result_msg) {
 516                 dbus_message_get_args(result_msg, &err,
 517                         DBUS_TYPE_INT32, &result,
 518                         DBUS_TYPE_INVALID);
 519
 520                 if (dbus_error_is_set(&err)) {
 521                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 522                         dbus_error_free(&err);
 523                         result = TTS_ERROR_OPERATION_FAILED;
 524                 }
 525                 dbus_message_unref(result_msg);
 526
 527                 if (0 == result) {
 528                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 529                 } else {
 530                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 531                 }
 532         } else {
 533                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 534                 tts_dbus_reconnect();
 535                 result = TTS_ERROR_TIMED_OUT;
 536         }
 537
 538         return result;
 539 }
 540
 541 int tts_dbus_request_play(int uid)
 542 {
 543         DBusMessage* msg;
 544         DBusError err;
 545         dbus_error_init(&err);
 546
 547         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 548
 549         if (NULL == msg) {
 550                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 551                 return TTS_ERROR_OPERATION_FAILED;
 552         } else {
 553                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 554         }
 555
 556         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 557                 dbus_message_unref(msg);
 558                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 559
 560                 return TTS_ERROR_OPERATION_FAILED;
 561         }
 562
 563         DBusMessage* result_msg;
 564         int result = TTS_ERROR_OPERATION_FAILED;
 565
 566         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 567         dbus_message_unref(msg);
 568         if (dbus_error_is_set(&err)) {
 569                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 570                 dbus_error_free(&err);
 571         }
 572
 573         if (NULL != result_msg) {
 574                 dbus_message_get_args(result_msg, &err,
 575                         DBUS_TYPE_INT32, &result,
 576                         DBUS_TYPE_INVALID);
 577
 578                 if (dbus_error_is_set(&err)) {
 579                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 580                         dbus_error_free(&err);
 581                         result = TTS_ERROR_OPERATION_FAILED;
 582                 }
 583                 dbus_message_unref(result_msg);
 584
 585                 if (0 == result) {
 586                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 587                 } else {
 588                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 589                 }
 590         } else {
 591                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 592                 tts_dbus_reconnect();
 593                 result = TTS_ERROR_TIMED_OUT;
 594         }
 595
 596         return result;
 597 }
 598
 599 int tts_dbus_request_stop(int uid)
 600 {
 601         DBusMessage* msg;
 602         DBusError err;
 603         dbus_error_init(&err);
 604
 605         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 606
 607         if (NULL == msg) {
 608                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 609                 return TTS_ERROR_OPERATION_FAILED;
 610         } else {
 611                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 612         }
 613
 614         DBusMessage* result_msg;
 615         int result = TTS_ERROR_OPERATION_FAILED;
 616
 617         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 618                 dbus_message_unref(msg);
 619                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 620
 621                 return TTS_ERROR_OPERATION_FAILED;
 622         }
 623
 624         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 625         dbus_message_unref(msg);
 626         if (dbus_error_is_set(&err)) {
 627                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 628                 dbus_error_free(&err);
 629         }
 630
 631         if (NULL != result_msg) {
 632                 dbus_message_get_args(result_msg, &err,
 633                         DBUS_TYPE_INT32, &result,
 634                         DBUS_TYPE_INVALID);
 635
 636                 if (dbus_error_is_set(&err)) {
 637                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 638                         dbus_error_free(&err);
 639                         result = TTS_ERROR_OPERATION_FAILED;
 640                 }
 641                 dbus_message_unref(result_msg);
 642
 643                 if (0 == result) {
 644                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 645                 } else {
 646                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 647                 }
 648         } else {
 649                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 650                 tts_dbus_reconnect();
 651                 result = TTS_ERROR_TIMED_OUT;
 652         }
 653
 654         return result;
 655 }
 656
 657 int tts_dbus_request_pause(int uid)
 658 {
 659         DBusMessage* msg;
 660         DBusError err;
 661         dbus_error_init(&err);
 662
 663         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 664
 665         if (NULL == msg) {
 666                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 667                 return TTS_ERROR_OPERATION_FAILED;
 668         } else {
 669                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 670         }
 671
 672         DBusMessage* result_msg;
 673         int result = TTS_ERROR_OPERATION_FAILED;
 674
 675         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 676                 dbus_message_unref(msg);
 677                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 678
 679                 return TTS_ERROR_OPERATION_FAILED;
 680         }
 681
 682         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 683         dbus_message_unref(msg);
 684         if (dbus_error_is_set(&err)) {
 685                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 686                 dbus_error_free(&err);
 687         }
 688
 689         if (NULL != result_msg) {
 690                 dbus_message_get_args(result_msg, &err,
 691                         DBUS_TYPE_INT32, &result,
 692                         DBUS_TYPE_INVALID);
 693
 694                 if (dbus_error_is_set(&err)) {
 695                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 696                         dbus_error_free(&err);
 697                         result = TTS_ERROR_OPERATION_FAILED;
 698                 }
 699                 dbus_message_unref(result_msg);
 700
 701                 if (0 == result) {
 702                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 703                 } else {
 704                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 705                 }
 706         } else {
 707                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 708                 tts_dbus_reconnect();
 709                 result = TTS_ERROR_TIMED_OUT;
 710         }
 711
 712         return result;
 713 }