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