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