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