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, bool* credential_needed)
 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         int temp = 0;
 364         if (NULL != result_msg) {
 365                 dbus_message_get_args(result_msg, &err,
 366                                   DBUS_TYPE_INT32, &result,
 367                                   DBUS_TYPE_INT32, &temp,
 368                                   DBUS_TYPE_INVALID);
 369
 370                 if (dbus_error_is_set(&err)) {
 371                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 372                         dbus_error_free(&err);
 373                         result = TTS_ERROR_OPERATION_FAILED;
 374                 }
 375
 376                 dbus_message_unref(result_msg);
 377
 378                 if (0 == result) {
 379                         *credential_needed = (bool)temp;
 380                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d, credential_needed(%d)", result, *credential_needed);
 381                 } else {
 382                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 383                 }
 384         } else {
 385                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 386                 tts_dbus_reconnect();
 387                 result = TTS_ERROR_TIMED_OUT;
 388         }
 389
 390         return result;
 391 }
 392
 393
 394 int tts_dbus_request_finalize(int uid)
 395 {
 396         DBusMessage* msg;
 397         DBusError err;
 398         dbus_error_init(&err);
 399
 400         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 401
 402         if (NULL == msg) {
 403                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 404                 return TTS_ERROR_OPERATION_FAILED;
 405         } else {
 406                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 407         }
 408
 409         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 410                 dbus_message_unref(msg);
 411                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 412
 413                 return TTS_ERROR_OPERATION_FAILED;
 414         }
 415
 416         DBusMessage* result_msg;
 417         int result = TTS_ERROR_OPERATION_FAILED;
 418
 419         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 420         dbus_message_unref(msg);
 421         if (dbus_error_is_set(&err)) {
 422                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 423                 dbus_error_free(&err);
 424         }
 425
 426         if (NULL != result_msg) {
 427                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 428
 429                 if (dbus_error_is_set(&err)) {
 430                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 431                         dbus_error_free(&err);
 432                         result = TTS_ERROR_OPERATION_FAILED;
 433                 }
 434
 435                 dbus_message_unref(result_msg);
 436
 437                 if (0 == result) {
 438                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 439                 } else {
 440                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 441                 }
 442         } else {
 443                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 444                 tts_dbus_reconnect();
 445                 result = TTS_ERROR_TIMED_OUT;
 446         }
 447
 448         return result;
 449 }
 450
 451 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 452 {
 453         if (NULL == text || NULL == lang) {
 454                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 455                 return TTS_ERROR_INVALID_PARAMETER;
 456         }
 457
 458         DBusMessage* msg;
 459         DBusError err;
 460         dbus_error_init(&err);
 461
 462         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 463
 464         if (NULL == msg) {
 465                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 466                 return TTS_ERROR_OPERATION_FAILED;
 467         } else {
 468                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
 469                          uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
 470         }
 471
 472         char *temp = NULL;
 473         if (NULL == credential) {
 474                 temp = strdup("NULL");
 475         } else {
 476                 temp = strdup(credential);
 477         }
 478
 479         if (true != dbus_message_append_args(msg,
 480                 DBUS_TYPE_INT32, &uid,
 481                 DBUS_TYPE_STRING, &text,
 482                 DBUS_TYPE_STRING, &lang,
 483                 DBUS_TYPE_INT32, &vctype,
 484                 DBUS_TYPE_INT32, &speed,
 485                 DBUS_TYPE_INT32, &uttid,
 486                 DBUS_TYPE_STRING, &temp,
 487                 DBUS_TYPE_INVALID)) {
 488                 dbus_message_unref(msg);
 489                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 490
 491                 if (NULL != temp) {
 492                         free(temp);
 493                         temp = NULL;
 494                 }
 495                 return TTS_ERROR_OPERATION_FAILED;
 496         }
 497
 498         DBusMessage* result_msg;
 499         int result = TTS_ERROR_OPERATION_FAILED;
 500
 501         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 502         dbus_message_unref(msg);
 503         if (dbus_error_is_set(&err)) {
 504                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 505                 dbus_error_free(&err);
 506         }
 507
 508         if (NULL != result_msg) {
 509                 dbus_message_get_args(result_msg, &err,
 510                         DBUS_TYPE_INT32, &result,
 511                         DBUS_TYPE_INVALID);
 512
 513                 if (dbus_error_is_set(&err)) {
 514                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 515                         dbus_error_free(&err);
 516                         result = TTS_ERROR_OPERATION_FAILED;
 517                 }
 518                 dbus_message_unref(result_msg);
 519
 520                 if (0 == result) {
 521                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 522                 } else {
 523                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 524                 }
 525         } else {
 526                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 527                 tts_dbus_reconnect();
 528                 result = TTS_ERROR_TIMED_OUT;
 529         }
 530
 531         if (NULL != temp) {
 532                 free(temp);
 533                 temp = NULL;
 534         }
 535         return result;
 536 }
 537
 538 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
 539 {
 540         if (NULL == key || NULL == data) {
 541                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 542                 return TTS_ERROR_INVALID_PARAMETER;
 543         }
 544
 545         DBusMessage* msg;
 546         DBusError err;
 547         dbus_error_init(&err);
 548
 549         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 550
 551         if (NULL == msg) {
 552                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 553                 return TTS_ERROR_OPERATION_FAILED;
 554         } else {
 555                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 556         }
 557
 558         if (true != dbus_message_append_args(msg,
 559                 DBUS_TYPE_INT32, &uid,
 560                 DBUS_TYPE_STRING, &key,
 561                 DBUS_TYPE_STRING, &data,
 562                 DBUS_TYPE_INVALID)) {
 563                 dbus_message_unref(msg);
 564                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 565
 566                 return TTS_ERROR_OPERATION_FAILED;
 567         }
 568
 569         DBusMessage* result_msg;
 570         int result = TTS_ERROR_OPERATION_FAILED;
 571
 572         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 573         dbus_message_unref(msg);
 574         if (dbus_error_is_set(&err)) {
 575                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 576                 dbus_error_free(&err);
 577         }
 578
 579         if (NULL != result_msg) {
 580                 dbus_message_get_args(result_msg, &err,
 581                         DBUS_TYPE_INT32, &result,
 582                         DBUS_TYPE_INVALID);
 583
 584                 if (dbus_error_is_set(&err)) {
 585                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 586                         dbus_error_free(&err);
 587                         result = TTS_ERROR_OPERATION_FAILED;
 588                 }
 589                 dbus_message_unref(result_msg);
 590
 591                 if (0 == result) {
 592                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 593                 } else {
 594                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 595                 }
 596         } else {
 597                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 598                 tts_dbus_reconnect();
 599                 result = TTS_ERROR_TIMED_OUT;
 600         }
 601
 602         return result;
 603 }
 604
 605 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 606 {
 607         if (NULL == key || NULL == data) {
 608                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 609                 return TTS_ERROR_INVALID_PARAMETER;
 610         }
 611
 612         DBusMessage* msg;
 613         DBusError err;
 614         dbus_error_init(&err);
 615
 616         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 617
 618         if (NULL == msg) {
 619                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 620                 return TTS_ERROR_OPERATION_FAILED;
 621         } else {
 622                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 623         }
 624
 625         if (true != dbus_message_append_args(msg,
 626                 DBUS_TYPE_INT32, &uid,
 627                 DBUS_TYPE_STRING, &key,
 628                 DBUS_TYPE_INVALID)) {
 629                 dbus_message_unref(msg);
 630                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 631
 632                 return TTS_ERROR_OPERATION_FAILED;
 633         }
 634
 635         DBusMessage* result_msg;
 636         int result = TTS_ERROR_OPERATION_FAILED;
 637
 638         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 639         dbus_message_unref(msg);
 640         if (dbus_error_is_set(&err)) {
 641                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 642                 dbus_error_free(&err);
 643         }
 644
 645         char* temp = NULL;
 646         if (NULL != result_msg) {
 647                 dbus_message_get_args(result_msg, &err,
 648                         DBUS_TYPE_INT32, &result,
 649                         DBUS_TYPE_STRING, &temp,
 650                         DBUS_TYPE_INVALID);
 651
 652                 if (dbus_error_is_set(&err)) {
 653                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 654                         dbus_error_free(&err);
 655                         result = TTS_ERROR_OPERATION_FAILED;
 656                 }
 657                 dbus_message_unref(result_msg);
 658
 659                 if (0 == result) {
 660                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 661                         if (NULL != temp) {
 662                                 *data = strdup(temp);
 663                         }
 664                 } else {
 665                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 666                 }
 667         } else {
 668                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 669                 tts_dbus_reconnect();
 670                 result = TTS_ERROR_TIMED_OUT;
 671         }
 672
 673         return result;
 674 }
 675
 676 int tts_dbus_request_play(int uid, const char* credential)
 677 {
 678         DBusMessage* msg;
 679         DBusError err;
 680         dbus_error_init(&err);
 681
 682         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 683
 684         if (NULL == msg) {
 685                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 686                 return TTS_ERROR_OPERATION_FAILED;
 687         } else {
 688                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 689         }
 690
 691         char *temp = NULL;
 692         if (NULL == credential) {
 693                 temp = strdup("NULL");
 694         } else {
 695                 temp = strdup(credential);
 696         }
 697
 698         if (true != dbus_message_append_args(msg,
 699                 DBUS_TYPE_INT32, &uid,
 700                 DBUS_TYPE_STRING, &temp,
 701                 DBUS_TYPE_INVALID)) {
 702                 dbus_message_unref(msg);
 703                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 704
 705                 if (NULL != temp) {
 706                         free(temp);
 707                         temp = NULL;
 708                 }
 709                 return TTS_ERROR_OPERATION_FAILED;
 710         }
 711
 712         DBusMessage* result_msg;
 713         int result = TTS_ERROR_OPERATION_FAILED;
 714
 715         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 716         dbus_message_unref(msg);
 717         if (dbus_error_is_set(&err)) {
 718                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 719                 dbus_error_free(&err);
 720         }
 721
 722         if (NULL != result_msg) {
 723                 dbus_message_get_args(result_msg, &err,
 724                         DBUS_TYPE_INT32, &result,
 725                         DBUS_TYPE_INVALID);
 726
 727                 if (dbus_error_is_set(&err)) {
 728                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 729                         dbus_error_free(&err);
 730                         result = TTS_ERROR_OPERATION_FAILED;
 731                 }
 732                 dbus_message_unref(result_msg);
 733
 734                 if (0 == result) {
 735                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 736                 } else {
 737                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 738                 }
 739         } else {
 740                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 741                 tts_dbus_reconnect();
 742                 result = TTS_ERROR_TIMED_OUT;
 743         }
 744
 745         if (NULL != temp) {
 746                 free(temp);
 747                 temp = NULL;
 748         }
 749         return result;
 750 }
 751
 752 int tts_dbus_request_stop(int uid)
 753 {
 754         DBusMessage* msg;
 755         DBusError err;
 756         dbus_error_init(&err);
 757
 758         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 759
 760         if (NULL == msg) {
 761                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 762                 return TTS_ERROR_OPERATION_FAILED;
 763         } else {
 764                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 765         }
 766
 767         DBusMessage* result_msg;
 768         int result = TTS_ERROR_OPERATION_FAILED;
 769
 770         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 771                 dbus_message_unref(msg);
 772                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 773
 774                 return TTS_ERROR_OPERATION_FAILED;
 775         }
 776
 777         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 778         dbus_message_unref(msg);
 779         if (dbus_error_is_set(&err)) {
 780                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 781                 dbus_error_free(&err);
 782         }
 783
 784         if (NULL != result_msg) {
 785                 dbus_message_get_args(result_msg, &err,
 786                         DBUS_TYPE_INT32, &result,
 787                         DBUS_TYPE_INVALID);
 788
 789                 if (dbus_error_is_set(&err)) {
 790                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 791                         dbus_error_free(&err);
 792                         result = TTS_ERROR_OPERATION_FAILED;
 793                 }
 794                 dbus_message_unref(result_msg);
 795
 796                 if (0 == result) {
 797                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 798                 } else {
 799                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 800                 }
 801         } else {
 802                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 803                 tts_dbus_reconnect();
 804                 result = TTS_ERROR_TIMED_OUT;
 805         }
 806
 807         return result;
 808 }
 809
 810 int tts_dbus_request_pause(int uid)
 811 {
 812         DBusMessage* msg;
 813         DBusError err;
 814         dbus_error_init(&err);
 815
 816         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 817
 818         if (NULL == msg) {
 819                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 820                 return TTS_ERROR_OPERATION_FAILED;
 821         } else {
 822                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 823         }
 824
 825         DBusMessage* result_msg;
 826         int result = TTS_ERROR_OPERATION_FAILED;
 827
 828         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 829                 dbus_message_unref(msg);
 830                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 831
 832                 return TTS_ERROR_OPERATION_FAILED;
 833         }
 834
 835         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 836         dbus_message_unref(msg);
 837         if (dbus_error_is_set(&err)) {
 838                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 839                 dbus_error_free(&err);
 840         }
 841
 842         if (NULL != result_msg) {
 843                 dbus_message_get_args(result_msg, &err,
 844                         DBUS_TYPE_INT32, &result,
 845                         DBUS_TYPE_INVALID);
 846
 847                 if (dbus_error_is_set(&err)) {
 848                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 849                         dbus_error_free(&err);
 850                         result = TTS_ERROR_OPERATION_FAILED;
 851                 }
 852                 dbus_message_unref(result_msg);
 853
 854                 if (0 == result) {
 855                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 856                 } else {
 857                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 858                 }
 859         } else {
 860                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 861                 tts_dbus_reconnect();
 862                 result = TTS_ERROR_TIMED_OUT;
 863         }
 864
 865         return result;
 866 }