client/tts_dbus.c

   1 /*
   2 * Copyright (c) 2011 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
  20
  21 static Ecore_Fd_Handler* g_fd_handler = NULL;
  22
  23 static DBusConnection* g_conn = NULL;
  24
  25
  26 extern int __tts_cb_error(int uid, tts_error_e reason, int utt_id);
  27
  28 extern int __tts_cb_interrupt(int uid, tts_interrupted_code_e code);
  29
  30 extern int __tts_cb_utt_started(int uid, int utt_id);
  31
  32 extern int __tts_cb_utt_completed(int uid, int utt_id);
  33
  34
  35 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  36 {
  37         DBusConnection* conn = (DBusConnection*)data;
  38
  39         if (NULL == conn)       return ECORE_CALLBACK_RENEW;
  40
  41         dbus_connection_read_write_dispatch(conn, 50);
  42
  43         DBusMessage* msg = NULL;
  44         msg = dbus_connection_pop_message(conn);
  45
  46         /* loop again if we haven't read a message */
  47         if (NULL == msg) {
  48                 return ECORE_CALLBACK_RENEW;
  49         }
  50
  51         DBusError err;
  52         dbus_error_init(&err);
  53
  54         char if_name[64];
  55         snprintf(if_name, 64, "%s%d", TTS_CLIENT_SERVICE_INTERFACE, getpid());
  56
  57         /* check if the message is a signal from the correct interface and with the correct name */
  58         if (dbus_message_is_signal(msg, if_name, TTS_SIGNAL_UTTERANCE_STARTED)) {
  59                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance started");
  60                 int uid, uttid;
  61                 dbus_message_get_args(msg, &err,
  62                         DBUS_TYPE_INT32, &uid,
  63                         DBUS_TYPE_INT32, &uttid,
  64                         DBUS_TYPE_INVALID);
  65
  66                 if (dbus_error_is_set(&err)) {
  67                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance started - Get arguments error (%s)\n", err.message);
  68                         dbus_error_free(&err);
  69                 } else {
  70                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance started signal : uid(%d), uttid(%d) \n", uid, uttid);
  71                         __tts_cb_utt_started(uid, uttid);
  72                 }
  73                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  74                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  75         }/* TTS_SIGNAL_UTTERANCE_STARTED */
  76
  77         else if (dbus_message_is_signal(msg, if_name, TTS_SIGNAL_UTTERANCE_COMPLETED)) {
  78                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get utterance completed");
  79                 int uid, uttid;
  80                 dbus_message_get_args(msg, &err,
  81                         DBUS_TYPE_INT32, &uid,
  82                         DBUS_TYPE_INT32, &uttid,
  83                         DBUS_TYPE_INVALID);
  84
  85                 if (dbus_error_is_set(&err)) {
  86                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Utterance completed - Get arguments error (%s)\n", err.message);
  87                         dbus_error_free(&err);
  88                 } else {
  89                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Utterance completed signal : uid(%d), uttid(%d) \n", uid, uttid);
  90                         __tts_cb_utt_completed(uid, uttid);
  91                 }
  92                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
  93                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
  94         }/* TTS_SIGNAL_UTTERANCE_COMPLETED */
  95
  96         else if (dbus_message_is_signal(msg, if_name, TTS_SIGNAL_INTERRUPT)) {
  97                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get interrupt callback");
  98                 int uid;
  99                 int code;
 100                 dbus_message_get_args(msg, &err,
 101                         DBUS_TYPE_INT32, &uid,
 102                         DBUS_TYPE_INT32, &code,
 103                         DBUS_TYPE_INVALID);
 104
 105                 if (dbus_error_is_set(&err)) {
 106                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Stop signal - Get arguments error (%s)\n", err.message);
 107                         dbus_error_free(&err);
 108                 } else {
 109                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Interrupt signal : uid(%d) , interrupt code(%d)\n", uid, code);
 110                         __tts_cb_interrupt(uid, (tts_interrupted_code_e)code);
 111                 }
 112                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 113                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 114         } /* TTS_SIGNAL_INTERRUPT */
 115
 116         else if (dbus_message_is_signal(msg, if_name, TTS_SIGNAL_ERROR)) {
 117                 SLOG(LOG_DEBUG, TAG_TTSC, "===== Get error callback");
 118
 119                 int uid;
 120                 int uttid;
 121                 int reason;
 122
 123                 dbus_message_get_args(msg, &err,
 124                         DBUS_TYPE_INT32, &uid,
 125                         DBUS_TYPE_INT32, &uttid,
 126                         DBUS_TYPE_INT32, &reason,
 127                         DBUS_TYPE_INVALID);
 128
 129                 if (dbus_error_is_set(&err)) {
 130                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get Error signal - Get arguments error (%s)\n", err.message);
 131                         dbus_error_free(&err);
 132                 } else {
 133                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< Get Error signal : uid(%d), error(%d), uttid(%d)\n", uid, reason, uttid);
 134                         __tts_cb_error(uid, reason, uttid);
 135                 }
 136                 SLOG(LOG_DEBUG, TAG_TTSC, "=====");
 137                 SLOG(LOG_DEBUG, TAG_TTSC, " ");
 138         }/* TTS_SIGNAL_ERROR */
 139
 140         /* free the message */
 141         dbus_message_unref(msg);
 142
 143         return ECORE_CALLBACK_PASS_ON;
 144 }
 145
 146
 147 int tts_dbus_open_connection()
 148 {
 149         if (NULL != g_conn) {
 150                 SLOG(LOG_WARN, TAG_TTSC, "already existed connection ");
 151                 return 0;
 152         }
 153
 154         DBusError err;
 155         int ret;
 156
 157         /* initialise the error value */
 158         dbus_error_init(&err);
 159
 160         /* connect to the DBUS system bus, and check for errors */
 161         g_conn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
 162
 163         if (dbus_error_is_set(&err)) {
 164                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Dbus Connection Error (%s)\n", err.message);
 165                 dbus_error_free(&err);
 166         }
 167
 168         if (NULL == g_conn) {
 169                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] fail to get dbus connection \n");
 170                 return TTS_ERROR_OPERATION_FAILED;
 171         }
 172
 173         int pid = getpid();
 174
 175         char service_name[64];
 176         memset(service_name, 0, 64);
 177         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 178
 179         SLOG(LOG_DEBUG, TAG_TTSC, "Service name is %s\n", service_name);
 180
 181         /* register our name on the bus, and check for errors */
 182         ret = dbus_bus_request_name(g_conn, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 183
 184         if (dbus_error_is_set(&err)) {
 185                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Name Error (%s)\n", err.message);
 186                 dbus_error_free(&err);
 187         }
 188
 189         if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
 190                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to open connection : Service name has already been existed. \n");
 191                 return TTS_ERROR_OPERATION_FAILED;
 192         }
 193
 194         char rule[128];
 195         snprintf(rule, 128, "type='signal',interface='%s%d'", TTS_CLIENT_SERVICE_INTERFACE, pid);
 196
 197         /* add a rule for which messages we want to see */
 198         dbus_bus_add_match(g_conn, rule, &err);
 199         dbus_connection_flush(g_conn);
 200
 201         if (dbus_error_is_set(&err)) {
 202                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Match Error (%s)\n", err.message);
 203                 return TTS_ERROR_OPERATION_FAILED;
 204         }
 205
 206         int fd = 0;
 207         dbus_connection_get_unix_fd(g_conn, &fd);
 208
 209         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn, NULL, NULL);
 210
 211         if (NULL == g_fd_handler) {
 212                 SLOG(LOG_ERROR, TAG_TTSC, "[ERROR] Fail to get fd handler from ecore \n");
 213                 return TTS_ERROR_OPERATION_FAILED;
 214         }
 215
 216         return 0;
 217 }
 218
 219
 220 int tts_dbus_close_connection()
 221 {
 222         DBusError err;
 223         dbus_error_init(&err);
 224
 225         int pid = getpid();
 226
 227         char service_name[64];
 228         memset(service_name, 0, 64);
 229         snprintf(service_name, 64, "%s%d", TTS_CLIENT_SERVICE_NAME, pid);
 230
 231         dbus_bus_release_name (g_conn, service_name, &err);
 232
 233         g_conn = NULL;
 234
 235         return 0;
 236 }
 237
 238
 239 int tts_dbus_request_initialize(int uid)
 240 {
 241         DBusMessage* msg;
 242
 243         msg = dbus_message_new_method_call(
 244                 TTS_SERVER_SERVICE_NAME,
 245                 TTS_SERVER_SERVICE_OBJECT_PATH,
 246                 TTS_SERVER_SERVICE_INTERFACE,
 247                 TTS_METHOD_INITIALIZE);
 248
 249         if (NULL == msg) {
 250                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts initialize : Fail to make message \n");
 251                 return TTS_ERROR_OPERATION_FAILED;
 252         } else {
 253                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts initialize : uid(%d)", uid);
 254         }
 255
 256         int pid = getpid();
 257         dbus_message_append_args( msg,
 258                 DBUS_TYPE_INT32, &pid,
 259                 DBUS_TYPE_INT32, &uid,
 260                 DBUS_TYPE_INVALID);
 261
 262         DBusError err;
 263         dbus_error_init(&err);
 264
 265         DBusMessage* result_msg;
 266         int result = TTS_ERROR_OPERATION_FAILED;
 267
 268         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 269
 270         if (NULL != result_msg) {
 271                 dbus_message_get_args(result_msg, &err,
 272                                   DBUS_TYPE_INT32, &result,
 273                                   DBUS_TYPE_INVALID);
 274
 275                 if (dbus_error_is_set(&err)) {
 276                         SLOG(LOG_ERROR, TAG_TTSC, "Get arguments error (%s)\n", err.message);
 277                         dbus_error_free(&err);
 278                         result = TTS_ERROR_OPERATION_FAILED;
 279                 }
 280
 281                 dbus_message_unref(result_msg);
 282         } else {
 283                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 284         }
 285
 286         if (0 == result) {
 287                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 288         } else {
 289                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts initialize : result = %d \n", result);
 290         }
 291
 292         dbus_message_unref(msg);
 293
 294         return result;
 295 }
 296
 297
 298 int tts_dbus_request_finalize(int uid)
 299 {
 300         DBusMessage* msg;
 301
 302         msg = dbus_message_new_method_call(
 303                 TTS_SERVER_SERVICE_NAME,
 304                 TTS_SERVER_SERVICE_OBJECT_PATH,
 305                 TTS_SERVER_SERVICE_INTERFACE,
 306                 TTS_METHOD_FINALIZE);
 307
 308         if (NULL == msg) {
 309                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts finalize : Fail to make message \n");
 310                 return TTS_ERROR_OPERATION_FAILED;
 311         } else {
 312                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts finalize : uid(%d)", uid);
 313         }
 314
 315         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 316
 317         DBusError err;
 318         dbus_error_init(&err);
 319
 320         DBusMessage* result_msg;
 321         int result = TTS_ERROR_OPERATION_FAILED;
 322
 323         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 324
 325         if (NULL != result_msg) {
 326                 dbus_message_get_args(result_msg, &err, DBUS_TYPE_INT32, &result, DBUS_TYPE_INVALID);
 327
 328                 if (dbus_error_is_set(&err)) {
 329                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 330                         dbus_error_free(&err);
 331                         result = TTS_ERROR_OPERATION_FAILED;
 332                 }
 333
 334                 dbus_message_unref(result_msg);
 335         } else {
 336                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 337         }
 338
 339         if (0 == result) {
 340                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 341         } else {
 342                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts finalize : result = %d \n", result);
 343         }
 344
 345         dbus_message_unref(msg);
 346
 347         return result;
 348 }
 349
 350 int tts_dbus_request_get_support_voice(int uid, tts_h tts, tts_supported_voice_cb callback, void* user_data)
 351 {
 352         DBusMessage* msg;
 353
 354         msg = dbus_message_new_method_call(
 355                 TTS_SERVER_SERVICE_NAME,
 356                 TTS_SERVER_SERVICE_OBJECT_PATH,
 357                 TTS_SERVER_SERVICE_INTERFACE,
 358                 TTS_METHOD_GET_SUPPORT_VOICES);
 359
 360         if (NULL == msg) {
 361                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get supported voices : Fail to make message \n");
 362                 return TTS_ERROR_OPERATION_FAILED;
 363         } else {
 364                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get supported voices : uid(%d)", uid);
 365         }
 366
 367         dbus_message_append_args( msg,
 368                 DBUS_TYPE_INT32, &uid,
 369                 DBUS_TYPE_INVALID);
 370
 371         DBusError err;
 372         dbus_error_init(&err);
 373
 374         DBusMessage* result_msg;
 375         DBusMessageIter args;
 376         int result = TTS_ERROR_OPERATION_FAILED;
 377
 378         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err );
 379
 380         if (NULL != result_msg) {
 381                 if (dbus_message_iter_init(result_msg, &args)) {
 382                         /* Get result */
 383                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 384                                 dbus_message_iter_get_basic(&args, &result);
 385                                 dbus_message_iter_next(&args);
 386                         }
 387
 388                         if (0 == result) {
 389                                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 390
 391                                 int size ;
 392                                 char* temp_char;
 393                                 int temp_int;
 394
 395                                 /* Get voice size */
 396                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 397                                         dbus_message_iter_get_basic(&args, &size);
 398                                         dbus_message_iter_next(&args);
 399                                 }
 400
 401                                 if (0 >= size) {
 402                                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts size of voice error : size = %d \n", size);
 403                                 } else {
 404                                         int i=0;
 405                                         for (i=0 ; i<size ; i++) {
 406                                                 dbus_message_iter_get_basic(&args, &(temp_char) );
 407                                                 dbus_message_iter_next(&args);
 408                                                 dbus_message_iter_get_basic(&args, &(temp_int) );
 409                                                 dbus_message_iter_next(&args);
 410
 411                                                 if (true != callback(tts, temp_char, (tts_voice_type_e)temp_int, user_data)) {
 412                                                         break;
 413                                                 }
 414                                         }
 415                                 }
 416                         } else {
 417                                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result = %d \n", result);
 418                         }
 419                 } else  {
 420                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get supported voices : result message is invalid \n");
 421                         result = TTS_ERROR_OPERATION_FAILED;
 422                 }
 423                 dbus_message_unref(result_msg);
 424         } else {
 425                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL");
 426         }
 427
 428         dbus_message_unref(msg);
 429
 430         return result;
 431 }
 432
 433 int tts_dbus_request_get_default_voice(int uid , char** lang, tts_voice_type_e* vctype)
 434 {
 435         if (NULL == lang || NULL == vctype) {
 436                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 437                 return TTS_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         DBusMessage* msg;
 441
 442         msg = dbus_message_new_method_call(
 443                 TTS_SERVER_SERVICE_NAME,
 444                 TTS_SERVER_SERVICE_OBJECT_PATH,
 445                 TTS_SERVER_SERVICE_INTERFACE,
 446                 TTS_METHOD_GET_CURRENT_VOICE);
 447
 448         if (NULL == msg) {
 449                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts get default voice : Fail to make message \n");
 450                 return TTS_ERROR_OPERATION_FAILED;
 451         } else {
 452                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts get default voice : uid(%d)", uid);
 453         }
 454
 455         dbus_message_append_args( msg,
 456                 DBUS_TYPE_INT32, &uid,
 457                 DBUS_TYPE_INVALID);
 458
 459         DBusError err;
 460         dbus_error_init(&err);
 461
 462         DBusMessage* result_msg;
 463         int result = TTS_ERROR_OPERATION_FAILED;
 464         char* temp_lang;
 465         int voice_type;
 466
 467         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 3000, &err);
 468
 469         if (NULL != result_msg) {
 470                 dbus_message_get_args(result_msg, &err,
 471                         DBUS_TYPE_INT32, &result,
 472                         DBUS_TYPE_STRING, &temp_lang,
 473                         DBUS_TYPE_INT32, &voice_type,
 474                         DBUS_TYPE_INVALID);
 475
 476                 if (dbus_error_is_set(&err)) {
 477                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< Get arguments error (%s)\n", err.message);
 478                         dbus_error_free(&err);
 479                         result = TTS_ERROR_OPERATION_FAILED;
 480                 }
 481                 dbus_message_unref(result_msg);
 482         } else {
 483                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 484         }
 485
 486         if (0 == result) {
 487                 *lang = strdup(temp_lang);
 488                 *vctype = (tts_voice_type_e)voice_type;
 489
 490                 if (NULL == *lang) {
 491                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : Out of memory \n");
 492                         result = TTS_ERROR_OUT_OF_MEMORY;
 493                 } else {
 494                         SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts get default voice : result(%d), lang(%s), vctype(%d) \n", result, *lang, *vctype);
 495                 }
 496         } else {
 497                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts get default voice : result(%d) \n", result);
 498         }
 499
 500         dbus_message_unref(msg);
 501
 502         return result;
 503 }
 504
 505
 506 int tts_dbus_request_add_text(int uid, const char* text, const char* lang, int vctype, int speed, int uttid)
 507 {
 508         if (NULL == text || NULL == lang) {
 509                 SLOG(LOG_ERROR, TAG_TTSC, "Input parameter is NULL");
 510                 return TTS_ERROR_INVALID_PARAMETER;
 511         }
 512
 513         DBusMessage* msg;
 514
 515         msg = dbus_message_new_method_call(
 516                 TTS_SERVER_SERVICE_NAME,
 517                 TTS_SERVER_SERVICE_OBJECT_PATH,
 518                 TTS_SERVER_SERVICE_INTERFACE,
 519                 TTS_METHOD_ADD_QUEUE);
 520
 521         if (NULL == msg) {
 522                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts add text : Fail to make message \n");
 523                 return TTS_ERROR_OPERATION_FAILED;
 524         } else {
 525                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts add text : uid(%d), text(%s), lang(%s), type(%d), speed(%d), id(%d)",
 526                         uid, text, lang, vctype, speed, uttid);
 527         }
 528
 529         dbus_message_append_args( msg,
 530                 DBUS_TYPE_INT32, &uid,
 531                 DBUS_TYPE_STRING, &text,
 532                 DBUS_TYPE_STRING, &lang,
 533                 DBUS_TYPE_INT32, &vctype,
 534                 DBUS_TYPE_INT32, &speed,
 535                 DBUS_TYPE_INT32, &uttid,
 536                 DBUS_TYPE_INVALID);
 537
 538         DBusError err;
 539         dbus_error_init(&err);
 540
 541         DBusMessage* result_msg;
 542         int result = TTS_ERROR_OPERATION_FAILED;
 543
 544         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 545
 546         if (NULL != result_msg) {
 547                 dbus_message_get_args(result_msg, &err,
 548                         DBUS_TYPE_INT32, &result,
 549                         DBUS_TYPE_INVALID);
 550
 551                 if (dbus_error_is_set(&err)) {
 552                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : Get arguments error (%s)\n", err.message);
 553                         dbus_error_free(&err);
 554                         result = TTS_ERROR_OPERATION_FAILED;
 555                 }
 556                 dbus_message_unref(result_msg);
 557         } else {
 558                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 559         }
 560
 561         if (0 == result) {
 562                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 563         } else {
 564                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts add text : result(%d) \n", result);
 565         }
 566
 567         dbus_message_unref(msg);
 568
 569         return result;
 570 }
 571
 572 int tts_dbus_request_play(int uid)
 573 {
 574         DBusMessage* msg;
 575
 576         msg = dbus_message_new_method_call(
 577                 TTS_SERVER_SERVICE_NAME,
 578                 TTS_SERVER_SERVICE_OBJECT_PATH,
 579                 TTS_SERVER_SERVICE_INTERFACE,
 580                 TTS_METHOD_PLAY );
 581
 582         if (NULL == msg) {
 583                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts play : Fail to make message \n");
 584                 return TTS_ERROR_OPERATION_FAILED;
 585         } else {
 586                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts play : uid(%d)", uid);
 587         }
 588
 589         dbus_message_append_args( msg,
 590                 DBUS_TYPE_INT32, &uid,
 591                 DBUS_TYPE_INVALID);
 592
 593         DBusError err;
 594         dbus_error_init(&err);
 595
 596         DBusMessage* result_msg;
 597         int result = TTS_ERROR_OPERATION_FAILED;
 598
 599         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 600
 601         if (NULL != result_msg) {
 602                 dbus_message_get_args(result_msg, &err,
 603                         DBUS_TYPE_INT32, &result,
 604                         DBUS_TYPE_INVALID);
 605
 606                 if (dbus_error_is_set(&err)) {
 607                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : Get arguments error (%s)\n", err.message);
 608                         dbus_error_free(&err);
 609                         result = TTS_ERROR_OPERATION_FAILED;
 610                 }
 611                 dbus_message_unref(result_msg);
 612         } else {
 613                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 614         }
 615
 616         if (0 == result) {
 617                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 618         } else {
 619                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts play : result(%d) \n", result);
 620         }
 621
 622         dbus_message_unref(msg);
 623
 624         return result;
 625 }
 626
 627
 628 int tts_dbus_request_stop(int uid)
 629 {
 630         DBusMessage* msg;
 631
 632         msg = dbus_message_new_method_call(
 633                 TTS_SERVER_SERVICE_NAME,
 634                 TTS_SERVER_SERVICE_OBJECT_PATH,
 635                 TTS_SERVER_SERVICE_INTERFACE,
 636                 TTS_METHOD_STOP);
 637
 638         if (NULL == msg) {
 639                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts stop : Fail to make message \n");
 640                 return TTS_ERROR_OPERATION_FAILED;
 641         } else {
 642                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts stop : uid(%d)", uid);
 643         }
 644
 645         DBusError err;
 646         dbus_error_init(&err);
 647
 648         DBusMessage* result_msg;
 649         int result = TTS_ERROR_OPERATION_FAILED;
 650
 651         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 652
 653         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 654
 655         if (NULL != result_msg) {
 656                 dbus_message_get_args(result_msg, &err,
 657                         DBUS_TYPE_INT32, &result,
 658                         DBUS_TYPE_INVALID);
 659
 660                 if (dbus_error_is_set(&err)) {
 661                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : Get arguments error (%s)\n", err.message);
 662                         dbus_error_free(&err);
 663                         result = TTS_ERROR_OPERATION_FAILED;
 664                 }
 665                 dbus_message_unref(result_msg);
 666         } else {
 667                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 668         }
 669
 670         if (0 == result) {
 671                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 672         } else {
 673                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts stop : result(%d) \n", result);
 674         }
 675
 676         dbus_message_unref(msg);
 677
 678         return result;
 679 }
 680
 681 int tts_dbus_request_pause(int uid)
 682 {
 683         DBusMessage* msg;
 684
 685         msg = dbus_message_new_method_call(
 686                 TTS_SERVER_SERVICE_NAME,
 687                 TTS_SERVER_SERVICE_OBJECT_PATH,
 688                 TTS_SERVER_SERVICE_INTERFACE,
 689                 TTS_METHOD_PAUSE);
 690
 691         if (NULL == msg) {
 692                 SLOG(LOG_ERROR, TAG_TTSC, ">>>> Request tts pause : Fail to make message \n");
 693                 return TTS_ERROR_OPERATION_FAILED;
 694         } else {
 695                 SLOG(LOG_DEBUG, TAG_TTSC, ">>>> Request tts pause : uid(%d)", uid);
 696         }
 697
 698         DBusError err;
 699         dbus_error_init(&err);
 700
 701         DBusMessage* result_msg;
 702         int result = TTS_ERROR_OPERATION_FAILED;
 703
 704         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 705
 706         result_msg = dbus_connection_send_with_reply_and_block(g_conn, msg, 5000, &err);
 707
 708         if (NULL != result_msg) {
 709                 dbus_message_get_args(result_msg, &err,
 710                         DBUS_TYPE_INT32, &result,
 711                         DBUS_TYPE_INVALID);
 712
 713                 if (dbus_error_is_set(&err)) {
 714                         SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : Get arguments error (%s)\n", err.message);
 715                         dbus_error_free(&err);
 716                         result = TTS_ERROR_OPERATION_FAILED;
 717                 }
 718                 dbus_message_unref(result_msg);
 719         } else {
 720                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< Result message is NULL ");
 721         }
 722
 723         if (0 == result) {
 724                 SLOG(LOG_DEBUG, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 725         } else {
 726                 SLOG(LOG_ERROR, TAG_TTSC, "<<<< tts pause : result(%d) \n", result);
 727         }
 728
 729         dbus_message_unref(msg);
 730
 731         return result;
 732 }