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