client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2014 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 "stt_main.h"
  16 #include "stt_dbus.h"
  17 #include "stt_defs.h"
  18
  19 #include "stt_client.h"
  20
  21 static int g_waiting_time = 3000;
  22 static int g_waiting_short_time = 500;
  23
  24 static Ecore_Fd_Handler* g_fd_handler = NULL;
  25
  26 static DBusConnection* g_conn_sender = NULL;
  27 static DBusConnection* g_conn_listener = NULL;
  28
  29
  30 extern int __stt_cb_error(int uid, int reason);
  31
  32 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
  33
  34 extern int __stt_cb_set_state(int uid, int state);
  35
  36 extern int __stt_cb_set_volume(int uid, float volume);
  37
  38 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
  39 {
  40         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
  41
  42         dbus_connection_read_write_dispatch(g_conn_listener, 50);
  43
  44         while (1) {
  45                 DBusMessage* msg = NULL;
  46                 msg = dbus_connection_pop_message(g_conn_listener);
  47
  48                 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
  49                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
  50                         break;
  51                 }
  52
  53                 /* loop again if we haven't read a message */
  54                 if (NULL == msg) {
  55                         break;
  56                 }
  57
  58                 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Message is arrived");
  59
  60                 DBusError err;
  61                 dbus_error_init(&err);
  62
  63                 DBusMessage *reply = NULL;
  64
  65                 char if_name[64];
  66                 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
  67
  68                 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
  69                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
  70                         int uid = 0;
  71                         int response = -1;
  72
  73                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
  74                         if (dbus_error_is_set(&err)) {
  75                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
  76                                 dbus_error_free(&err);
  77                         }
  78
  79                         if (uid > 0) {
  80                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
  81
  82                                 /* check uid */
  83                                 stt_client_s* client = stt_client_get_by_uid(uid);
  84                                 if (NULL != client)
  85                                         response = 1;
  86                                 else
  87                                         response = 0;
  88                         }
  89                         else {
  90                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
  91                         }
  92
  93                         reply = dbus_message_new_method_return(msg);
  94
  95                         if (NULL != reply) {
  96                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
  97
  98                                 if (!dbus_connection_send(g_conn_listener, reply, NULL))
  99                                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
 100                                 else
 101                                         SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
 102
 103                                 dbus_connection_flush(g_conn_listener);
 104                                 dbus_message_unref(reply);
 105                         }
 106                         else {
 107                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 108                         }
 109
 110                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 111                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 112                 } /* STTD_METHOD_HELLO */
 113
 114                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
 115                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
 116                         int uid = 0;
 117                         int state = -1;
 118
 119                         dbus_message_get_args(msg, &err,
 120                                 DBUS_TYPE_INT32, &uid,
 121                                 DBUS_TYPE_INT32, &state,
 122                                 DBUS_TYPE_INVALID);
 123
 124                         if (dbus_error_is_set(&err)) {
 125                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 126                                 dbus_error_free(&err);
 127                         }
 128
 129                         if (uid > 0 && state >= 0) {
 130                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
 131                                 __stt_cb_set_state(uid, state);
 132                         }
 133                         else {
 134                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
 135                         }
 136
 137                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 138                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 139                 } /* STTD_METHOD_SET_STATE */
 140
 141                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
 142                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
 143                         int uid = 0;
 144                         float volume = 0;
 145
 146                         dbus_message_get_args(msg, &err,
 147                                 DBUS_TYPE_INT32, &uid,
 148                                 DBUS_TYPE_INT32, &volume,
 149                                 DBUS_TYPE_INVALID);
 150
 151                         if (dbus_error_is_set(&err)) {
 152                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 153                                 dbus_error_free(&err);
 154                         }
 155
 156                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
 157                         __stt_cb_set_volume(uid, volume);
 158
 159                         /* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
 160                         /* SLOG(LOG_DEBUG, TAG_STTC, " "); */
 161                 } /* STTD_METHOD_SET_VOLUME */
 162
 163                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
 164                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
 165                         int uid = 0;
 166                         DBusMessageIter args;
 167
 168                         dbus_message_iter_init(msg, &args);
 169
 170                         /* Get result */
 171                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 172                                 dbus_message_iter_get_basic(&args, &uid);
 173                                 dbus_message_iter_next(&args);
 174                         }
 175
 176                         stt_client_s* client = NULL;
 177                         client = stt_client_get_by_uid(uid);
 178                         if (NULL != client) {
 179                                 char** temp_result = NULL;
 180                                 char* temp_msg = NULL;
 181                                 char* temp_char = NULL;
 182                                 int temp_event = 0;
 183                                 int temp_count = 0;
 184                                 int temp_result_id = 0;
 185
 186                                 /* Get recognition type */
 187                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 188                                         dbus_message_iter_get_basic(&args, &temp_event);
 189                                         dbus_message_iter_next(&args);
 190                                 }
 191
 192                                 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 193                                         dbus_message_iter_get_basic(&args, &(temp_msg));
 194                                         dbus_message_iter_next(&args);
 195                                 }
 196
 197                                 /* Get voice size */
 198                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 199                                         dbus_message_iter_get_basic(&args, &temp_count);
 200                                         dbus_message_iter_next(&args);
 201                                 }
 202
 203                                 /* Get result id */
 204                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 205                                         dbus_message_iter_get_basic(&args, &temp_result_id);
 206                                         dbus_message_iter_next(&args);
 207                                 }
 208
 209                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
 210                                         uid, temp_event, temp_msg, temp_count, temp_result_id);
 211
 212                                 if (temp_count <= 0) {
 213                                         __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
 214                                 } else {
 215                                         temp_result = (char**)calloc(temp_count, sizeof(char*));
 216
 217                                         if (NULL == temp_result)        {
 218                                                 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
 219                                         } else {
 220                                                 int i = 0;
 221                                                 for (i = 0; i < temp_count; i++) {
 222                                                         dbus_message_iter_get_basic(&args, &(temp_char));
 223                                                         dbus_message_iter_next(&args);
 224
 225                                                         if (NULL != temp_char) {
 226                                                                 temp_result[i] = strdup(temp_char);
 227                                                                 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
 228                                                         }
 229                                                 }
 230
 231                                                 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
 232
 233                                                 for (i = 0; i < temp_count; i++) {
 234                                                         if (NULL != temp_result[i])
 235                                                                 free(temp_result[i]);
 236                                                 }
 237
 238                                                 free(temp_result);
 239                                         }
 240                                 }
 241                         } else {
 242                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
 243                         }
 244
 245                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 246                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 247                 }/* STTD_METHOD_RESULT */
 248
 249                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
 250                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
 251                         int uid;
 252                         int reason;
 253                         char* err_msg;
 254
 255                         dbus_message_get_args(msg, &err,
 256                                 DBUS_TYPE_INT32, &uid,
 257                                 DBUS_TYPE_INT32, &reason,
 258                                 DBUS_TYPE_STRING, &err_msg,
 259                                 DBUS_TYPE_INVALID);
 260
 261                         if (dbus_error_is_set(&err)) {
 262                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
 263                                 dbus_error_free(&err);
 264                         }
 265                         else {
 266                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), msg(%s)", uid, reason, err_msg);
 267                                 __stt_cb_error(uid, reason);
 268                         }
 269
 270                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 271                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 272                 }/* STTD_METHOD_ERROR */
 273
 274                 else {
 275                         SLOG(LOG_DEBUG, TAG_STTC, "Message is NOT valid");
 276                         dbus_message_unref(msg);
 277                         break;
 278                 }
 279
 280                 /* free the message */
 281                 dbus_message_unref(msg);
 282         }/* while */
 283
 284         return ECORE_CALLBACK_RENEW;
 285 }
 286
 287 int stt_dbus_open_connection()
 288 {
 289         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 290                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 291                 return 0;
 292         }
 293
 294         DBusError err;
 295
 296         /* initialise the error value */
 297         dbus_error_init(&err);
 298
 299         /* connect to the DBUS system bus, and check for errors */
 300         g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 301         if (dbus_error_is_set(&err)) {
 302                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
 303                 dbus_error_free(&err);
 304         }
 305
 306         if (NULL == g_conn_sender) {
 307                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
 308                 return STT_ERROR_OPERATION_FAILED;
 309         }
 310
 311         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 312
 313         /* connect to the DBUS system bus, and check for errors */
 314         g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 315
 316         if (dbus_error_is_set(&err)) {
 317                 SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
 318                 dbus_error_free(&err);
 319         }
 320
 321         if (NULL == g_conn_listener) {
 322                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 323                 return STT_ERROR_OPERATION_FAILED;
 324         }
 325
 326         int pid = getpid();
 327
 328         char service_name[64];
 329         memset(service_name, '\0', 64);
 330         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 331
 332         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
 333
 334         /* register our name on the bus, and check for errors */
 335         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 336
 337         if (dbus_error_is_set(&err)) {
 338                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
 339                 dbus_error_free(&err);
 340         }
 341
 342         char rule[128] = {0, };
 343         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 344
 345         /* add a rule for which messages we want to see */
 346         dbus_bus_add_match(g_conn_listener, rule, &err);
 347         dbus_connection_flush(g_conn_listener);
 348
 349         if (dbus_error_is_set(&err)) {
 350                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 351                 dbus_error_free(&err);
 352                 return STT_ERROR_OPERATION_FAILED;
 353         }
 354
 355         int fd = 0;
 356         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 357                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
 358                 return STT_ERROR_OPERATION_FAILED;
 359         } else {
 360                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
 361         }
 362
 363         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 364         if (NULL == g_fd_handler) {
 365                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 366                 return STT_ERROR_OPERATION_FAILED;
 367         }
 368
 369         return 0;
 370 }
 371
 372 int stt_dbus_close_connection()
 373 {
 374         DBusError err;
 375         dbus_error_init(&err);
 376
 377         if (NULL != g_fd_handler) {
 378                 ecore_main_fd_handler_del(g_fd_handler);
 379                 g_fd_handler = NULL;
 380         }
 381
 382         int pid = getpid();
 383
 384         char service_name[64];
 385         memset(service_name, '\0', 64);
 386         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 387
 388         dbus_bus_release_name(g_conn_listener, service_name, &err);
 389         if (dbus_error_is_set(&err)) {
 390                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 391                 dbus_error_free(&err);
 392         }
 393
 394         dbus_connection_close(g_conn_sender);
 395         dbus_connection_close(g_conn_listener);
 396
 397         g_conn_sender = NULL;
 398         g_conn_listener = NULL;
 399
 400         return 0;
 401 }
 402
 403 int stt_dbus_reconnect()
 404 {
 405         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 406         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 407         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
 408                 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 409
 410         if (false == sender_connected || false == listener_connected) {
 411                 stt_dbus_close_connection();
 412
 413                 if (0 != stt_dbus_open_connection()) {
 414                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 415                         return -1;
 416                 }
 417
 418                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 419         }
 420
 421         return 0;
 422 }
 423
 424 int stt_dbus_request_hello()
 425 {
 426         DBusMessage* msg;
 427
 428         msg = dbus_message_new_method_call(
 429                 STT_SERVER_SERVICE_NAME,
 430                 STT_SERVER_SERVICE_OBJECT_PATH,
 431                 STT_SERVER_SERVICE_INTERFACE,
 432                 STT_METHOD_HELLO);
 433
 434         if (NULL == msg) {
 435                 SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 436                 return STT_ERROR_OPERATION_FAILED;
 437         }
 438
 439         DBusError err;
 440         dbus_error_init(&err);
 441
 442         DBusMessage* result_msg = NULL;
 443         int result = 0;
 444
 445         if(g_conn_sender) {
 446                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 447                 dbus_message_unref(msg);
 448                 if (dbus_error_is_set(&err)) {
 449                         dbus_error_free(&err);
 450                 }
 451
 452                 if (NULL != result_msg) {
 453                         dbus_message_unref(result_msg);
 454
 455                         if (dbus_error_is_set(&err)) {
 456                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 457                                 dbus_error_free(&err);
 458                         }
 459
 460                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 461                 } else {
 462                         result = STT_ERROR_TIMED_OUT;
 463                 }
 464         }else {
 465                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 466                 result = STT_ERROR_OPERATION_FAILED;
 467         }
 468
 469         return result;
 470 }
 471
 472
 473 int stt_dbus_request_initialize(int uid, bool* silence_supported)
 474 {
 475         DBusMessage* msg;
 476
 477         msg = dbus_message_new_method_call(
 478                 STT_SERVER_SERVICE_NAME,
 479                 STT_SERVER_SERVICE_OBJECT_PATH,
 480                 STT_SERVER_SERVICE_INTERFACE,
 481                 STT_METHOD_INITIALIZE);
 482
 483         if (NULL == msg) {
 484                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 485                 return STT_ERROR_OPERATION_FAILED;
 486         } else {
 487                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 488         }
 489
 490         int pid = getpid();
 491         dbus_message_append_args(msg,
 492                 DBUS_TYPE_INT32, &pid,
 493                 DBUS_TYPE_INT32, &uid,
 494                 DBUS_TYPE_INVALID);
 495
 496         DBusError err;
 497         dbus_error_init(&err);
 498
 499         DBusMessage* result_msg;
 500         int result = STT_ERROR_OPERATION_FAILED;
 501
 502         if(g_conn_sender) {
 503                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 504                 dbus_message_unref(msg);
 505                 if (dbus_error_is_set(&err)) {
 506                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 507                         dbus_error_free(&err);
 508                 }
 509
 510                 if (NULL != result_msg) {
 511                         dbus_message_get_args(result_msg, &err,
 512                                 DBUS_TYPE_INT32, &result,
 513                                 DBUS_TYPE_INT32, silence_supported,
 514                                 DBUS_TYPE_INVALID);
 515
 516                         if (dbus_error_is_set(&err)) {
 517                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 518                                 dbus_error_free(&err);
 519                                 result = STT_ERROR_OPERATION_FAILED;
 520                         }
 521
 522                         if (0 == result) {
 523                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d)",
 524                                         result, *silence_supported);
 525                         } else {
 526                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 527                         }
 528
 529                         dbus_message_unref(result_msg);
 530                 } else {
 531                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 532                         stt_dbus_reconnect();
 533                         result = STT_ERROR_TIMED_OUT;
 534                 }
 535         } else {
 536                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 537                 result = STT_ERROR_OPERATION_FAILED;
 538         }
 539
 540         return result;
 541 }
 542
 543 int stt_dbus_request_finalize(int uid)
 544 {
 545         DBusMessage* msg;
 546
 547         msg = dbus_message_new_method_call(
 548                 STT_SERVER_SERVICE_NAME,
 549                 STT_SERVER_SERVICE_OBJECT_PATH,
 550                 STT_SERVER_SERVICE_INTERFACE,
 551                 STT_METHOD_FINALIZE);
 552
 553         if (NULL == msg) {
 554                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
 555                 return STT_ERROR_OPERATION_FAILED;
 556         } else {
 557                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 558         }
 559
 560         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 561
 562         DBusError err;
 563         dbus_error_init(&err);
 564
 565         DBusMessage* result_msg;
 566         int result = STT_ERROR_OPERATION_FAILED;
 567
 568         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 569         dbus_message_unref(msg);
 570         if (dbus_error_is_set(&err)) {
 571                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 572                 dbus_error_free(&err);
 573         }
 574
 575         if (NULL != result_msg) {
 576                 dbus_message_get_args(result_msg, &err,
 577                                 DBUS_TYPE_INT32, &result,
 578                                 DBUS_TYPE_INVALID);
 579
 580                 if (dbus_error_is_set(&err)) {
 581                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 582                         dbus_error_free(&err);
 583                         result = STT_ERROR_OPERATION_FAILED;
 584                 }
 585
 586                 dbus_message_unref(result_msg);
 587
 588                 if (0 == result) {
 589                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
 590                 } else {
 591                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
 592                 }
 593         } else {
 594                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 595                 stt_dbus_reconnect();
 596                 result = STT_ERROR_TIMED_OUT;
 597         }
 598
 599         return result;
 600 }
 601
 602 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported)
 603 {
 604         DBusMessage* msg;
 605
 606         msg = dbus_message_new_method_call(
 607                 STT_SERVER_SERVICE_NAME,
 608                 STT_SERVER_SERVICE_OBJECT_PATH,
 609                 STT_SERVER_SERVICE_INTERFACE,
 610                 STT_METHOD_SET_CURRENT_ENGINE);
 611
 612         if (NULL == msg) {
 613                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
 614                 return STT_ERROR_OPERATION_FAILED;
 615         } else {
 616                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
 617         }
 618
 619         dbus_message_append_args(msg,
 620                 DBUS_TYPE_INT32, &uid,
 621                 DBUS_TYPE_STRING, &engine_id,
 622                 DBUS_TYPE_INVALID);
 623
 624         DBusError err;
 625         dbus_error_init(&err);
 626
 627         DBusMessage* result_msg;
 628         int result = STT_ERROR_OPERATION_FAILED;
 629
 630         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 631         dbus_message_unref(msg);
 632         if (dbus_error_is_set(&err)) {
 633                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 634                 dbus_error_free(&err);
 635         }
 636
 637         if (NULL != result_msg) {
 638                 dbus_message_get_args(result_msg, &err,
 639                         DBUS_TYPE_INT32, &result,
 640                         DBUS_TYPE_INT32, silence_supported,
 641                         DBUS_TYPE_INVALID);
 642
 643                 if (dbus_error_is_set(&err)) {
 644                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 645                         dbus_error_free(&err);
 646                         result = STT_ERROR_OPERATION_FAILED;
 647                 }
 648
 649                 dbus_message_unref(result_msg);
 650
 651                 if (0 == result) {
 652                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d)",
 653                                 result, *silence_supported);
 654                 } else {
 655                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
 656                 }
 657         } else {
 658                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 659                 stt_dbus_reconnect();
 660                 result = STT_ERROR_TIMED_OUT;
 661         }
 662
 663         return result;
 664 }
 665
 666 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
 667 {
 668         if (NULL == appid || NULL == value) {
 669                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 670                 return STT_ERROR_INVALID_PARAMETER;
 671         }
 672
 673         DBusMessage* msg;
 674
 675         msg = dbus_message_new_method_call(
 676                 STT_SERVER_SERVICE_NAME,
 677                 STT_SERVER_SERVICE_OBJECT_PATH,
 678                 STT_SERVER_SERVICE_INTERFACE,
 679                 STT_METHOD_CHECK_APP_AGREED);
 680
 681         if (NULL == msg) {
 682                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
 683                 return STT_ERROR_OPERATION_FAILED;
 684         } else {
 685                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
 686         }
 687
 688         dbus_message_append_args(msg,
 689                 DBUS_TYPE_INT32, &uid,
 690                 DBUS_TYPE_STRING, &appid,
 691                 DBUS_TYPE_INVALID);
 692
 693         DBusError err;
 694         dbus_error_init(&err);
 695
 696         DBusMessage* result_msg;
 697         int result = STT_ERROR_OPERATION_FAILED;
 698         int available = -1;
 699
 700         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 701         dbus_message_unref(msg);
 702         if (dbus_error_is_set(&err)) {
 703                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 704                 dbus_error_free(&err);
 705         }
 706
 707         if (NULL != result_msg) {
 708                 dbus_message_get_args(result_msg, &err,
 709                         DBUS_TYPE_INT32, &result,
 710                         DBUS_TYPE_INT32, &available,
 711                         DBUS_TYPE_INVALID);
 712
 713                 if (dbus_error_is_set(&err)) {
 714                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 715                         dbus_error_free(&err);
 716                         result = STT_ERROR_OPERATION_FAILED;
 717                 }
 718                 dbus_message_unref(result_msg);
 719
 720                 if (0 == result) {
 721                         *value = (bool)available;
 722                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
 723                 } else {
 724                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
 725                 }
 726         } else {
 727                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 728                 stt_dbus_reconnect();
 729                 result = STT_ERROR_TIMED_OUT;
 730         }
 731
 732         return result;
 733 }
 734
 735 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 736 {
 737         if (NULL == stt || NULL == callback) {
 738                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 739                 return STT_ERROR_INVALID_PARAMETER;
 740         }
 741
 742         DBusMessage* msg;
 743
 744         msg = dbus_message_new_method_call(
 745                 STT_SERVER_SERVICE_NAME,
 746                 STT_SERVER_SERVICE_OBJECT_PATH,
 747                 STT_SERVER_SERVICE_INTERFACE,
 748                 STT_METHOD_GET_SUPPORT_LANGS);
 749
 750         if (NULL == msg) {
 751                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
 752                 return STT_ERROR_OPERATION_FAILED;
 753         } else {
 754                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 755         }
 756
 757         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 758
 759         DBusError err;
 760         dbus_error_init(&err);
 761
 762         DBusMessage* result_msg;
 763         DBusMessageIter args;
 764         int result = STT_ERROR_OPERATION_FAILED;
 765
 766         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 767         dbus_message_unref(msg);
 768         if (dbus_error_is_set(&err)) {
 769                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 770                 dbus_error_free(&err);
 771         }
 772
 773         if (NULL != result_msg) {
 774                 if (dbus_message_iter_init(result_msg, &args)) {
 775                         /* Get result */
 776                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 777                                 dbus_message_iter_get_basic(&args, &result);
 778                                 dbus_message_iter_next(&args);
 779                         }
 780
 781                         if (0 == result) {
 782                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 783
 784                                 /* Get voice size */
 785                                 int size = 0;
 786                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 787                                         dbus_message_iter_get_basic(&args, &size);
 788                                         dbus_message_iter_next(&args);
 789                                 }
 790
 791                                 if (0 >= size) {
 792                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
 793                                 } else {
 794                                         int i = 0;
 795                                         char* temp_lang;
 796
 797                                         for (i = 0; i < size; i++) {
 798                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 799                                                 dbus_message_iter_next(&args);
 800
 801                                                 if (true != callback(stt, temp_lang, user_data)) {
 802                                                         break;
 803                                                 }
 804                                         }
 805                                 }
 806                         } else {
 807                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 808                         }
 809                 }
 810                 dbus_message_unref(result_msg);
 811         } else {
 812                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
 813                 stt_dbus_reconnect();
 814                 result = STT_ERROR_TIMED_OUT;
 815         }
 816
 817         return result;
 818 }
 819
 820 int stt_dbus_request_get_default_lang(int uid, char** language)
 821 {
 822         if (NULL == language) {
 823                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 824                 return STT_ERROR_INVALID_PARAMETER;
 825         }
 826
 827         DBusMessage* msg;
 828
 829         msg = dbus_message_new_method_call(
 830                 STT_SERVER_SERVICE_NAME,
 831                 STT_SERVER_SERVICE_OBJECT_PATH,
 832                 STT_SERVER_SERVICE_INTERFACE,
 833                 STT_METHOD_GET_CURRENT_LANG);
 834
 835         if (NULL == msg) {
 836                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
 837                 return STT_ERROR_OPERATION_FAILED;
 838         } else {
 839                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 840         }
 841
 842         dbus_message_append_args(msg,
 843                 DBUS_TYPE_INT32, &uid,
 844                 DBUS_TYPE_INVALID);
 845
 846         DBusError err;
 847         dbus_error_init(&err);
 848
 849         DBusMessage* result_msg;
 850         int result = STT_ERROR_OPERATION_FAILED;
 851         char* temp_lang = NULL;
 852
 853         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 854         dbus_message_unref(msg);
 855         if (dbus_error_is_set(&err)) {
 856                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 857                 dbus_error_free(&err);
 858         }
 859
 860         if (NULL != result_msg) {
 861                 dbus_message_get_args(result_msg, &err,
 862                         DBUS_TYPE_INT32, &result,
 863                         DBUS_TYPE_STRING, &temp_lang,
 864                         DBUS_TYPE_INVALID);
 865
 866                 if (dbus_error_is_set(&err)) {
 867                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 868                         dbus_error_free(&err);
 869                         result = STT_ERROR_OPERATION_FAILED;
 870                 }
 871                 dbus_message_unref(result_msg);
 872
 873                 if (0 == result) {
 874                         *language = strdup(temp_lang);
 875                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
 876                 } else {
 877                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
 878                 }
 879         } else {
 880                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 881                 stt_dbus_reconnect();
 882                 result = STT_ERROR_TIMED_OUT;
 883         }
 884
 885         return result;
 886 }
 887
 888 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
 889 {
 890         if (NULL == support || NULL == type) {
 891                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 892                 return STT_ERROR_INVALID_PARAMETER;
 893         }
 894
 895         DBusMessage* msg;
 896
 897         msg = dbus_message_new_method_call(
 898                    STT_SERVER_SERVICE_NAME,
 899                    STT_SERVER_SERVICE_OBJECT_PATH,
 900                    STT_SERVER_SERVICE_INTERFACE,
 901                    STT_METHOD_IS_TYPE_SUPPORTED);
 902
 903         if (NULL == msg) {
 904                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
 905                 return STT_ERROR_OPERATION_FAILED;
 906         } else {
 907                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
 908         }
 909
 910         dbus_message_append_args(msg,
 911                 DBUS_TYPE_INT32, &uid,
 912                 DBUS_TYPE_STRING, &type,
 913                 DBUS_TYPE_INVALID);
 914
 915         DBusError err;
 916         dbus_error_init(&err);
 917
 918         DBusMessage* result_msg;
 919         int result = STT_ERROR_OPERATION_FAILED;
 920         int result_support = -1;
 921
 922         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 923         dbus_message_unref(msg);
 924         if (dbus_error_is_set(&err)) {
 925                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 926                 dbus_error_free(&err);
 927         }
 928
 929         if (NULL != result_msg) {
 930                 dbus_message_get_args(result_msg, &err,
 931                         DBUS_TYPE_INT32, &result,
 932                         DBUS_TYPE_INT32, &result_support,
 933                         DBUS_TYPE_INVALID);
 934
 935                 if (dbus_error_is_set(&err)) {
 936                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 937                         dbus_error_free(&err);
 938                         result = STT_ERROR_OPERATION_FAILED;
 939                 }
 940                 dbus_message_unref(result_msg);
 941
 942                 if (0 == result) {
 943                         *support = (bool)result_support;
 944                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
 945                 } else {
 946                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
 947                 }
 948         } else {
 949                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 950                 stt_dbus_reconnect();
 951                 result = STT_ERROR_TIMED_OUT;
 952         }
 953
 954         return result;
 955 }
 956
 957 int stt_dbus_request_set_start_sound(int uid, const char* file)
 958 {
 959         if (NULL == file) {
 960                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 961                 return STT_ERROR_INVALID_PARAMETER;
 962         }
 963
 964         DBusMessage* msg;
 965
 966         msg = dbus_message_new_method_call(
 967                    STT_SERVER_SERVICE_NAME,
 968                    STT_SERVER_SERVICE_OBJECT_PATH,
 969                    STT_SERVER_SERVICE_INTERFACE,
 970                    STT_METHOD_SET_START_SOUND);
 971
 972         if (NULL == msg) {
 973                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
 974                 return STT_ERROR_OPERATION_FAILED;
 975         } else {
 976                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
 977         }
 978
 979         dbus_message_append_args(msg,
 980                 DBUS_TYPE_INT32, &uid,
 981                 DBUS_TYPE_STRING, &file,
 982                 DBUS_TYPE_INVALID);
 983
 984         DBusError err;
 985         dbus_error_init(&err);
 986
 987         DBusMessage* result_msg;
 988         int result = STT_ERROR_OPERATION_FAILED;
 989
 990         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 991         dbus_message_unref(msg);
 992         if (dbus_error_is_set(&err)) {
 993                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 994                 dbus_error_free(&err);
 995         }
 996
 997         if (NULL != result_msg) {
 998                 dbus_message_get_args(result_msg, &err,
 999                         DBUS_TYPE_INT32, &result,
1000                         DBUS_TYPE_INVALID);
1001
1002                 if (dbus_error_is_set(&err)) {
1003                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1004                         dbus_error_free(&err);
1005                         result = STT_ERROR_OPERATION_FAILED;
1006                 }
1007                 dbus_message_unref(result_msg);
1008
1009                 if (0 == result) {
1010                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1011                 } else {
1012                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1013                 }
1014         } else {
1015                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1016                 stt_dbus_reconnect();
1017                 result = STT_ERROR_TIMED_OUT;
1018         }
1019
1020         return result;
1021 }
1022
1023 int stt_dbus_request_unset_start_sound(int uid)
1024 {
1025         DBusMessage* msg;
1026
1027         msg = dbus_message_new_method_call(
1028                    STT_SERVER_SERVICE_NAME,
1029                    STT_SERVER_SERVICE_OBJECT_PATH,
1030                    STT_SERVER_SERVICE_INTERFACE,
1031                    STT_METHOD_UNSET_START_SOUND);
1032
1033         if (NULL == msg) {
1034                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1035                 return STT_ERROR_OPERATION_FAILED;
1036         } else {
1037                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1038         }
1039
1040         dbus_message_append_args(msg,
1041                 DBUS_TYPE_INT32, &uid,
1042                 DBUS_TYPE_INVALID);
1043
1044         DBusError err;
1045         dbus_error_init(&err);
1046
1047         DBusMessage* result_msg;
1048         int result = STT_ERROR_OPERATION_FAILED;
1049
1050         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1051         dbus_message_unref(msg);
1052         if (dbus_error_is_set(&err)) {
1053                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1054                 dbus_error_free(&err);
1055         }
1056
1057         if (NULL != result_msg) {
1058                 dbus_message_get_args(result_msg, &err,
1059                         DBUS_TYPE_INT32, &result,
1060                         DBUS_TYPE_INVALID);
1061
1062                 if (dbus_error_is_set(&err)) {
1063                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1064                         dbus_error_free(&err);
1065                         result = STT_ERROR_OPERATION_FAILED;
1066                 }
1067                 dbus_message_unref(result_msg);
1068
1069                 if (0 == result) {
1070                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1071                 } else {
1072                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1073                 }
1074         } else {
1075                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1076                 stt_dbus_reconnect();
1077                 result = STT_ERROR_TIMED_OUT;
1078         }
1079
1080         return result;
1081 }
1082
1083 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1084 {
1085         if (NULL == file) {
1086                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1087                 return STT_ERROR_INVALID_PARAMETER;
1088         }
1089
1090         DBusMessage* msg;
1091
1092         msg = dbus_message_new_method_call(
1093                    STT_SERVER_SERVICE_NAME,
1094                    STT_SERVER_SERVICE_OBJECT_PATH,
1095                    STT_SERVER_SERVICE_INTERFACE,
1096                    STT_METHOD_SET_STOP_SOUND);
1097
1098         if (NULL == msg) {
1099                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1100                 return STT_ERROR_OPERATION_FAILED;
1101         } else {
1102                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1103         }
1104
1105         dbus_message_append_args(msg,
1106                 DBUS_TYPE_INT32, &uid,
1107                 DBUS_TYPE_STRING, &file,
1108                 DBUS_TYPE_INVALID);
1109
1110         DBusError err;
1111         dbus_error_init(&err);
1112
1113         DBusMessage* result_msg;
1114         int result = STT_ERROR_OPERATION_FAILED;
1115
1116         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1117         dbus_message_unref(msg);
1118         if (dbus_error_is_set(&err)) {
1119                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1120                 dbus_error_free(&err);
1121         }
1122
1123         if (NULL != result_msg) {
1124                 dbus_message_get_args(result_msg, &err,
1125                         DBUS_TYPE_INT32, &result,
1126                         DBUS_TYPE_INVALID);
1127
1128                 if (dbus_error_is_set(&err)) {
1129                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1130                         dbus_error_free(&err);
1131                         result = STT_ERROR_OPERATION_FAILED;
1132                 }
1133                 dbus_message_unref(result_msg);
1134
1135                 if (0 == result) {
1136                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1137                 } else {
1138                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1139                 }
1140         } else {
1141                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1142                 stt_dbus_reconnect();
1143                 result = STT_ERROR_TIMED_OUT;
1144         }
1145
1146         return result;
1147 }
1148
1149 int stt_dbus_request_unset_stop_sound(int uid)
1150 {
1151         DBusMessage* msg;
1152
1153         msg = dbus_message_new_method_call(
1154                    STT_SERVER_SERVICE_NAME,
1155                    STT_SERVER_SERVICE_OBJECT_PATH,
1156                    STT_SERVER_SERVICE_INTERFACE,
1157                    STT_METHOD_UNSET_STOP_SOUND);
1158
1159         if (NULL == msg) {
1160                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1161                 return STT_ERROR_OPERATION_FAILED;
1162         } else {
1163                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1164         }
1165
1166         dbus_message_append_args(msg,
1167                 DBUS_TYPE_INT32, &uid,
1168                 DBUS_TYPE_INVALID);
1169
1170         DBusError err;
1171         dbus_error_init(&err);
1172
1173         DBusMessage* result_msg;
1174         int result = STT_ERROR_OPERATION_FAILED;
1175
1176         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1177         dbus_message_unref(msg);
1178         if (dbus_error_is_set(&err)) {
1179                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1180                 dbus_error_free(&err);
1181         }
1182
1183         if (NULL != result_msg) {
1184                 dbus_message_get_args(result_msg, &err,
1185                         DBUS_TYPE_INT32, &result,
1186                         DBUS_TYPE_INVALID);
1187
1188                 if (dbus_error_is_set(&err)) {
1189                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1190                         dbus_error_free(&err);
1191                         result = STT_ERROR_OPERATION_FAILED;
1192                 }
1193                 dbus_message_unref(result_msg);
1194
1195                 if (0 == result) {
1196                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1197                 } else {
1198                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1199                 }
1200         } else {
1201                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1202                 stt_dbus_reconnect();
1203                 result = STT_ERROR_TIMED_OUT;
1204         }
1205
1206         return result;
1207 }
1208
1209 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid)
1210 {
1211         if (NULL == lang || NULL == type || NULL == appid) {
1212                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1213                 return STT_ERROR_INVALID_PARAMETER;
1214         }
1215
1216         DBusMessage* msg;
1217
1218         /* create a signal & check for errors */
1219         msg = dbus_message_new_method_call(
1220                 STT_SERVER_SERVICE_NAME,
1221                 STT_SERVER_SERVICE_OBJECT_PATH,
1222                 STT_SERVER_SERVICE_INTERFACE,
1223                 STT_METHOD_START);
1224
1225         if (NULL == msg) {
1226                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1227                 return STT_ERROR_OPERATION_FAILED;
1228         } else {
1229                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1230         }
1231
1232         dbus_message_append_args(msg,
1233                 DBUS_TYPE_INT32, &uid,
1234                 DBUS_TYPE_STRING, &lang,
1235                 DBUS_TYPE_STRING, &type,
1236                 DBUS_TYPE_INT32, &silence,
1237                 DBUS_TYPE_STRING, &appid,
1238                 DBUS_TYPE_INVALID);
1239 #if 1
1240         if(g_conn_sender) {
1241                 dbus_message_set_no_reply(msg, TRUE);
1242
1243                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1244                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1245                         return STT_ERROR_OUT_OF_MEMORY;
1246                 } else {
1247                         dbus_connection_flush(g_conn_sender);
1248                 }
1249
1250                 dbus_message_unref(msg);
1251
1252         } else {
1253                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1254                 return STT_ERROR_OPERATION_FAILED;
1255         }
1256
1257         return 0;
1258 #else
1259         DBusError err;
1260         dbus_error_init(&err);
1261
1262         DBusMessage* result_msg;
1263         int result = STT_ERROR_OPERATION_FAILED;
1264
1265         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1266         dbus_message_unref(msg);
1267         if (dbus_error_is_set(&err)) {
1268                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1269                 dbus_error_free(&err);
1270         }
1271
1272         if (NULL != result_msg) {
1273                 dbus_message_get_args(result_msg, &err,
1274                         DBUS_TYPE_INT32, &result,
1275                         DBUS_TYPE_INVALID);
1276
1277                 if (dbus_error_is_set(&err)) {
1278                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1279                         dbus_error_free(&err);
1280                         result = STT_ERROR_OPERATION_FAILED;
1281                 }
1282                 dbus_message_unref(result_msg);
1283
1284                 if (0 == result) {
1285                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1286                 } else {
1287                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1288                 }
1289         } else {
1290                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1291                 stt_dbus_reconnect();
1292                 result = STT_ERROR_TIMED_OUT;
1293         }
1294
1295         return result;
1296 #endif
1297 }
1298
1299 int stt_dbus_request_stop(int uid)
1300 {
1301         DBusMessage* msg;
1302
1303         /* create a signal & check for errors */
1304         msg = dbus_message_new_method_call(
1305                 STT_SERVER_SERVICE_NAME,
1306                 STT_SERVER_SERVICE_OBJECT_PATH,
1307                 STT_SERVER_SERVICE_INTERFACE,
1308                 STT_METHOD_STOP);
1309
1310         if (NULL == msg) {
1311                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1312                 return STT_ERROR_OPERATION_FAILED;
1313         } else {
1314                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1315         }
1316
1317         dbus_message_append_args(msg,
1318                 DBUS_TYPE_INT32, &uid,
1319                 DBUS_TYPE_INVALID);
1320 #if 1
1321         if(g_conn_sender) {
1322                 dbus_message_set_no_reply(msg, TRUE);
1323
1324                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1325                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1326                         return STT_ERROR_OUT_OF_MEMORY;
1327                 } else {
1328                         dbus_connection_flush(g_conn_sender);
1329                 }
1330
1331                 dbus_message_unref(msg);
1332         } else {
1333                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1334                 return STT_ERROR_OPERATION_FAILED;
1335         }
1336
1337         return 0;
1338 #else
1339         DBusError err;
1340         dbus_error_init(&err);
1341
1342         DBusMessage* result_msg;
1343         int result = STT_ERROR_OPERATION_FAILED;
1344
1345         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1346         dbus_message_unref(msg);
1347         if (dbus_error_is_set(&err)) {
1348                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1349                 dbus_error_free(&err);
1350         }
1351
1352         if (NULL != result_msg) {
1353                 dbus_message_get_args(result_msg, &err,
1354                         DBUS_TYPE_INT32, &result,
1355                         DBUS_TYPE_INVALID);
1356
1357                 if (dbus_error_is_set(&err)) {
1358                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1359                         dbus_error_free(&err);
1360                         result = STT_ERROR_OPERATION_FAILED;
1361                 }
1362                 dbus_message_unref(result_msg);
1363
1364                 if (0 == result) {
1365                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1366                 } else {
1367                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1368                 }
1369         } else {
1370                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1371                 stt_dbus_reconnect();
1372                 result = STT_ERROR_TIMED_OUT;
1373         }
1374
1375         return result;
1376 #endif
1377 }
1378
1379 int stt_dbus_request_cancel(int uid)
1380 {
1381         DBusMessage* msg;
1382
1383         /* create a signal & check for errors */
1384         msg = dbus_message_new_method_call(
1385                 STT_SERVER_SERVICE_NAME,
1386                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1387                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
1388                 STT_METHOD_CANCEL);     /* name of the signal */
1389
1390         if (NULL == msg) {
1391                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1392                 return STT_ERROR_OPERATION_FAILED;
1393         } else {
1394                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1395         }
1396
1397         dbus_message_append_args(msg,
1398                 DBUS_TYPE_INT32, &uid,
1399                 DBUS_TYPE_INVALID);
1400 #if 1
1401         if(g_conn_sender) {
1402                 dbus_message_set_no_reply(msg, TRUE);
1403
1404                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1405                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1406                         return STT_ERROR_OUT_OF_MEMORY;
1407                 } else {
1408                         dbus_connection_flush(g_conn_sender);
1409                 }
1410
1411                 dbus_message_unref(msg);
1412         } else {
1413                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1414                 return STT_ERROR_OPERATION_FAILED;
1415         }
1416
1417         return 0;
1418 #else
1419         DBusError err;
1420         dbus_error_init(&err);
1421
1422         DBusMessage* result_msg;
1423         int result = STT_ERROR_OPERATION_FAILED;
1424
1425         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1426         dbus_message_unref(msg);
1427         if (dbus_error_is_set(&err)) {
1428                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1429                 dbus_error_free(&err);
1430         }
1431
1432         if (NULL != result_msg) {
1433                 dbus_message_get_args(result_msg, &err,
1434                         DBUS_TYPE_INT32, &result,
1435                         DBUS_TYPE_INVALID);
1436
1437                 if (dbus_error_is_set(&err)) {
1438                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1439                         dbus_error_free(&err);
1440                         result = STT_ERROR_OPERATION_FAILED;
1441                 }
1442                 dbus_message_unref(result_msg);
1443
1444                 if (0 == result) {
1445                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1446                 } else {
1447                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1448                 }
1449         } else {
1450                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1451                 stt_dbus_reconnect();
1452                 result = STT_ERROR_TIMED_OUT;
1453         }
1454
1455         return result;
1456 #endif
1457 }