client/tts_dbus.c

   1 /*
   2 *  Copyright (c) 2012, 2013 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
  15 #include <Ecore.h>
  16 #include "tts_main.h"
  17 #include "tts_dbus.h"
  18 #include "tts_defs.h"
  19 #include "tts_client.h"
  20
  21 #define INIT_WAITING_TIME 5000
  22 #define WAITING_TIME 1000
  23
  24 static Ecore_Fd_Handler* g_fd_handler = NULL;
  25
  26 static DBusConnection* g_conn = NULL;
  27
  28
  29 extern int __tts_cb_error(int uid, tts_error_e reason, int utt_id);
  30
  31 extern int __tts_cb_set_state(int uid, int state);
  32
  33 extern int __tts_cb_utt_started(int uid, int utt_id);
  34
  35 extern int __tts_cb_utt_completed(int uid, int utt_id);
  36
  37
  38 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  39 {
  40         DBusConnection* conn = (DBusConnection*)data;
  41
  42         if (NULL == conn)       return ECORE_CALLBACK_RENEW;
  43
  44         dbus_connection_read_write_dispatch(conn, 50);
  45
  46         DBusMessage* msg = NULL;
  47         msg = dbus_connection_pop_message(conn);
  48
  49         /* loop again if we haven't read a message */
  50         if (NULL == msg) {
  51                 return ECORE_CALLBACK_RENEW;
  52         }
  53
  54         DBusError err;
  55         dbus_error_init(&err);
  56
  57         DBusMessage *reply = NULL;
  58
  59         char if_name[64];
  60         snprintf(if_name, 64, "%s%d", TTS_CLIENT_SERVICE_INTERFACE, getpid());
  61
  62         /* check if the message is a signal from the correct interface and with the correct name */
  63         if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_HELLO)) {
  64                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get Hello");
  65                 int uid = 0;
  66                 int response = -1;
  67
  68                 dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
  69
  70                 if (uid > 0) {
  71                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get hello : uid(%d) \n", uid);
  72
  73                         /* check uid */
  74                         tts_client_s* client = tts_client_get_by_uid(uid);
  75                         if (NULL != client)
  76                                 response = 1;
  77                         else
  78                                 response = 0;
  79                 } else {
  80                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get hello : invalid uid \n");
  81                 }
  82
  83                 reply = dbus_message_new_method_return(msg);
  84
  85                 if (NULL != reply) {
  86                         dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  87
  88                         if (!dbus_connection_send(conn, reply, NULL))
  89                                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> tts get hello : fail to send reply");
  90                         else
  91                                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> tts get hello : result(%d)", response);
  92
  93                         dbus_connection_flush(conn);
  94                         dbus_message_unref(reply);
  95                 } else {
  96                         SLOG(LOG_ERROR, TAG_TTSC, ">>>> tts get hello : fail to create reply message");
  97                 }
  98
  99                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 100                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 101         } /* TTSD_METHOD_HELLO */
 102
 103         else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_UTTERANCE_STARTED)) {
 104                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance started");
 105                 int uid, uttid;
 106                 dbus_message_get_args(msg, &err,
 107                         DBUS_TYPE_INT32, &uid,
 108                         DBUS_TYPE_INT32, &uttid,
 109                         DBUS_TYPE_INVALID);
 110
 111                 if (dbus_error_is_set(&err)) {
 112                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance started - Get arguments error (%s)\n", err.message);
 113                         dbus_error_free(&err);
 114                 } else {
 115                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance started message : uid(%d), uttid(%d) \n", uid, uttid);
 116                         __tts_cb_utt_started(uid, uttid);
 117                 }
 118
 119                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 120                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 121         }/* TTS_SIGNAL_UTTERANCE_STARTED */
 122
 123         else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_UTTERANCE_COMPLETED)) {
 124                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance completed");
 125                 int uid, uttid;
 126                 dbus_message_get_args(msg, &err,
 127                         DBUS_TYPE_INT32, &uid,
 128                         DBUS_TYPE_INT32, &uttid,
 129                         DBUS_TYPE_INVALID);
 130
 131                 if (dbus_error_is_set(&err)) {
 132                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance completed - Get arguments error (%s)\n", err.message);
 133                         dbus_error_free(&err);
 134                 } else {
 135                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance completed message : uid(%d), uttid(%d) \n", uid, uttid);
 136                         __tts_cb_utt_completed(uid, uttid);
 137                 }
 138
 139                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 140                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 141         }/* TTS_SIGNAL_UTTERANCE_COMPLETED */
 142
 143         else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_SET_STATE)) {
 144                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get state changed callback");
 145                 int uid;
 146                 int state;
 147                 dbus_message_get_args(msg, &err,
 148                         DBUS_TYPE_INT32, &uid,
 149                         DBUS_TYPE_INT32, &state,
 150                         DBUS_TYPE_INVALID);
 151
 152                 if (dbus_error_is_set(&err)) {
 153                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get state change - Get arguments error (%s)", err.message);
 154                         dbus_error_free(&err);
 155                 } else {
 156                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get state change : uid(%d) , state(%d)", uid, state);
 157                         __tts_cb_set_state(uid, state);
 158                 }
 159
 160                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 161                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 162         } /* TTSD_METHOD_SET_STATE */
 163
 164         else if (dbus_message_is_method_call(msg, if_name, TTSD_METHOD_ERROR)) {
 165                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get error callback");
 166
 167                 int uid;
 168                 int uttid;
 169                 int reason;
 170
 171                 dbus_message_get_args(msg, &err,
 172                         DBUS_TYPE_INT32, &uid,
 173                         DBUS_TYPE_INT32, &uttid,
 174                         DBUS_TYPE_INT32, &reason,
 175                         DBUS_TYPE_INVALID);
 176
 177                 if (dbus_error_is_set(&err)) {
 178                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error signal - Get arguments error (%s)\n", err.message);
 179                         dbus_error_free(&err);
 180                 } else {
 181                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Error signal : uid(%d), error(%d), uttid(%d)\n", uid, reason, uttid);
 182                         __tts_cb_error(uid, reason, uttid);
 183                 }
 184
 185                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 186                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 187         }/* TTS_SIGNAL_ERROR */
 188
 189         /* free the message */
 190         dbus_message_unref(msg);
 191
 192         return ECORE_CALLBACK_PASS_ON;
 193 }
 194
 195
 196 int tts_dbus_open_connection()
 197 {
 198         if (NULL != g_conn) {
 199                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 200                 return 0;
 201         }
 202
 203         DBusError err;
 204         int ret;
 205
 206         /* initialise the error value */
 207         dbus_error_init(&err);
 208
 209         /* connect to the DBUS system bus, and check for errors */
 210         g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 211
 212         if (dbus_error_is_set(&err)) {
 213                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)\n", err.message);
 214                 dbus_error_free(&err);
 215         }
 216
 217         if (NULL == g_conn) {
 218                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection \n");
 219                 return TTS_ERROR_OPERATION_FAILED;
 220         }
 221
 222         dbus_connection_set_exit_on_disconnect(g_conn, false);
 223
 224         int pid = getpid();
 225
 226         char service_name[64];
 227         memset(service_name, 0, 64);
 228         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 229
 230         SLOG(LOG_DEBUG, TAG_TTSC, "Service name is %s\n", service_name);
 231
 232         /* register our name on the bus, and check for errors */
 233         ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 234
 235         if (dbus_error_is_set(&err)) {
 236                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Name Error (%s)\n", err.message);
 237                 dbus_error_free(&err);
 238         }
 239
 240         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 241                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open connection : Service name has already been existed. \n");
 242                 return TTS_ERROR_OPERATION_FAILED;
 243         }
 244
 245         char rule[128];
 246         snprintf(rule, 128, "type='signal',interface='%s%d'", TTS_CLIENT_SERVICE_INTERFACE, pid);
 247
 248         /* add a rule for which messages we want to see */
 249         dbus_bus_add_match(g_conn, rule, &err);
 250         dbus_connection_flush(g_conn);
 251
 252         if (dbus_error_is_set(&err)) {
 253                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Match Error (%s)\n", err.message);
 254                 return TTS_ERROR_OPERATION_FAILED;
 255         }
 256
 257         int fd = 0;
 258         dbus_connection_get_unix_fd(g_conn, &fd);
 259
 260         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
 261
 262         if (NULL == g_fd_handler) {
 263                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore \n");
 264                 return TTS_ERROR_OPERATION_FAILED;
 265         }
 266
 267         return 0;
 268 }
 269
 270
 271 int tts_dbus_close_connection()
 272 {
 273         DBusError err;
 274         dbus_error_init(&err);
 275
 276         ecore_main_fd_handler_del(g_fd_handler);
 277
 278         int pid = getpid();
 279
 280         char service_name[64];
 281         memset(service_name, 0, 64);
 282         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 283
 284         dbus_bus_release_name (g_conn, service_name, &err);
 285
 286         dbus_connection_close(g_conn);
 287
 288         g_fd_handler = NULL;
 289         g_conn = NULL;
 290
 291         return 0;
 292 }
 293
 294
 295 int tts_dbus_reconnect()
 296 {
 297         bool connected = dbus_connection_get_is_connected(g_conn);
 298         SLOG(LOG_DEBUG, "[DBUS] %s\n", connected ? "Connected" : "Not connected");
 299
 300         if (false == connected) {
 301                 tts_dbus_close_connection();
 302
 303                 if(0 != tts_dbus_open_connection()) {
 304                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to reconnect");
 305                         return -1;
 306                 }
 307
 308                 SLOG(LOG_DEBUG, TAG_TTSC, "[DBUS] Reconnect");
 309         }
 310
 311         return 0;
 312 }
 313
 314
 315 int tts_dbus_request_hello()
 316 {
 317         DBusMessage* msg;
 318
 319         msg = dbus_message_new_method_call(
 320                 TTS_SERVER_SERVICE_NAME,
 321                 TTS_SERVER_SERVICE_OBJECT_PATH,
 322                 TTS_SERVER_SERVICE_INTERFACE,
 323                 TTS_METHOD_HELLO);
 324
 325         if (NULL == msg) {
 326                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts hello : Fail to make message \n");
 327                 return TTS_ERROR_OPERATION_FAILED;
 328         }
 329
 330         DBusError err;
 331         dbus_error_init(&err);
 332
 333         DBusMessage* result_msg = NULL;
 334         int result = 0;
 335
 336         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 337
 338         dbus_message_unref(msg);
 339
 340         if (NULL != result_msg) {
 341                 dbus_message_unref(result_msg);
 342
 343                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 344                 result = 0;
 345         } else {
 346                 result = TTS_ERROR_OPERATION_FAILED;
 347         }
 348
 349         return result;
 350 }
 351
 352 int tts_dbus_request_initialize(int uid)
 353 {
 354         DBusMessage* msg;
 355         DBusError err;
 356         dbus_error_init(&err);
 357
 358         msg = dbus_message_new_method_call(
 359                 TTS_SERVER_SERVICE_NAME,
 360                 TTS_SERVER_SERVICE_OBJECT_PATH,
 361                 TTS_SERVER_SERVICE_INTERFACE,
 362                 TTS_METHOD_INITIALIZE);
 363
 364         if (NULL == msg) {
 365                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message \n");
 366                 if (dbus_error_is_set(&err))
 367                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 368
 369                 return TTS_ERROR_OPERATION_FAILED;
 370         } else {
 371                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 372         }
 373
 374         int pid = getpid();
 375         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 376                 dbus_message_unref(msg);
 377                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 378
 379                 return TTS_ERROR_OPERATION_FAILED;
 380         }
 381
 382         DBusMessage* result_msg;
 383         int result = TTS_ERROR_OPERATION_FAILED;
 384
 385         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, INIT_WAITING_TIME, &err);
 386         dbus_message_unref(msg);
 387
 388         if (dbus_error_is_set(&err))
 389                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 390
 391         if (NULL != result_msg) {
 392                 dbus_message_get_args(result_msg, &err,
 393                                   DBUS_TYPE_INT32, &result,
 394                                   DBUS_TYPE_INVALID);
 395
 396                 if (dbus_error_is_set(&err)) {
 397                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 398                         dbus_error_free(&err);
 399                         result = TTS_ERROR_OPERATION_FAILED;
 400                 }
 401
 402                 dbus_message_unref(result_msg);
 403         } else {
 404                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 405                 if (dbus_error_is_set(&err))
 406                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 407                 tts_dbus_reconnect();
 408         }
 409
 410         if (0 == result) {
 411                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 412         } else {
 413                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 414         }
 415
 416         return result;
 417 }
 418
 419
 420 int tts_dbus_request_finalize(int uid)
 421 {
 422         DBusMessage* msg;
 423         DBusError err;
 424         dbus_error_init(&err);
 425
 426         msg = dbus_message_new_method_call(
 427                 TTS_SERVER_SERVICE_NAME,
 428                 TTS_SERVER_SERVICE_OBJECT_PATH,
 429                 TTS_SERVER_SERVICE_INTERFACE,
 430                 TTS_METHOD_FINALIZE);
 431
 432         if (NULL == msg) {
 433                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 434                 if (dbus_error_is_set(&err))
 435                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 436
 437                 return TTS_ERROR_OPERATION_FAILED;
 438         } else {
 439                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 440         }
 441
 442         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 443                 dbus_message_unref(msg);
 444                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 445
 446                 return TTS_ERROR_OPERATION_FAILED;
 447         }
 448
 449         DBusMessage* result_msg;
 450         int result = TTS_ERROR_OPERATION_FAILED;
 451
 452         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 453         dbus_message_unref(msg);
 454
 455         if (dbus_error_is_set(&err))
 456                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 457
 458         if (NULL != result_msg) {
 459                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 460
 461                 if (dbus_error_is_set(&err)) {
 462                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 463                         dbus_error_free(&err);
 464                         result = TTS_ERROR_OPERATION_FAILED;
 465                 }
 466
 467                 dbus_message_unref(result_msg);
 468         } else {
 469                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 470                 if (dbus_error_is_set(&err))
 471                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 472                 tts_dbus_reconnect();
 473         }
 474
 475         if (0 == result) {
 476                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 477         } else {
 478                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 479         }
 480
 481         return result;
 482 }
 483
 484 int tts_dbus_request_get_support_voice(int uid, tts_h tts, tts_supported_voice_cb callback, void* user_data)
 485 {
 486         DBusMessage* msg;
 487         DBusError err;
 488         dbus_error_init(&err);
 489
 490         msg = dbus_message_new_method_call(
 491                 TTS_SERVER_SERVICE_NAME,
 492                 TTS_SERVER_SERVICE_OBJECT_PATH,
 493                 TTS_SERVER_SERVICE_INTERFACE,
 494                 TTS_METHOD_GET_SUPPORT_VOICES);
 495
 496         if (NULL == msg) {
 497                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get supported voices : Fail to make message");
 498                 if (dbus_error_is_set(&err))
 499                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 500
 501                 return TTS_ERROR_OPERATION_FAILED;
 502         } else {
 503                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get supported voices : 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         DBusMessageIter args;
 515         int result = TTS_ERROR_OPERATION_FAILED;
 516
 517         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err );
 518         dbus_message_unref(msg);
 519
 520         if (dbus_error_is_set(&err)) {
 521                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 522                 printf("result message : %p\n", result_msg);
 523         }
 524
 525         if (NULL != result_msg) {
 526                 if (dbus_message_iter_init(result_msg, &args)) {
 527                         /* Get result */
 528                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 529                                 dbus_message_iter_get_basic(&args, &result);
 530                                 dbus_message_iter_next(&args);
 531                         }
 532
 533                         if (0 == result) {
 534                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 535
 536                                 int size ;
 537                                 char* temp_char;
 538                                 int temp_int;
 539
 540                                 /* Get voice size */
 541                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 542                                         dbus_message_iter_get_basic(&args, &size);
 543                                         dbus_message_iter_next(&args);
 544                                 }
 545
 546                                 if (0 >= size) {
 547                                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts size of voice error : size = %d \n", size);
 548                                 } else {
 549                                         int i=0;
 550                                         for (i=0 ; i<size ; i++) {
 551                                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 552                                                 dbus_message_iter_next(&args);
 553                                                 dbus_message_iter_get_basic(&args, &(temp_int) );
 554                                                 dbus_message_iter_next(&args);
 555
 556                                                 if (true != callback(tts, temp_char, (tts_voice_type_e)temp_int, user_data)) {
 557                                                         break;
 558                                                 }
 559                                         }
 560                                 }
 561                         } else {
 562                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 563                         }
 564                 } else  {
 565                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result message is invalid \n");
 566                         result = TTS_ERROR_OPERATION_FAILED;
 567                 }
 568                 dbus_message_unref(result_msg);
 569         } else {
 570                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL");
 571                 if (dbus_error_is_set(&err))
 572                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 573                 tts_dbus_reconnect();
 574         }
 575
 576         return result;
 577 }
 578
 579 int tts_dbus_request_get_default_voice(int uid , char** lang, tts_voice_type_e* vctype)
 580 {
 581         if (NULL == lang || NULL == vctype) {
 582                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 583                 return TTS_ERROR_INVALID_PARAMETER;
 584         }
 585
 586         DBusMessage* msg;
 587         DBusError err;
 588         dbus_error_init(&err);
 589
 590         msg = dbus_message_new_method_call(
 591                 TTS_SERVER_SERVICE_NAME,
 592                 TTS_SERVER_SERVICE_OBJECT_PATH,
 593                 TTS_SERVER_SERVICE_INTERFACE,
 594                 TTS_METHOD_GET_CURRENT_VOICE);
 595
 596         if (NULL == msg) {
 597                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get default voice : Fail to make message");
 598                 if (dbus_error_is_set(&err))
 599                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 600
 601                 return TTS_ERROR_OPERATION_FAILED;
 602         } else {
 603                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get default voice : uid(%d)", uid);
 604         }
 605
 606         if (true != dbus_message_append_args( msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 607                 dbus_message_unref(msg);
 608                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 609
 610                 return TTS_ERROR_OPERATION_FAILED;
 611         }
 612
 613         DBusMessage* result_msg;
 614         int result = TTS_ERROR_OPERATION_FAILED;
 615         char* temp_lang;
 616         int voice_type;
 617
 618         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 619         dbus_message_unref(msg);
 620
 621         if (dbus_error_is_set(&err)) {
 622                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 623                 printf("result message : %p\n", result_msg);
 624         }
 625
 626         if (NULL != result_msg) {
 627                 dbus_message_get_args(result_msg, &err,
 628                         DBUS_TYPE_INT32, &result,
 629                         DBUS_TYPE_STRING, &temp_lang,
 630                         DBUS_TYPE_INT32, &voice_type,
 631                         DBUS_TYPE_INVALID);
 632
 633                 if (dbus_error_is_set(&err)) {
 634                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 635                         dbus_error_free(&err);
 636                         result = TTS_ERROR_OPERATION_FAILED;
 637                 }
 638                 dbus_message_unref(result_msg);
 639         } else {
 640                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 641                 if (dbus_error_is_set(&err))
 642                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 643                 tts_dbus_reconnect();
 644         }
 645
 646         if (0 == result) {
 647                 *lang = strdup(temp_lang);
 648                 *vctype = (tts_voice_type_e)voice_type;
 649
 650                 if (NULL == *lang) {
 651                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : Out of memory \n");
 652                         result = TTS_ERROR_OUT_OF_MEMORY;
 653                 } else {
 654                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get default voice : result(%d), lang(%s), vctype(%d) \n", result, *lang, *vctype);
 655                 }
 656         } else {
 657                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : result(%d) \n", result);
 658         }
 659
 660         return result;
 661 }
 662
 663
 664 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid)
 665 {
 666         if (NULL == text || NULL == lang) {
 667                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 668                 return TTS_ERROR_INVALID_PARAMETER;
 669         }
 670
 671         DBusMessage* msg;
 672         DBusError err;
 673         dbus_error_init(&err);
 674
 675         msg = dbus_message_new_method_call(
 676                 TTS_SERVER_SERVICE_NAME,
 677                 TTS_SERVER_SERVICE_OBJECT_PATH,
 678                 TTS_SERVER_SERVICE_INTERFACE,
 679                 TTS_METHOD_ADD_QUEUE);
 680
 681         if (NULL == msg) {
 682                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 683                 if (dbus_error_is_set(&err))
 684                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 685
 686                 return TTS_ERROR_OPERATION_FAILED;
 687         } else {
 688                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d)",
 689                         uid, text, lang, vctype, speed, uttid);
 690         }
 691
 692         if (true != dbus_message_append_args( msg,
 693                 DBUS_TYPE_INT32, &uid,
 694                 DBUS_TYPE_STRING, &text,
 695                 DBUS_TYPE_STRING, &lang,
 696                 DBUS_TYPE_INT32, &vctype,
 697                 DBUS_TYPE_INT32, &speed,
 698                 DBUS_TYPE_INT32, &uttid,
 699                 DBUS_TYPE_INVALID)) {
 700                 dbus_message_unref(msg);
 701                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 702
 703                 return TTS_ERROR_OPERATION_FAILED;
 704         }
 705
 706         DBusMessage* result_msg;
 707         int result = TTS_ERROR_OPERATION_FAILED;
 708
 709         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 710         dbus_message_unref(msg);
 711
 712         if (dbus_error_is_set(&err))
 713                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 714
 715         if (NULL != result_msg) {
 716                 dbus_message_get_args(result_msg, &err,
 717                         DBUS_TYPE_INT32, &result,
 718                         DBUS_TYPE_INVALID);
 719
 720                 if (dbus_error_is_set(&err)) {
 721                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)\n", err.message);
 722                         dbus_error_free(&err);
 723                         result = TTS_ERROR_OPERATION_FAILED;
 724                 }
 725                 dbus_message_unref(result_msg);
 726         } else {
 727                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 728                 if (dbus_error_is_set(&err))
 729                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 730                 tts_dbus_reconnect();
 731         }
 732
 733         if (0 == result) {
 734                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 735         } else {
 736                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 737         }
 738
 739         return result;
 740 }
 741
 742 int tts_dbus_request_play(int uid)
 743 {
 744         DBusMessage* msg;
 745         DBusError err;
 746         dbus_error_init(&err);
 747
 748         msg = dbus_message_new_method_call(
 749                 TTS_SERVER_SERVICE_NAME,
 750                 TTS_SERVER_SERVICE_OBJECT_PATH,
 751                 TTS_SERVER_SERVICE_INTERFACE,
 752                 TTS_METHOD_PLAY );
 753
 754         if (NULL == msg) {
 755                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 756                 if (dbus_error_is_set(&err))
 757                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 758
 759                 return TTS_ERROR_OPERATION_FAILED;
 760         } else {
 761                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 762         }
 763
 764         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 765                 dbus_message_unref(msg);
 766                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 767
 768                 return TTS_ERROR_OPERATION_FAILED;
 769         }
 770
 771         DBusMessage* result_msg;
 772         int result = TTS_ERROR_OPERATION_FAILED;
 773
 774         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 775         dbus_message_unref(msg);
 776
 777         if (dbus_error_is_set(&err))
 778                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 779
 780         if (NULL != result_msg) {
 781                 dbus_message_get_args(result_msg, &err,
 782                         DBUS_TYPE_INT32, &result,
 783                         DBUS_TYPE_INVALID);
 784
 785                 if (dbus_error_is_set(&err)) {
 786                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)\n", err.message);
 787                         dbus_error_free(&err);
 788                         result = TTS_ERROR_OPERATION_FAILED;
 789                 }
 790                 dbus_message_unref(result_msg);
 791         } else {
 792                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 793                 if (dbus_error_is_set(&err))
 794                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 795                 tts_dbus_reconnect();
 796         }
 797
 798         if (0 == result) {
 799                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 800         } else {
 801                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 802         }
 803
 804         return result;
 805 }
 806
 807
 808 int tts_dbus_request_stop(int uid)
 809 {
 810         DBusMessage* msg;
 811         DBusError err;
 812         dbus_error_init(&err);
 813
 814         msg = dbus_message_new_method_call(
 815                 TTS_SERVER_SERVICE_NAME,
 816                 TTS_SERVER_SERVICE_OBJECT_PATH,
 817                 TTS_SERVER_SERVICE_INTERFACE,
 818                 TTS_METHOD_STOP);
 819
 820         if (NULL == msg) {
 821                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 822                 if (dbus_error_is_set(&err))
 823                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 824
 825                 return TTS_ERROR_OPERATION_FAILED;
 826         } else {
 827                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 828         }
 829
 830         DBusMessage* result_msg;
 831         int result = TTS_ERROR_OPERATION_FAILED;
 832
 833         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 834                 dbus_message_unref(msg);
 835                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 836
 837                 return TTS_ERROR_OPERATION_FAILED;
 838         }
 839
 840         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 841         dbus_message_unref(msg);
 842
 843         if (dbus_error_is_set(&err))
 844                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 845
 846         if (NULL != result_msg) {
 847                 dbus_message_get_args(result_msg, &err,
 848                         DBUS_TYPE_INT32, &result,
 849                         DBUS_TYPE_INVALID);
 850
 851                 if (dbus_error_is_set(&err)) {
 852                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)\n", err.message);
 853                         dbus_error_free(&err);
 854                         result = TTS_ERROR_OPERATION_FAILED;
 855                 }
 856                 dbus_message_unref(result_msg);
 857         } else {
 858                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 859                 if (dbus_error_is_set(&err))
 860                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 861                 tts_dbus_reconnect();
 862         }
 863
 864         if (0 == result) {
 865                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 866         } else {
 867                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 868         }
 869
 870         return result;
 871 }
 872
 873 int tts_dbus_request_pause(int uid)
 874 {
 875         DBusMessage* msg;
 876         DBusError err;
 877         dbus_error_init(&err);
 878
 879         msg = dbus_message_new_method_call(
 880                 TTS_SERVER_SERVICE_NAME,
 881                 TTS_SERVER_SERVICE_OBJECT_PATH,
 882                 TTS_SERVER_SERVICE_INTERFACE,
 883                 TTS_METHOD_PAUSE);
 884
 885         if (NULL == msg) {
 886                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 887                 if (dbus_error_is_set(&err))
 888                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 889
 890                 return TTS_ERROR_OPERATION_FAILED;
 891         } else {
 892                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 893         }
 894
 895         DBusMessage* result_msg;
 896         int result = TTS_ERROR_OPERATION_FAILED;
 897
 898         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 899                 dbus_message_unref(msg);
 900                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 901
 902                 return TTS_ERROR_OPERATION_FAILED;
 903         }
 904
 905         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 906         dbus_message_unref(msg);
 907
 908         if (dbus_error_is_set(&err))
 909                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 910
 911         if (NULL != result_msg) {
 912                 dbus_message_get_args(result_msg, &err,
 913                         DBUS_TYPE_INT32, &result,
 914                         DBUS_TYPE_INVALID);
 915
 916                 if (dbus_error_is_set(&err)) {
 917                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)\n", err.message);
 918                         dbus_error_free(&err);
 919                         result = TTS_ERROR_OPERATION_FAILED;
 920                 }
 921                 dbus_message_unref(result_msg);
 922         } else {
 923                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 924                 if (dbus_error_is_set(&err))
 925                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 926                 tts_dbus_reconnect();
 927         }
 928
 929         if (0 == result) {
 930                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 931         } else {
 932                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 933         }
 934
 935         return result;
 936 }