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 #include "tts_internal.h"
  25
  26 #define HELLO_WAITING_TIME -1
  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 if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 139                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@ Owner Changed");
 140                         __tts_cb_error(-1, TTS_ERROR_SERVICE_RESET, -1, "Daemon Reset");
 141                         SLOG(LOG_DEBUG, TAG_TTSC, "@@@");
 142                         SLOG(LOG_DEBUG, TAG_TTSC, " ");
 143                 } /* NameOwnerChanged */
 144
 145                 else {
 146                         SLOG(LOG_DEBUG, TAG_TTSC, "Message is NOT valid");
 147                         dbus_message_unref(msg);
 148                         break;
 149                 }
 150
 151                 /* free the message */
 152                 dbus_message_unref(msg);
 153         }
 154         return ECORE_CALLBACK_PASS_ON;
 155 }
 156
 157 static void __tts_dbus_connection_free()
 158 {
 159         if (NULL != g_conn_listener) {
 160                 dbus_connection_close(g_conn_listener);
 161                 dbus_connection_unref(g_conn_listener);
 162                 g_conn_listener = NULL;
 163         }
 164         if (NULL != g_conn_sender) {
 165                 dbus_connection_close(g_conn_sender);
 166                 dbus_connection_unref(g_conn_sender);
 167                 g_conn_sender = NULL;
 168         }
 169 }
 170
 171 int tts_dbus_open_connection()
 172 {
 173         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 174                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 175                 return 0;
 176         }
 177
 178         DBusError err;
 179
 180         /* initialize the error value */
 181         dbus_error_init(&err);
 182
 183         /* connect to the DBUS system bus, and check for errors */
 184         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 185         if (dbus_error_is_set(&err)) {
 186                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 187                 dbus_error_free(&err);
 188         }
 189
 190         if (NULL == g_conn_sender) {
 191                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection");
 192                 return TTS_ERROR_OPERATION_FAILED;
 193         }
 194
 195         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 196
 197         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 198         if (dbus_error_is_set(&err)) {
 199                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)", err.message);
 200                 dbus_error_free(&err);
 201         }
 202
 203         if (NULL == g_conn_listener) {
 204                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection for listener");
 205                 __tts_dbus_connection_free();
 206                 return TTS_ERROR_OPERATION_FAILED;
 207         }
 208
 209         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 210
 211         char rule[128] = {0, };
 212         snprintf(rule, 128, "type='signal',interface='%s'", TTS_CLIENT_SERVICE_INTERFACE);
 213
 214         /* add a rule for which messages we want to see */
 215         dbus_bus_add_match(g_conn_listener, rule, &err);
 216         dbus_connection_flush(g_conn_listener);
 217
 218         int fd = 0;
 219         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 220                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get fd from dbus");
 221                 __tts_dbus_connection_free();
 222                 return TTS_ERROR_OPERATION_FAILED;
 223         } else {
 224                 SLOG(LOG_DEBUG, TAG_TTSC, "Get fd from dbus : %d", fd);
 225         }
 226
 227         g_dbus_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, NULL, NULL, NULL);
 228         if (NULL == g_dbus_fd_handler) {
 229                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore");
 230                 __tts_dbus_connection_free();
 231                 return TTS_ERROR_OPERATION_FAILED;
 232         }
 233
 234         return 0;
 235 }
 236
 237 int tts_dbus_close_connection()
 238 {
 239         DBusError err;
 240         dbus_error_init(&err);
 241
 242         if (NULL != g_dbus_fd_handler) {
 243                 ecore_main_fd_handler_del(g_dbus_fd_handler);
 244                 g_dbus_fd_handler = NULL;
 245         }
 246
 247         __tts_dbus_connection_free();
 248
 249         return 0;
 250 }
 251
 252 int tts_dbus_reconnect()
 253 {
 254         if (!g_conn_sender || !g_conn_listener) {
 255                 tts_dbus_close_connection();
 256
 257                 if (0 != tts_dbus_open_connection()) {
 258                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 259                         return -1;
 260                 }
 261
 262                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 263                 return 0;
 264         }
 265
 266         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 267         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 268         SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Sender(%s) Listener(%s)",
 269                  sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 270
 271         if (false == sender_connected || false == listener_connected) {
 272                 tts_dbus_close_connection();
 273
 274                 if (0 != tts_dbus_open_connection()) {
 275                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 276                         return -1;
 277                 }
 278
 279                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 280         }
 281
 282         return 0;
 283 }
 284
 285 DBusMessage* __tts_dbus_make_message(int uid, const char* method)
 286 {
 287         if (NULL == method) {
 288                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input method is NULL");
 289                 return NULL;
 290         }
 291
 292         tts_client_s* client = tts_client_get_by_uid(uid);
 293
 294         /* check handle */
 295         if (NULL == client) {
 296                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] uid is not available");
 297                 return NULL;
 298         }
 299
 300         DBusMessage* msg;
 301
 302         if (TTS_MODE_DEFAULT == client->mode) {
 303                 msg = dbus_message_new_method_call(
 304                         TTS_SERVER_SERVICE_NAME,
 305                         TTS_SERVER_SERVICE_OBJECT_PATH,
 306                         TTS_SERVER_SERVICE_INTERFACE,
 307                         method);
 308         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 309                 msg = dbus_message_new_method_call(
 310                         TTS_NOTI_SERVER_SERVICE_NAME,
 311                         TTS_NOTI_SERVER_SERVICE_OBJECT_PATH,
 312                         TTS_NOTI_SERVER_SERVICE_INTERFACE,
 313                         method);
 314         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 315                 msg = dbus_message_new_method_call(
 316                         TTS_SR_SERVER_SERVICE_NAME,
 317                         TTS_SR_SERVER_SERVICE_OBJECT_PATH,
 318                         TTS_SR_SERVER_SERVICE_INTERFACE,
 319                         method);
 320         } else if (TTS_MODE_INTERRUPT == client->mode) {
 321                 msg = dbus_message_new_method_call(
 322                         TTS_INTERRUPT_SERVER_SERVICE_NAME,
 323                         TTS_INTERRUPT_SERVER_SERVICE_OBJECT_PATH,
 324                         TTS_INTERRUPT_SERVER_SERVICE_INTERFACE,
 325                         method);
 326         } else {
 327                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Input mode is not available");
 328                 return NULL;
 329         }
 330
 331         return msg;
 332 }
 333
 334 int tts_dbus_request_hello(int uid)
 335 {
 336         DBusError err;
 337         dbus_error_init(&err);
 338         DBusMessage* msg;
 339
 340         msg = __tts_dbus_make_message(uid, TTS_METHOD_HELLO);
 341
 342         if (dbus_error_is_set(&err)) {
 343 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err);
 344                 dbus_error_free(&err);
 345         }
 346
 347         if (NULL == msg) {
 348                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message");
 349                 return TTS_ERROR_OPERATION_FAILED;
 350         }
 351
 352         DBusMessage* result_msg = NULL;
 353         int result = 0;
 354
 355         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, HELLO_WAITING_TIME, &err);
 356         dbus_message_unref(msg);
 357         if (dbus_error_is_set(&err)) {
 358                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts dbus log : %s", err.message);
 359                 dbus_error_free(&err);
 360         }
 361
 362         if (NULL != result_msg) {
 363                 dbus_message_unref(result_msg);
 364
 365 //              SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 366                 result = 0;
 367         } else {
 368                 result = TTS_ERROR_TIMED_OUT;
 369         }
 370
 371         return result;
 372 }
 373
 374 int tts_dbus_request_initialize(int uid, bool* credential_needed)
 375 {
 376         DBusMessage* msg;
 377         DBusError err;
 378         dbus_error_init(&err);
 379
 380         msg = __tts_dbus_make_message(uid, TTS_METHOD_INITIALIZE);
 381
 382         if (NULL == msg) {
 383                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message");
 384                 return TTS_ERROR_OPERATION_FAILED;
 385         } else {
 386                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 387         }
 388
 389         int pid = getpid();
 390         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 391                 dbus_message_unref(msg);
 392                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 393
 394                 return TTS_ERROR_OPERATION_FAILED;
 395         }
 396
 397         DBusMessage* result_msg;
 398         int result = TTS_ERROR_OPERATION_FAILED;
 399
 400         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 401         dbus_message_unref(msg);
 402         if (dbus_error_is_set(&err)) {
 403                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 404                 dbus_error_free(&err);
 405         }
 406
 407         int temp = 0;
 408         if (NULL != result_msg) {
 409                 dbus_message_get_args(result_msg, &err,
 410                                   DBUS_TYPE_INT32, &result,
 411                                   DBUS_TYPE_INT32, &temp,
 412                                   DBUS_TYPE_INVALID);
 413
 414                 if (dbus_error_is_set(&err)) {
 415                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 416                         dbus_error_free(&err);
 417                         result = TTS_ERROR_OPERATION_FAILED;
 418                 }
 419
 420                 dbus_message_unref(result_msg);
 421
 422                 if (0 == result) {
 423                         *credential_needed = (bool)temp;
 424                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d, credential_needed(%d)", result, *credential_needed);
 425
 426                         /* add a rule for daemon error */
 427                         char rule_err[256] = {0, };
 428                         tts_client_s* client = tts_client_get_by_uid(uid);
 429                         if (NULL == client) {
 430                                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
 431                                 return TTS_ERROR_OPERATION_FAILED;
 432                         }
 433
 434                         if (TTS_ERROR_SERVICE_RESET != client->reason) {
 435                                 if (TTS_MODE_DEFAULT == client->mode) {
 436                                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
 437                                 } else if (TTS_MODE_NOTIFICATION == client->mode) {
 438                                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
 439                                 } else if (TTS_MODE_SCREEN_READER == client->mode) {
 440                                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
 441                                 } else if (TTS_MODE_INTERRUPT == client->mode) {
 442                                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
 443                                 }
 444                                 dbus_bus_add_match(g_conn_listener, rule_err, &err);
 445                                 dbus_connection_flush(g_conn_listener);
 446
 447                                 if (dbus_error_is_set(&err)) {
 448                                         SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 449                                         dbus_error_free(&err);
 450                                         return TTS_ERROR_OPERATION_FAILED;
 451                                 }
 452                                 client->reason = 0; // default value
 453                         }
 454                 } else {
 455                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d", result);
 456                 }
 457         } else {
 458                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 459                 tts_dbus_reconnect();
 460                 result = TTS_ERROR_TIMED_OUT;
 461         }
 462
 463         return result;
 464 }
 465
 466
 467 int tts_dbus_request_finalize(int uid)
 468 {
 469         DBusMessage* msg;
 470         DBusError err;
 471         dbus_error_init(&err);
 472
 473         /* remove a rule for daemon error */
 474         char rule_err[256] = {0, };
 475         tts_client_s* client = tts_client_get_by_uid(uid);
 476         if (NULL == client) {
 477                 SLOG(LOG_ERROR, TAG_TTSC, "Fail to get TTS client");
 478                 return TTS_ERROR_OPERATION_FAILED;
 479         }
 480
 481         if (TTS_MODE_DEFAULT == client->mode) {
 482                 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SERVER_SERVICE_INTERFACE);
 483         } else if (TTS_MODE_NOTIFICATION == client->mode) {
 484                 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_NOTI_SERVER_SERVICE_INTERFACE);
 485         } else if (TTS_MODE_SCREEN_READER == client->mode) {
 486                 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_SR_SERVER_SERVICE_INTERFACE);
 487         } else if (TTS_MODE_INTERRUPT == client->mode) {
 488                 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", TTS_INTERRUPT_SERVER_SERVICE_INTERFACE);
 489         }
 490         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
 491         dbus_connection_flush(g_conn_listener);
 492         if (dbus_error_is_set(&err)) {
 493                 SLOG(LOG_ERROR, TAG_TTSC, "Match Error (%s)", err.message);
 494                 dbus_error_free(&err);
 495         }
 496
 497         msg = __tts_dbus_make_message(uid, TTS_METHOD_FINALIZE);
 498
 499         if (NULL == msg) {
 500                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 501                 return TTS_ERROR_OPERATION_FAILED;
 502         } else {
 503                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 504         }
 505
 506         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 507                 dbus_message_unref(msg);
 508                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 509
 510                 return TTS_ERROR_OPERATION_FAILED;
 511         }
 512
 513         DBusMessage* result_msg;
 514         int result = TTS_ERROR_OPERATION_FAILED;
 515
 516         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 517         dbus_message_unref(msg);
 518         if (dbus_error_is_set(&err)) {
 519                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error %s", err.message);
 520                 dbus_error_free(&err);
 521         }
 522
 523         if (NULL != result_msg) {
 524                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 525
 526                 if (dbus_error_is_set(&err)) {
 527                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)", err.message);
 528                         dbus_error_free(&err);
 529                         result = TTS_ERROR_OPERATION_FAILED;
 530                 }
 531
 532                 dbus_message_unref(result_msg);
 533
 534                 if (0 == result) {
 535                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 536                 } else {
 537                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d", result);
 538                 }
 539         } else {
 540                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 541                 tts_dbus_reconnect();
 542                 result = TTS_ERROR_TIMED_OUT;
 543         }
 544
 545         return result;
 546 }
 547
 548 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid, const char* credential)
 549 {
 550         if (NULL == text || NULL == lang) {
 551                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 552                 return TTS_ERROR_INVALID_PARAMETER;
 553         }
 554
 555         DBusMessage* msg;
 556         DBusError err;
 557         dbus_error_init(&err);
 558
 559         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_QUEUE);
 560
 561         if (NULL == msg) {
 562                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 563                 return TTS_ERROR_OPERATION_FAILED;
 564         } else {
 565                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d), credential(%s)",
 566                          uid, text, lang, vctype, speed, uttid, (NULL == credential) ? "NULL" : credential);
 567         }
 568
 569         char *temp = NULL;
 570         if (NULL == credential) {
 571                 temp = strdup("NULL");
 572         } else {
 573                 temp = strdup(credential);
 574         }
 575
 576         if (true != dbus_message_append_args(msg,
 577                 DBUS_TYPE_INT32, &uid,
 578                 DBUS_TYPE_STRING, &text,
 579                 DBUS_TYPE_STRING, &lang,
 580                 DBUS_TYPE_INT32, &vctype,
 581                 DBUS_TYPE_INT32, &speed,
 582                 DBUS_TYPE_INT32, &uttid,
 583                 DBUS_TYPE_STRING, &temp,
 584                 DBUS_TYPE_INVALID)) {
 585                 dbus_message_unref(msg);
 586                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 587
 588                 if (NULL != temp) {
 589                         free(temp);
 590                         temp = NULL;
 591                 }
 592                 return TTS_ERROR_OPERATION_FAILED;
 593         }
 594
 595         DBusMessage* result_msg;
 596         int result = TTS_ERROR_OPERATION_FAILED;
 597
 598         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 599         dbus_message_unref(msg);
 600         if (dbus_error_is_set(&err)) {
 601                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 602                 dbus_error_free(&err);
 603         }
 604
 605         if (NULL != result_msg) {
 606                 dbus_message_get_args(result_msg, &err,
 607                         DBUS_TYPE_INT32, &result,
 608                         DBUS_TYPE_INVALID);
 609
 610                 if (dbus_error_is_set(&err)) {
 611                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)", err.message);
 612                         dbus_error_free(&err);
 613                         result = TTS_ERROR_OPERATION_FAILED;
 614                 }
 615                 dbus_message_unref(result_msg);
 616
 617                 if (0 == result) {
 618                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 619                 } else {
 620                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d)", result);
 621                 }
 622         } else {
 623                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 624                 tts_dbus_reconnect();
 625                 result = TTS_ERROR_TIMED_OUT;
 626         }
 627
 628         if (NULL != temp) {
 629                 free(temp);
 630                 temp = NULL;
 631         }
 632         return result;
 633 }
 634
 635 int tts_dbus_request_set_private_data(int uid, const char* key, const char* data)
 636 {
 637         if (NULL == key || NULL == data) {
 638                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 639                 return TTS_ERROR_INVALID_PARAMETER;
 640         }
 641
 642         DBusMessage* msg;
 643         DBusError err;
 644         dbus_error_init(&err);
 645
 646         msg = __tts_dbus_make_message(uid, TTS_METHOD_SET_PRIVATE_DATA);
 647
 648         if (NULL == msg) {
 649                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts set private data : Fail to make message");
 650                 return TTS_ERROR_OPERATION_FAILED;
 651         } else {
 652                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts set private data : uid(%d)", uid);
 653         }
 654
 655         if (true != dbus_message_append_args(msg,
 656                 DBUS_TYPE_INT32, &uid,
 657                 DBUS_TYPE_STRING, &key,
 658                 DBUS_TYPE_STRING, &data,
 659                 DBUS_TYPE_INVALID)) {
 660                 dbus_message_unref(msg);
 661                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 662
 663                 return TTS_ERROR_OPERATION_FAILED;
 664         }
 665
 666         DBusMessage* result_msg;
 667         int result = TTS_ERROR_OPERATION_FAILED;
 668
 669         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 670         dbus_message_unref(msg);
 671         if (dbus_error_is_set(&err)) {
 672                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 673                 dbus_error_free(&err);
 674         }
 675
 676         if (NULL != result_msg) {
 677                 dbus_message_get_args(result_msg, &err,
 678                         DBUS_TYPE_INT32, &result,
 679                         DBUS_TYPE_INVALID);
 680
 681                 if (dbus_error_is_set(&err)) {
 682                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : Get arguments error (%s)", err.message);
 683                         dbus_error_free(&err);
 684                         result = TTS_ERROR_OPERATION_FAILED;
 685                 }
 686                 dbus_message_unref(result_msg);
 687
 688                 if (0 == result) {
 689                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 690                 } else {
 691                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts set private data : result(%d)", result);
 692                 }
 693         } else {
 694                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 695                 tts_dbus_reconnect();
 696                 result = TTS_ERROR_TIMED_OUT;
 697         }
 698
 699         return result;
 700 }
 701
 702 int tts_dbus_request_get_private_data(int uid, const char* key, char** data)
 703 {
 704         if (NULL == key || NULL == data) {
 705                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 706                 return TTS_ERROR_INVALID_PARAMETER;
 707         }
 708
 709         DBusMessage* msg;
 710         DBusError err;
 711         dbus_error_init(&err);
 712
 713         msg = __tts_dbus_make_message(uid, TTS_METHOD_GET_PRIVATE_DATA);
 714
 715         if (NULL == msg) {
 716                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get private data : Fail to make message");
 717                 return TTS_ERROR_OPERATION_FAILED;
 718         } else {
 719                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get private data : uid(%d)", uid);
 720         }
 721
 722         if (true != dbus_message_append_args(msg,
 723                 DBUS_TYPE_INT32, &uid,
 724                 DBUS_TYPE_STRING, &key,
 725                 DBUS_TYPE_INVALID)) {
 726                 dbus_message_unref(msg);
 727                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 728
 729                 return TTS_ERROR_OPERATION_FAILED;
 730         }
 731
 732         DBusMessage* result_msg;
 733         int result = TTS_ERROR_OPERATION_FAILED;
 734
 735         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 736         dbus_message_unref(msg);
 737         if (dbus_error_is_set(&err)) {
 738                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 739                 dbus_error_free(&err);
 740         }
 741
 742         char* temp = NULL;
 743         if (NULL != result_msg) {
 744                 dbus_message_get_args(result_msg, &err,
 745                         DBUS_TYPE_INT32, &result,
 746                         DBUS_TYPE_STRING, &temp,
 747                         DBUS_TYPE_INVALID);
 748
 749                 if (dbus_error_is_set(&err)) {
 750                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : Get arguments error (%s)", err.message);
 751                         dbus_error_free(&err);
 752                         result = TTS_ERROR_OPERATION_FAILED;
 753                 }
 754                 dbus_message_unref(result_msg);
 755
 756                 if (0 == result) {
 757                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 758                         if (NULL != temp) {
 759                                 *data = strdup(temp);
 760                         }
 761                 } else {
 762                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get private data : result(%d)", result);
 763                 }
 764         } else {
 765                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 766                 tts_dbus_reconnect();
 767                 result = TTS_ERROR_TIMED_OUT;
 768         }
 769
 770         return result;
 771 }
 772
 773 int tts_dbus_request_play(int uid, const char* credential)
 774 {
 775         DBusMessage* msg;
 776         DBusError err;
 777         dbus_error_init(&err);
 778
 779         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY);
 780
 781         if (NULL == msg) {
 782                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 783                 return TTS_ERROR_OPERATION_FAILED;
 784         } else {
 785                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 786         }
 787
 788         char *temp = NULL;
 789         if (NULL == credential) {
 790                 temp = strdup("NULL");
 791         } else {
 792                 temp = strdup(credential);
 793         }
 794
 795         if (true != dbus_message_append_args(msg,
 796                 DBUS_TYPE_INT32, &uid,
 797                 DBUS_TYPE_STRING, &temp,
 798                 DBUS_TYPE_INVALID)) {
 799                 dbus_message_unref(msg);
 800                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 801
 802                 if (NULL != temp) {
 803                         free(temp);
 804                         temp = NULL;
 805                 }
 806                 return TTS_ERROR_OPERATION_FAILED;
 807         }
 808
 809         DBusMessage* result_msg;
 810         int result = TTS_ERROR_OPERATION_FAILED;
 811
 812         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 813         dbus_message_unref(msg);
 814         if (dbus_error_is_set(&err)) {
 815                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 816                 dbus_error_free(&err);
 817         }
 818
 819         if (NULL != result_msg) {
 820                 dbus_message_get_args(result_msg, &err,
 821                         DBUS_TYPE_INT32, &result,
 822                         DBUS_TYPE_INVALID);
 823
 824                 if (dbus_error_is_set(&err)) {
 825                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)", err.message);
 826                         dbus_error_free(&err);
 827                         result = TTS_ERROR_OPERATION_FAILED;
 828                 }
 829                 dbus_message_unref(result_msg);
 830
 831                 if (0 == result) {
 832                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d)", result);
 833                 } else {
 834                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d)", result);
 835                 }
 836         } else {
 837                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 838                 tts_dbus_reconnect();
 839                 result = TTS_ERROR_TIMED_OUT;
 840         }
 841
 842         if (NULL != temp) {
 843                 free(temp);
 844                 temp = NULL;
 845         }
 846         return result;
 847 }
 848
 849 int tts_dbus_request_stop(int uid)
 850 {
 851         DBusMessage* msg;
 852         DBusError err;
 853         dbus_error_init(&err);
 854
 855         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP);
 856
 857         if (NULL == msg) {
 858                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 859                 return TTS_ERROR_OPERATION_FAILED;
 860         } else {
 861                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 862         }
 863
 864         DBusMessage* result_msg;
 865         int result = TTS_ERROR_OPERATION_FAILED;
 866
 867         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 868                 dbus_message_unref(msg);
 869                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 870
 871                 return TTS_ERROR_OPERATION_FAILED;
 872         }
 873
 874         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 875         dbus_message_unref(msg);
 876         if (dbus_error_is_set(&err)) {
 877                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 878                 dbus_error_free(&err);
 879         }
 880
 881         if (NULL != result_msg) {
 882                 dbus_message_get_args(result_msg, &err,
 883                         DBUS_TYPE_INT32, &result,
 884                         DBUS_TYPE_INVALID);
 885
 886                 if (dbus_error_is_set(&err)) {
 887                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)", err.message);
 888                         dbus_error_free(&err);
 889                         result = TTS_ERROR_OPERATION_FAILED;
 890                 }
 891                 dbus_message_unref(result_msg);
 892
 893                 if (0 == result) {
 894                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 895                 } else {
 896                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d)", result);
 897                 }
 898         } else {
 899                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 900                 tts_dbus_reconnect();
 901                 result = TTS_ERROR_TIMED_OUT;
 902         }
 903
 904         return result;
 905 }
 906
 907 int tts_dbus_request_pause(int uid)
 908 {
 909         DBusMessage* msg;
 910         DBusError err;
 911         dbus_error_init(&err);
 912
 913         msg = __tts_dbus_make_message(uid, TTS_METHOD_PAUSE);
 914
 915         if (NULL == msg) {
 916                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 917                 return TTS_ERROR_OPERATION_FAILED;
 918         } else {
 919                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 920         }
 921
 922         DBusMessage* result_msg;
 923         int result = TTS_ERROR_OPERATION_FAILED;
 924
 925         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 926                 dbus_message_unref(msg);
 927                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 928
 929                 return TTS_ERROR_OPERATION_FAILED;
 930         }
 931
 932         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 933         dbus_message_unref(msg);
 934         if (dbus_error_is_set(&err)) {
 935                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 936                 dbus_error_free(&err);
 937         }
 938
 939         if (NULL != result_msg) {
 940                 dbus_message_get_args(result_msg, &err,
 941                         DBUS_TYPE_INT32, &result,
 942                         DBUS_TYPE_INVALID);
 943
 944                 if (dbus_error_is_set(&err)) {
 945                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)", err.message);
 946                         dbus_error_free(&err);
 947                         result = TTS_ERROR_OPERATION_FAILED;
 948                 }
 949                 dbus_message_unref(result_msg);
 950
 951                 if (0 == result) {
 952                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 953                 } else {
 954                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d)", result);
 955                 }
 956         } else {
 957                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 958                 tts_dbus_reconnect();
 959                 result = TTS_ERROR_TIMED_OUT;
 960         }
 961
 962         return result;
 963 }
 964
 965 //LCOV_EXCL_START
 966 int tts_dbus_request_play_pcm(int uid)
 967 {
 968         DBusMessage* msg;
 969         DBusError err;
 970         dbus_error_init(&err);
 971
 972         msg = __tts_dbus_make_message(uid, TTS_METHOD_PLAY_PCM);
 973
 974         if (NULL == msg) {
 975                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play pcm : Fail to make message");
 976                 return TTS_ERROR_OPERATION_FAILED;
 977         } else {
 978                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play pcm : uid(%d)", uid);
 979         }
 980
 981         if (true != dbus_message_append_args(msg,
 982                 DBUS_TYPE_INT32, &uid,
 983                 DBUS_TYPE_INVALID)) {
 984                 dbus_message_unref(msg);
 985                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 986                 return TTS_ERROR_OPERATION_FAILED;
 987         }
 988
 989         DBusMessage* result_msg;
 990         int result = TTS_ERROR_OPERATION_FAILED;
 991
 992         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
 993         dbus_message_unref(msg);
 994         if (dbus_error_is_set(&err)) {
 995                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
 996                 dbus_error_free(&err);
 997         }
 998
 999         if (NULL != result_msg) {
1000                 dbus_message_get_args(result_msg, &err,
1001                         DBUS_TYPE_INT32, &result,
1002                         DBUS_TYPE_INVALID);
1003
1004                 if (dbus_error_is_set(&err)) {
1005                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : Get arguments error (%s)", err.message);
1006                         dbus_error_free(&err);
1007                         result = TTS_ERROR_OPERATION_FAILED;
1008                 }
1009                 dbus_message_unref(result_msg);
1010
1011                 if (0 == result) {
1012                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1013                 } else {
1014                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play pcm : result(%d)", result);
1015                 }
1016         } else {
1017                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1018                 tts_dbus_reconnect();
1019                 result = TTS_ERROR_TIMED_OUT;
1020         }
1021
1022         return result;
1023 }
1024
1025 int tts_dbus_request_stop_pcm(int uid)
1026 {
1027         DBusMessage* msg;
1028         DBusError err;
1029         dbus_error_init(&err);
1030
1031         msg = __tts_dbus_make_message(uid, TTS_METHOD_STOP_PCM);
1032
1033         if (NULL == msg) {
1034                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop pcm : Fail to make message");
1035                 return TTS_ERROR_OPERATION_FAILED;
1036         } else {
1037                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop pcm : uid(%d)", uid);
1038         }
1039
1040         if (true != dbus_message_append_args(msg,
1041                 DBUS_TYPE_INT32, &uid,
1042                 DBUS_TYPE_INVALID)) {
1043                 dbus_message_unref(msg);
1044                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1045                 return TTS_ERROR_OPERATION_FAILED;
1046         }
1047
1048         DBusMessage* result_msg;
1049         int result = TTS_ERROR_OPERATION_FAILED;
1050
1051         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1052         dbus_message_unref(msg);
1053         if (dbus_error_is_set(&err)) {
1054                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1055                 dbus_error_free(&err);
1056         }
1057
1058         if (NULL != result_msg) {
1059                 dbus_message_get_args(result_msg, &err,
1060                         DBUS_TYPE_INT32, &result,
1061                         DBUS_TYPE_INVALID);
1062
1063                 if (dbus_error_is_set(&err)) {
1064                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : Get arguments error (%s)", err.message);
1065                         dbus_error_free(&err);
1066                         result = TTS_ERROR_OPERATION_FAILED;
1067                 }
1068                 dbus_message_unref(result_msg);
1069
1070                 if (0 == result) {
1071                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1072                 } else {
1073                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop pcm : result(%d)", result);
1074                 }
1075         } else {
1076                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1077                 tts_dbus_reconnect();
1078                 result = TTS_ERROR_TIMED_OUT;
1079         }
1080
1081         return result;
1082 }
1083
1084 int tts_dbus_request_add_pcm(int uid, int event, const char* data, int data_size, int audio_type, int rate)
1085 {
1086         DBusMessage* msg;
1087         DBusError err;
1088         dbus_error_init(&err);
1089
1090         msg = __tts_dbus_make_message(uid, TTS_METHOD_ADD_PCM);
1091
1092         if (NULL == msg) {
1093                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add pcm : Fail to make message");
1094                 return TTS_ERROR_OPERATION_FAILED;
1095         } else {
1096                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add pcm : uid(%d)", uid);
1097         }
1098
1099         if (true != dbus_message_append_args(msg,
1100                 DBUS_TYPE_INT32, &uid,
1101                 DBUS_TYPE_INT32, &event,
1102                 DBUS_TYPE_INT32, &audio_type,
1103                 DBUS_TYPE_INT32, &rate,
1104                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1105                 &data, data_size,
1106                 DBUS_TYPE_INVALID)) {
1107                 dbus_message_unref(msg);
1108                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
1109                 return TTS_ERROR_OPERATION_FAILED;
1110         }
1111
1112         DBusMessage* result_msg;
1113         int result = TTS_ERROR_OPERATION_FAILED;
1114
1115         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, WAITING_TIME, &err);
1116         dbus_message_unref(msg);
1117         if (dbus_error_is_set(&err)) {
1118                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Send error (%s)", err.message);
1119                 dbus_error_free(&err);
1120         }
1121
1122         if (NULL != result_msg) {
1123                 dbus_message_get_args(result_msg, &err,
1124                         DBUS_TYPE_INT32, &result,
1125                         DBUS_TYPE_INVALID);
1126
1127                 if (dbus_error_is_set(&err)) {
1128                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : Get arguments error (%s)", err.message);
1129                         dbus_error_free(&err);
1130                         result = TTS_ERROR_OPERATION_FAILED;
1131                 }
1132                 dbus_message_unref(result_msg);
1133
1134                 if (0 == result) {
1135                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1136                 } else {
1137                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add pcm : result(%d)", result);
1138                 }
1139         } else {
1140                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
1141                 tts_dbus_reconnect();
1142                 result = TTS_ERROR_TIMED_OUT;
1143         }
1144
1145         return result;
1146 }
1147 // LCOV_EXCL_STOP