client/tts_dbus.c

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