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_set_private_data(int uid, const char* key, const char* data)
 520 {
 521         if (NULL == key || NULL == data) {
 522                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 523                 return TTS_ERROR_INVALID_PARAMETER;
 524         }
 525
 526         DBusMessage* msg;
 527         DBusError err;
 528         dbus_error_init(&err);
 529
 530         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 531
 532         if (NULL == msg) {
 533                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 534                 return TTS_ERROR_OPERATION_FAILED;
 535         } else {
 536                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 537         }
 538
 539         if (true != dbus_message_append_args(msg,
 540                 DBUS_TYPE_INT32, &uid,
 541                 DBUS_TYPE_STRING, &key,
 542                 DBUS_TYPE_STRING, &data,
 543                 DBUS_TYPE_INVALID)) {
 544                 dbus_message_unref(msg);
 545                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 546
 547                 return TTS_ERROR_OPERATION_FAILED;
 548         }
 549
 550         DBusMessage* result_msg;
 551         int result = TTS_ERROR_OPERATION_FAILED;
 552
 553         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 554         dbus_message_unref(msg);
 555         if (dbus_error_is_set(&err)) {
 556                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 557                 dbus_error_free(&err);
 558         }
 559
 560         if (NULL != result_msg) {
 561                 dbus_message_get_args(result_msg, &err,
 562                         DBUS_TYPE_INT32, &result,
 563                         DBUS_TYPE_INVALID);
 564
 565                 if (dbus_error_is_set(&err)) {
 566                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 567                         dbus_error_free(&err);
 568                         result = TTS_ERROR_OPERATION_FAILED;
 569                 }
 570                 dbus_message_unref(result_msg);
 571
 572                 if (0 == result) {
 573                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 574                 } else {
 575                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 576                 }
 577         } else {
 578                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 579                 tts_dbus_reconnect();
 580                 result = TTS_ERROR_TIMED_OUT;
 581         }
 582
 583         return result;
 584 }
 585
 586 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 587 {
 588         if (NULL == key || NULL == data) {
 589                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 590                 return TTS_ERROR_INVALID_PARAMETER;
 591         }
 592
 593         DBusMessage* msg;
 594         DBusError err;
 595         dbus_error_init(&err);
 596
 597         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 598
 599         if (NULL == msg) {
 600                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 601                 return TTS_ERROR_OPERATION_FAILED;
 602         } else {
 603                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 604         }
 605
 606         if (true != dbus_message_append_args(msg,
 607                 DBUS_TYPE_INT32, &uid,
 608                 DBUS_TYPE_STRING, &key,
 609                 DBUS_TYPE_INVALID)) {
 610                 dbus_message_unref(msg);
 611                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 612
 613                 return TTS_ERROR_OPERATION_FAILED;
 614         }
 615
 616         DBusMessage* result_msg;
 617         int result = TTS_ERROR_OPERATION_FAILED;
 618
 619         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 620         dbus_message_unref(msg);
 621         if (dbus_error_is_set(&err)) {
 622                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 623                 dbus_error_free(&err);
 624         }
 625
 626         char* temp = NULL;
 627         if (NULL != result_msg) {
 628                 dbus_message_get_args(result_msg, &err,
 629                         DBUS_TYPE_INT32, &result,
 630                         DBUS_TYPE_STRING, &temp,
 631                         DBUS_TYPE_INVALID);
 632
 633                 if (dbus_error_is_set(&err)) {
 634                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 635                         dbus_error_free(&err);
 636                         result = TTS_ERROR_OPERATION_FAILED;
 637                 }
 638                 dbus_message_unref(result_msg);
 639
 640                 if (0 == result) {
 641                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 642                         if (NULL != temp) {
 643                                 *data = strdup(temp);
 644                                 free(temp);
 645                                 temp = NULL;
 646                         }
 647                 } else {
 648                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 649                 }
 650         } else {
 651                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 652                 tts_dbus_reconnect();
 653                 result = TTS_ERROR_TIMED_OUT;
 654         }
 655
 656         return result;
 657 }
 658
 659 int tts_dbus_request_play(int uid)
 660 {
 661         DBusMessage* msg;
 662         DBusError err;
 663         dbus_error_init(&err);
 664
 665         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 666
 667         if (NULL == msg) {
 668                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 669                 return TTS_ERROR_OPERATION_FAILED;
 670         } else {
 671                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 672         }
 673
 674         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 675                 dbus_message_unref(msg);
 676                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 677
 678                 return TTS_ERROR_OPERATION_FAILED;
 679         }
 680
 681         DBusMessage* result_msg;
 682         int result = TTS_ERROR_OPERATION_FAILED;
 683
 684         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 685         dbus_message_unref(msg);
 686         if (dbus_error_is_set(&err)) {
 687                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 688                 dbus_error_free(&err);
 689         }
 690
 691         if (NULL != result_msg) {
 692                 dbus_message_get_args(result_msg, &err,
 693                         DBUS_TYPE_INT32, &result,
 694                         DBUS_TYPE_INVALID);
 695
 696                 if (dbus_error_is_set(&err)) {
 697                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 698                         dbus_error_free(&err);
 699                         result = TTS_ERROR_OPERATION_FAILED;
 700                 }
 701                 dbus_message_unref(result_msg);
 702
 703                 if (0 == result) {
 704                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 705                 } else {
 706                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 707                 }
 708         } else {
 709                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 710                 tts_dbus_reconnect();
 711                 result = TTS_ERROR_TIMED_OUT;
 712         }
 713
 714         return result;
 715 }
 716
 717 int tts_dbus_request_stop(int uid)
 718 {
 719         DBusMessage* msg;
 720         DBusError err;
 721         dbus_error_init(&err);
 722
 723         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 724
 725         if (NULL == msg) {
 726                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 727                 return TTS_ERROR_OPERATION_FAILED;
 728         } else {
 729                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 730         }
 731
 732         DBusMessage* result_msg;
 733         int result = TTS_ERROR_OPERATION_FAILED;
 734
 735         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 736                 dbus_message_unref(msg);
 737                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 738
 739                 return TTS_ERROR_OPERATION_FAILED;
 740         }
 741
 742         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 743         dbus_message_unref(msg);
 744         if (dbus_error_is_set(&err)) {
 745                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 746                 dbus_error_free(&err);
 747         }
 748
 749         if (NULL != result_msg) {
 750                 dbus_message_get_args(result_msg, &err,
 751                         DBUS_TYPE_INT32, &result,
 752                         DBUS_TYPE_INVALID);
 753
 754                 if (dbus_error_is_set(&err)) {
 755                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 756                         dbus_error_free(&err);
 757                         result = TTS_ERROR_OPERATION_FAILED;
 758                 }
 759                 dbus_message_unref(result_msg);
 760
 761                 if (0 == result) {
 762                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 763                 } else {
 764                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 765                 }
 766         } else {
 767                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 768                 tts_dbus_reconnect();
 769                 result = TTS_ERROR_TIMED_OUT;
 770         }
 771
 772         return result;
 773 }
 774
 775 int tts_dbus_request_pause(int uid)
 776 {
 777         DBusMessage* msg;
 778         DBusError err;
 779         dbus_error_init(&err);
 780
 781         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 782
 783         if (NULL == msg) {
 784                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 785                 return TTS_ERROR_OPERATION_FAILED;
 786         } else {
 787                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 788         }
 789
 790         DBusMessage* result_msg;
 791         int result = TTS_ERROR_OPERATION_FAILED;
 792
 793         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 794                 dbus_message_unref(msg);
 795                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 796
 797                 return TTS_ERROR_OPERATION_FAILED;
 798         }
 799
 800         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 801         dbus_message_unref(msg);
 802         if (dbus_error_is_set(&err)) {
 803                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 804                 dbus_error_free(&err);
 805         }
 806
 807         if (NULL != result_msg) {
 808                 dbus_message_get_args(result_msg, &err,
 809                         DBUS_TYPE_INT32, &result,
 810                         DBUS_TYPE_INVALID);
 811
 812                 if (dbus_error_is_set(&err)) {
 813                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 814                         dbus_error_free(&err);
 815                         result = TTS_ERROR_OPERATION_FAILED;
 816                 }
 817                 dbus_message_unref(result_msg);
 818
 819                 if (0 == result) {
 820                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 821                 } else {
 822                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 823                 }
 824         } else {
 825                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 826                 tts_dbus_reconnect();
 827                 result = TTS_ERROR_TIMED_OUT;
 828         }
 829
 830         return result;
 831 }