client/tts_dbus.c

   1 /*
   2 *  Copyright (c) 2012 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         } else {
 329                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts hello");
 330         }
 331
 332         DBusError err;
 333         dbus_error_init(&err);
 334
 335         DBusMessage* result_msg = NULL;
 336         int result = 0;
 337
 338         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 339
 340         dbus_message_unref(msg);
 341
 342         if (NULL != result_msg) {
 343                 dbus_message_unref(result_msg);
 344
 345                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts hello");
 346                 result = 0;
 347         } else {
 348                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts hello : no response");
 349                 result = TTS_ERROR_OPERATION_FAILED;
 350         }
 351
 352         return result;
 353 }
 354
 355 int tts_dbus_request_initialize(int uid)
 356 {
 357         DBusMessage* msg;
 358         DBusError err;
 359         dbus_error_init(&err);
 360
 361         msg = dbus_message_new_method_call(
 362                 TTS_SERVER_SERVICE_NAME,
 363                 TTS_SERVER_SERVICE_OBJECT_PATH,
 364                 TTS_SERVER_SERVICE_INTERFACE,
 365                 TTS_METHOD_INITIALIZE);
 366
 367         if (NULL == msg) {
 368                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message \n");
 369                 if (dbus_error_is_set(&err))
 370                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 371
 372                 return TTS_ERROR_OPERATION_FAILED;
 373         } else {
 374                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 375         }
 376
 377         int pid = getpid();
 378         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &pid, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 379                 dbus_message_unref(msg);
 380                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 381
 382                 return TTS_ERROR_OPERATION_FAILED;
 383         }
 384
 385         DBusMessage* result_msg;
 386         int result = TTS_ERROR_OPERATION_FAILED;
 387
 388         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, INIT_WAITING_TIME, &err);
 389         dbus_message_unref(msg);
 390
 391         if (dbus_error_is_set(&err))
 392                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 393
 394         if (NULL != result_msg) {
 395                 dbus_message_get_args(result_msg, &err,
 396                                   DBUS_TYPE_INT32, &result,
 397                                   DBUS_TYPE_INVALID);
 398
 399                 if (dbus_error_is_set(&err)) {
 400                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 401                         dbus_error_free(&err);
 402                         result = TTS_ERROR_OPERATION_FAILED;
 403                 }
 404
 405                 dbus_message_unref(result_msg);
 406         } else {
 407                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 408                 if (dbus_error_is_set(&err))
 409                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 410                 tts_dbus_reconnect();
 411         }
 412
 413         if (0 == result) {
 414                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 415         } else {
 416                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 417         }
 418
 419         return result;
 420 }
 421
 422
 423 int tts_dbus_request_finalize(int uid)
 424 {
 425         DBusMessage* msg;
 426         DBusError err;
 427         dbus_error_init(&err);
 428
 429         msg = dbus_message_new_method_call(
 430                 TTS_SERVER_SERVICE_NAME,
 431                 TTS_SERVER_SERVICE_OBJECT_PATH,
 432                 TTS_SERVER_SERVICE_INTERFACE,
 433                 TTS_METHOD_FINALIZE);
 434
 435         if (NULL == msg) {
 436                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message");
 437                 if (dbus_error_is_set(&err))
 438                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 439
 440                 return TTS_ERROR_OPERATION_FAILED;
 441         } else {
 442                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 443         }
 444
 445         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 446                 dbus_message_unref(msg);
 447                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 448
 449                 return TTS_ERROR_OPERATION_FAILED;
 450         }
 451
 452         DBusMessage* result_msg;
 453         int result = TTS_ERROR_OPERATION_FAILED;
 454
 455         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 456         dbus_message_unref(msg);
 457
 458         if (dbus_error_is_set(&err))
 459                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 460
 461         if (NULL != result_msg) {
 462                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 463
 464                 if (dbus_error_is_set(&err)) {
 465                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 466                         dbus_error_free(&err);
 467                         result = TTS_ERROR_OPERATION_FAILED;
 468                 }
 469
 470                 dbus_message_unref(result_msg);
 471         } else {
 472                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 473                 if (dbus_error_is_set(&err))
 474                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 475                 tts_dbus_reconnect();
 476         }
 477
 478         if (0 == result) {
 479                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 480         } else {
 481                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 482         }
 483
 484         return result;
 485 }
 486
 487 int tts_dbus_request_get_support_voice(int uid, tts_h tts, tts_supported_voice_cb callback, void* user_data)
 488 {
 489         DBusMessage* msg;
 490         DBusError err;
 491         dbus_error_init(&err);
 492
 493         msg = dbus_message_new_method_call(
 494                 TTS_SERVER_SERVICE_NAME,
 495                 TTS_SERVER_SERVICE_OBJECT_PATH,
 496                 TTS_SERVER_SERVICE_INTERFACE,
 497                 TTS_METHOD_GET_SUPPORT_VOICES);
 498
 499         if (NULL == msg) {
 500                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get supported voices : Fail to make message");
 501                 if (dbus_error_is_set(&err))
 502                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 503
 504                 return TTS_ERROR_OPERATION_FAILED;
 505         } else {
 506                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get supported voices : uid(%d)", uid);
 507         }
 508
 509         if (true != dbus_message_append_args( msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 510                 dbus_message_unref(msg);
 511                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 512
 513                 return TTS_ERROR_OPERATION_FAILED;
 514         }
 515
 516         DBusMessage* result_msg;
 517         DBusMessageIter args;
 518         int result = TTS_ERROR_OPERATION_FAILED;
 519
 520         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err );
 521         dbus_message_unref(msg);
 522
 523         if (dbus_error_is_set(&err)) {
 524                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 525                 printf("result message : %p\n", result_msg);
 526         }
 527
 528         if (NULL != result_msg) {
 529                 if (dbus_message_iter_init(result_msg, &args)) {
 530                         /* Get result */
 531                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 532                                 dbus_message_iter_get_basic(&args, &result);
 533                                 dbus_message_iter_next(&args);
 534                         }
 535
 536                         if (0 == result) {
 537                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 538
 539                                 int size ;
 540                                 char* temp_char;
 541                                 int temp_int;
 542
 543                                 /* Get voice size */
 544                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 545                                         dbus_message_iter_get_basic(&args, &size);
 546                                         dbus_message_iter_next(&args);
 547                                 }
 548
 549                                 if (0 >= size) {
 550                                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts size of voice error : size = %d \n", size);
 551                                 } else {
 552                                         int i=0;
 553                                         for (i=0 ; i<size ; i++) {
 554                                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 555                                                 dbus_message_iter_next(&args);
 556                                                 dbus_message_iter_get_basic(&args, &(temp_int) );
 557                                                 dbus_message_iter_next(&args);
 558
 559                                                 if (true != callback(tts, temp_char, (tts_voice_type_e)temp_int, user_data)) {
 560                                                         break;
 561                                                 }
 562                                         }
 563                                 }
 564                         } else {
 565                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 566                         }
 567                 } else  {
 568                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result message is invalid \n");
 569                         result = TTS_ERROR_OPERATION_FAILED;
 570                 }
 571                 dbus_message_unref(result_msg);
 572         } else {
 573                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL");
 574                 if (dbus_error_is_set(&err))
 575                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 576                 tts_dbus_reconnect();
 577         }
 578
 579         return result;
 580 }
 581
 582 int tts_dbus_request_get_default_voice(int uid , char** lang, tts_voice_type_e* vctype)
 583 {
 584         if (NULL == lang || NULL == vctype) {
 585                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 586                 return TTS_ERROR_INVALID_PARAMETER;
 587         }
 588
 589         DBusMessage* msg;
 590         DBusError err;
 591         dbus_error_init(&err);
 592
 593         msg = dbus_message_new_method_call(
 594                 TTS_SERVER_SERVICE_NAME,
 595                 TTS_SERVER_SERVICE_OBJECT_PATH,
 596                 TTS_SERVER_SERVICE_INTERFACE,
 597                 TTS_METHOD_GET_CURRENT_VOICE);
 598
 599         if (NULL == msg) {
 600                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get default voice : Fail to make message");
 601                 if (dbus_error_is_set(&err))
 602                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 603
 604                 return TTS_ERROR_OPERATION_FAILED;
 605         } else {
 606                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get default voice : uid(%d)", uid);
 607         }
 608
 609         if (true != dbus_message_append_args( msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 610                 dbus_message_unref(msg);
 611                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 612
 613                 return TTS_ERROR_OPERATION_FAILED;
 614         }
 615
 616         DBusMessage* result_msg;
 617         int result = TTS_ERROR_OPERATION_FAILED;
 618         char* temp_lang;
 619         int voice_type;
 620
 621         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, WAITING_TIME, &err);
 622         dbus_message_unref(msg);
 623
 624         if (dbus_error_is_set(&err)) {
 625                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 626                 printf("result message : %p\n", result_msg);
 627         }
 628
 629         if (NULL != result_msg) {
 630                 dbus_message_get_args(result_msg, &err,
 631                         DBUS_TYPE_INT32, &result,
 632                         DBUS_TYPE_STRING, &temp_lang,
 633                         DBUS_TYPE_INT32, &voice_type,
 634                         DBUS_TYPE_INVALID);
 635
 636                 if (dbus_error_is_set(&err)) {
 637                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 638                         dbus_error_free(&err);
 639                         result = TTS_ERROR_OPERATION_FAILED;
 640                 }
 641                 dbus_message_unref(result_msg);
 642         } else {
 643                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 644                 if (dbus_error_is_set(&err))
 645                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 646                 tts_dbus_reconnect();
 647         }
 648
 649         if (0 == result) {
 650                 *lang = strdup(temp_lang);
 651                 *vctype = (tts_voice_type_e)voice_type;
 652
 653                 if (NULL == *lang) {
 654                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : Out of memory \n");
 655                         result = TTS_ERROR_OUT_OF_MEMORY;
 656                 } else {
 657                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get default voice : result(%d), lang(%s), vctype(%d) \n", result, *lang, *vctype);
 658                 }
 659         } else {
 660                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : result(%d) \n", result);
 661         }
 662
 663         return result;
 664 }
 665
 666
 667 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid)
 668 {
 669         if (NULL == text || NULL == lang) {
 670                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 671                 return TTS_ERROR_INVALID_PARAMETER;
 672         }
 673
 674         DBusMessage* msg;
 675         DBusError err;
 676         dbus_error_init(&err);
 677
 678         msg = dbus_message_new_method_call(
 679                 TTS_SERVER_SERVICE_NAME,
 680                 TTS_SERVER_SERVICE_OBJECT_PATH,
 681                 TTS_SERVER_SERVICE_INTERFACE,
 682                 TTS_METHOD_ADD_QUEUE);
 683
 684         if (NULL == msg) {
 685                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message");
 686                 if (dbus_error_is_set(&err))
 687                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 688
 689                 return TTS_ERROR_OPERATION_FAILED;
 690         } else {
 691                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d)",
 692                         uid, text, lang, vctype, speed, uttid);
 693         }
 694
 695         if (true != dbus_message_append_args( msg,
 696                 DBUS_TYPE_INT32, &uid,
 697                 DBUS_TYPE_STRING, &text,
 698                 DBUS_TYPE_STRING, &lang,
 699                 DBUS_TYPE_INT32, &vctype,
 700                 DBUS_TYPE_INT32, &speed,
 701                 DBUS_TYPE_INT32, &uttid,
 702                 DBUS_TYPE_INVALID)) {
 703                 dbus_message_unref(msg);
 704                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 705
 706                 return TTS_ERROR_OPERATION_FAILED;
 707         }
 708
 709         DBusMessage* result_msg;
 710         int result = TTS_ERROR_OPERATION_FAILED;
 711
 712         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 713         dbus_message_unref(msg);
 714
 715         if (dbus_error_is_set(&err))
 716                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 717
 718         if (NULL != result_msg) {
 719                 dbus_message_get_args(result_msg, &err,
 720                         DBUS_TYPE_INT32, &result,
 721                         DBUS_TYPE_INVALID);
 722
 723                 if (dbus_error_is_set(&err)) {
 724                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)\n", err.message);
 725                         dbus_error_free(&err);
 726                         result = TTS_ERROR_OPERATION_FAILED;
 727                 }
 728                 dbus_message_unref(result_msg);
 729         } else {
 730                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 731                 if (dbus_error_is_set(&err))
 732                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 733                 tts_dbus_reconnect();
 734         }
 735
 736         if (0 == result) {
 737                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 738         } else {
 739                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 740         }
 741
 742         return result;
 743 }
 744
 745 int tts_dbus_request_play(int uid)
 746 {
 747         DBusMessage* msg;
 748         DBusError err;
 749         dbus_error_init(&err);
 750
 751         msg = dbus_message_new_method_call(
 752                 TTS_SERVER_SERVICE_NAME,
 753                 TTS_SERVER_SERVICE_OBJECT_PATH,
 754                 TTS_SERVER_SERVICE_INTERFACE,
 755                 TTS_METHOD_PLAY );
 756
 757         if (NULL == msg) {
 758                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message");
 759                 if (dbus_error_is_set(&err))
 760                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 761
 762                 return TTS_ERROR_OPERATION_FAILED;
 763         } else {
 764                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 765         }
 766
 767         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 768                 dbus_message_unref(msg);
 769                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 770
 771                 return TTS_ERROR_OPERATION_FAILED;
 772         }
 773
 774         DBusMessage* result_msg;
 775         int result = TTS_ERROR_OPERATION_FAILED;
 776
 777         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 778         dbus_message_unref(msg);
 779
 780         if (dbus_error_is_set(&err))
 781                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 782
 783         if (NULL != result_msg) {
 784                 dbus_message_get_args(result_msg, &err,
 785                         DBUS_TYPE_INT32, &result,
 786                         DBUS_TYPE_INVALID);
 787
 788                 if (dbus_error_is_set(&err)) {
 789                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)\n", err.message);
 790                         dbus_error_free(&err);
 791                         result = TTS_ERROR_OPERATION_FAILED;
 792                 }
 793                 dbus_message_unref(result_msg);
 794         } else {
 795                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 796                 if (dbus_error_is_set(&err))
 797                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 798                 tts_dbus_reconnect();
 799         }
 800
 801         if (0 == result) {
 802                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 803         } else {
 804                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 805         }
 806
 807         return result;
 808 }
 809
 810
 811 int tts_dbus_request_stop(int uid)
 812 {
 813         DBusMessage* msg;
 814         DBusError err;
 815         dbus_error_init(&err);
 816
 817         msg = dbus_message_new_method_call(
 818                 TTS_SERVER_SERVICE_NAME,
 819                 TTS_SERVER_SERVICE_OBJECT_PATH,
 820                 TTS_SERVER_SERVICE_INTERFACE,
 821                 TTS_METHOD_STOP);
 822
 823         if (NULL == msg) {
 824                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message");
 825                 if (dbus_error_is_set(&err))
 826                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 827
 828                 return TTS_ERROR_OPERATION_FAILED;
 829         } else {
 830                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 831         }
 832
 833         DBusMessage* result_msg;
 834         int result = TTS_ERROR_OPERATION_FAILED;
 835
 836         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 837                 dbus_message_unref(msg);
 838                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 839
 840                 return TTS_ERROR_OPERATION_FAILED;
 841         }
 842
 843         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 844         dbus_message_unref(msg);
 845
 846         if (dbus_error_is_set(&err))
 847                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 848
 849         if (NULL != result_msg) {
 850                 dbus_message_get_args(result_msg, &err,
 851                         DBUS_TYPE_INT32, &result,
 852                         DBUS_TYPE_INVALID);
 853
 854                 if (dbus_error_is_set(&err)) {
 855                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)\n", err.message);
 856                         dbus_error_free(&err);
 857                         result = TTS_ERROR_OPERATION_FAILED;
 858                 }
 859                 dbus_message_unref(result_msg);
 860         } else {
 861                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 862                 if (dbus_error_is_set(&err))
 863                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 864                 tts_dbus_reconnect();
 865         }
 866
 867         if (0 == result) {
 868                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 869         } else {
 870                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 871         }
 872
 873         return result;
 874 }
 875
 876 int tts_dbus_request_pause(int uid)
 877 {
 878         DBusMessage* msg;
 879         DBusError err;
 880         dbus_error_init(&err);
 881
 882         msg = dbus_message_new_method_call(
 883                 TTS_SERVER_SERVICE_NAME,
 884                 TTS_SERVER_SERVICE_OBJECT_PATH,
 885                 TTS_SERVER_SERVICE_INTERFACE,
 886                 TTS_METHOD_PAUSE);
 887
 888         if (NULL == msg) {
 889                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message");
 890                 if (dbus_error_is_set(&err))
 891                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 892
 893                 return TTS_ERROR_OPERATION_FAILED;
 894         } else {
 895                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 896         }
 897
 898         DBusMessage* result_msg;
 899         int result = TTS_ERROR_OPERATION_FAILED;
 900
 901         if (true != dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID)) {
 902                 dbus_message_unref(msg);
 903                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to append args");
 904
 905                 return TTS_ERROR_OPERATION_FAILED;
 906         }
 907
 908         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 909         dbus_message_unref(msg);
 910
 911         if (dbus_error_is_set(&err))
 912                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 913
 914         if (NULL != result_msg) {
 915                 dbus_message_get_args(result_msg, &err,
 916                         DBUS_TYPE_INT32, &result,
 917                         DBUS_TYPE_INVALID);
 918
 919                 if (dbus_error_is_set(&err)) {
 920                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)\n", err.message);
 921                         dbus_error_free(&err);
 922                         result = TTS_ERROR_OPERATION_FAILED;
 923                 }
 924                 dbus_message_unref(result_msg);
 925         } else {
 926                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 927                 if (dbus_error_is_set(&err))
 928                         SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] %s", err.message);
 929                 tts_dbus_reconnect();
 930         }
 931
 932         if (0 == result) {
 933                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 934         } else {
 935                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 936         }
 937
 938         return result;
 939 }