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, char* err_msg);
  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), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
 263                                 __stt_cb_error(uid, reason, err_msg);
 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                         if (dbus_error_is_set(&err)) {
 459                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 460                                 dbus_error_free(&err);
 461                         }
 462
 463                         SLOG(LOG_ERROR, TAG_STTC, "STT_ERROR_TIME_OUT");
 464                         result = STT_ERROR_TIMED_OUT;
 465                 }
 466         } else {
 467                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 468                 result = STT_ERROR_OPERATION_FAILED;
 469         }
 470
 471         return result;
 472 }
 473
 474
 475 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 476 {
 477         DBusMessage* msg;
 478
 479         msg = dbus_message_new_method_call(
 480                 STT_SERVER_SERVICE_NAME,
 481                 STT_SERVER_SERVICE_OBJECT_PATH,
 482                 STT_SERVER_SERVICE_INTERFACE,
 483                 STT_METHOD_INITIALIZE);
 484
 485         if (NULL == msg) {
 486                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 487                 return STT_ERROR_OPERATION_FAILED;
 488         } else {
 489                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 490         }
 491
 492         int pid = getpid();
 493         dbus_message_append_args(msg,
 494                 DBUS_TYPE_INT32, &pid,
 495                 DBUS_TYPE_INT32, &uid,
 496                 DBUS_TYPE_INVALID);
 497
 498         DBusError err;
 499         dbus_error_init(&err);
 500
 501         DBusMessage* result_msg;
 502         int result = STT_ERROR_OPERATION_FAILED;
 503
 504         if (g_conn_sender) {
 505                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 506                 dbus_message_unref(msg);
 507                 if (dbus_error_is_set(&err)) {
 508                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 509                         dbus_error_free(&err);
 510                 }
 511
 512                 if (NULL != result_msg) {
 513                         dbus_message_get_args(result_msg, &err,
 514                                 DBUS_TYPE_INT32, &result,
 515                                 DBUS_TYPE_INT32, silence_supported,
 516                                 DBUS_TYPE_INT32, credential_needed,
 517                                 DBUS_TYPE_INVALID);
 518
 519                         if (dbus_error_is_set(&err)) {
 520                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 521                                 dbus_error_free(&err);
 522                                 result = STT_ERROR_OPERATION_FAILED;
 523                         }
 524
 525                         if (0 == result) {
 526                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
 527                                         result, *silence_supported, *credential_needed);
 528                         } else {
 529                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 530                         }
 531
 532                         dbus_message_unref(result_msg);
 533                 } else {
 534                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 535                         stt_dbus_reconnect();
 536                         result = STT_ERROR_TIMED_OUT;
 537                 }
 538         } else {
 539                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 540                 result = STT_ERROR_OPERATION_FAILED;
 541         }
 542
 543         return result;
 544 }
 545
 546 int stt_dbus_request_finalize(int uid)
 547 {
 548         DBusMessage* msg;
 549
 550         msg = dbus_message_new_method_call(
 551                 STT_SERVER_SERVICE_NAME,
 552                 STT_SERVER_SERVICE_OBJECT_PATH,
 553                 STT_SERVER_SERVICE_INTERFACE,
 554                 STT_METHOD_FINALIZE);
 555
 556         if (NULL == msg) {
 557                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
 558                 return STT_ERROR_OPERATION_FAILED;
 559         } else {
 560                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 561         }
 562
 563         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 564
 565         DBusError err;
 566         dbus_error_init(&err);
 567
 568         DBusMessage* result_msg;
 569         int result = STT_ERROR_OPERATION_FAILED;
 570
 571         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 572         dbus_message_unref(msg);
 573         if (dbus_error_is_set(&err)) {
 574                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 575                 dbus_error_free(&err);
 576         }
 577
 578         if (NULL != result_msg) {
 579                 dbus_message_get_args(result_msg, &err,
 580                                 DBUS_TYPE_INT32, &result,
 581                                 DBUS_TYPE_INVALID);
 582
 583                 if (dbus_error_is_set(&err)) {
 584                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 585                         dbus_error_free(&err);
 586                         result = STT_ERROR_OPERATION_FAILED;
 587                 }
 588
 589                 dbus_message_unref(result_msg);
 590
 591                 if (0 == result) {
 592                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
 593                 } else {
 594                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
 595                 }
 596         } else {
 597                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 598                 stt_dbus_reconnect();
 599                 result = STT_ERROR_TIMED_OUT;
 600         }
 601
 602         return result;
 603 }
 604
 605 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
 606 {
 607         DBusMessage* msg;
 608
 609         msg = dbus_message_new_method_call(
 610                 STT_SERVER_SERVICE_NAME,
 611                 STT_SERVER_SERVICE_OBJECT_PATH,
 612                 STT_SERVER_SERVICE_INTERFACE,
 613                 STT_METHOD_SET_CURRENT_ENGINE);
 614
 615         if (NULL == msg) {
 616                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
 617                 return STT_ERROR_OPERATION_FAILED;
 618         } else {
 619                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d)", uid);
 620         }
 621
 622         dbus_message_append_args(msg,
 623                 DBUS_TYPE_INT32, &uid,
 624                 DBUS_TYPE_STRING, &engine_id,
 625                 DBUS_TYPE_INVALID);
 626
 627         DBusError err;
 628         dbus_error_init(&err);
 629
 630         DBusMessage* result_msg;
 631         int result = STT_ERROR_OPERATION_FAILED;
 632
 633         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 634         dbus_message_unref(msg);
 635         if (dbus_error_is_set(&err)) {
 636                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 637                 dbus_error_free(&err);
 638         }
 639
 640         if (NULL != result_msg) {
 641                 dbus_message_get_args(result_msg, &err,
 642                         DBUS_TYPE_INT32, &result,
 643                         DBUS_TYPE_INT32, silence_supported,
 644                         DBUS_TYPE_INT32, credential_needed,
 645                         DBUS_TYPE_INVALID);
 646
 647                 if (dbus_error_is_set(&err)) {
 648                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 649                         dbus_error_free(&err);
 650                         result = STT_ERROR_OPERATION_FAILED;
 651                 }
 652
 653                 dbus_message_unref(result_msg);
 654
 655                 if (0 == result) {
 656                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
 657                                 result, *silence_supported, *credential_needed);
 658                 } else {
 659                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
 660                 }
 661         } else {
 662                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 663                 stt_dbus_reconnect();
 664                 result = STT_ERROR_TIMED_OUT;
 665         }
 666
 667         return result;
 668 }
 669
 670 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
 671 {
 672         if (NULL == appid || NULL == value) {
 673                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 674                 return STT_ERROR_INVALID_PARAMETER;
 675         }
 676
 677         DBusMessage* msg;
 678
 679         msg = dbus_message_new_method_call(
 680                 STT_SERVER_SERVICE_NAME,
 681                 STT_SERVER_SERVICE_OBJECT_PATH,
 682                 STT_SERVER_SERVICE_INTERFACE,
 683                 STT_METHOD_CHECK_APP_AGREED);
 684
 685         if (NULL == msg) {
 686                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
 687                 return STT_ERROR_OPERATION_FAILED;
 688         } else {
 689                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
 690         }
 691
 692         dbus_message_append_args(msg,
 693                 DBUS_TYPE_INT32, &uid,
 694                 DBUS_TYPE_STRING, &appid,
 695                 DBUS_TYPE_INVALID);
 696
 697         DBusError err;
 698         dbus_error_init(&err);
 699
 700         DBusMessage* result_msg;
 701         int result = STT_ERROR_OPERATION_FAILED;
 702         int available = -1;
 703
 704         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 705         dbus_message_unref(msg);
 706         if (dbus_error_is_set(&err)) {
 707                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 708                 dbus_error_free(&err);
 709         }
 710
 711         if (NULL != result_msg) {
 712                 dbus_message_get_args(result_msg, &err,
 713                         DBUS_TYPE_INT32, &result,
 714                         DBUS_TYPE_INT32, &available,
 715                         DBUS_TYPE_INVALID);
 716
 717                 if (dbus_error_is_set(&err)) {
 718                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 719                         dbus_error_free(&err);
 720                         result = STT_ERROR_OPERATION_FAILED;
 721                 }
 722                 dbus_message_unref(result_msg);
 723
 724                 if (0 == result) {
 725                         *value = (bool)available;
 726                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
 727                 } else {
 728                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
 729                 }
 730         } else {
 731                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 732                 stt_dbus_reconnect();
 733                 result = STT_ERROR_TIMED_OUT;
 734         }
 735
 736         return result;
 737 }
 738
 739 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
 740 {
 741         if (NULL == stt || NULL == callback) {
 742                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 743                 return STT_ERROR_INVALID_PARAMETER;
 744         }
 745
 746         DBusMessage* msg;
 747
 748         msg = dbus_message_new_method_call(
 749                 STT_SERVER_SERVICE_NAME,
 750                 STT_SERVER_SERVICE_OBJECT_PATH,
 751                 STT_SERVER_SERVICE_INTERFACE,
 752                 STT_METHOD_GET_SUPPORT_LANGS);
 753
 754         if (NULL == msg) {
 755                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
 756                 return STT_ERROR_OPERATION_FAILED;
 757         } else {
 758                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
 759         }
 760
 761         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 762
 763         DBusError err;
 764         dbus_error_init(&err);
 765
 766         DBusMessage* result_msg;
 767         DBusMessageIter args;
 768         int result = STT_ERROR_OPERATION_FAILED;
 769
 770         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 771         dbus_message_unref(msg);
 772         if (dbus_error_is_set(&err)) {
 773                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 774                 dbus_error_free(&err);
 775         }
 776
 777         if (NULL != result_msg) {
 778                 if (dbus_message_iter_init(result_msg, &args)) {
 779                         /* Get result */
 780                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 781                                 dbus_message_iter_get_basic(&args, &result);
 782                                 dbus_message_iter_next(&args);
 783                         }
 784
 785                         if (0 == result) {
 786                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 787
 788                                 /* Get voice size */
 789                                 int size = 0;
 790                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 791                                         dbus_message_iter_get_basic(&args, &size);
 792                                         dbus_message_iter_next(&args);
 793                                 }
 794
 795                                 if (0 >= size) {
 796                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
 797                                 } else {
 798                                         int i = 0;
 799                                         char* temp_lang;
 800
 801                                         for (i = 0; i < size; i++) {
 802                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
 803                                                 dbus_message_iter_next(&args);
 804
 805                                                 if (true != callback(stt, temp_lang, user_data)) {
 806                                                         break;
 807                                                 }
 808                                         }
 809                                 }
 810                         } else {
 811                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
 812                         }
 813                 }
 814                 dbus_message_unref(result_msg);
 815         } else {
 816                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
 817                 stt_dbus_reconnect();
 818                 result = STT_ERROR_TIMED_OUT;
 819         }
 820
 821         return result;
 822 }
 823
 824 int stt_dbus_request_get_default_lang(int uid, char** language)
 825 {
 826         if (NULL == language) {
 827                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 828                 return STT_ERROR_INVALID_PARAMETER;
 829         }
 830
 831         DBusMessage* msg;
 832
 833         msg = dbus_message_new_method_call(
 834                 STT_SERVER_SERVICE_NAME,
 835                 STT_SERVER_SERVICE_OBJECT_PATH,
 836                 STT_SERVER_SERVICE_INTERFACE,
 837                 STT_METHOD_GET_CURRENT_LANG);
 838
 839         if (NULL == msg) {
 840                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
 841                 return STT_ERROR_OPERATION_FAILED;
 842         } else {
 843                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
 844         }
 845
 846         dbus_message_append_args(msg,
 847                 DBUS_TYPE_INT32, &uid,
 848                 DBUS_TYPE_INVALID);
 849
 850         DBusError err;
 851         dbus_error_init(&err);
 852
 853         DBusMessage* result_msg;
 854         int result = STT_ERROR_OPERATION_FAILED;
 855         char* temp_lang = NULL;
 856
 857         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 858         dbus_message_unref(msg);
 859         if (dbus_error_is_set(&err)) {
 860                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 861                 dbus_error_free(&err);
 862         }
 863
 864         if (NULL != result_msg) {
 865                 dbus_message_get_args(result_msg, &err,
 866                         DBUS_TYPE_INT32, &result,
 867                         DBUS_TYPE_STRING, &temp_lang,
 868                         DBUS_TYPE_INVALID);
 869
 870                 if (dbus_error_is_set(&err)) {
 871                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 872                         dbus_error_free(&err);
 873                         result = STT_ERROR_OPERATION_FAILED;
 874                 }
 875                 dbus_message_unref(result_msg);
 876
 877                 if (0 == result) {
 878                         *language = strdup(temp_lang);
 879                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
 880                 } else {
 881                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
 882                 }
 883         } else {
 884                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 885                 stt_dbus_reconnect();
 886                 result = STT_ERROR_TIMED_OUT;
 887         }
 888
 889         return result;
 890 }
 891
 892 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
 893 {
 894         if (NULL == support || NULL == type) {
 895                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 896                 return STT_ERROR_INVALID_PARAMETER;
 897         }
 898
 899         DBusMessage* msg;
 900
 901         msg = dbus_message_new_method_call(
 902                    STT_SERVER_SERVICE_NAME,
 903                    STT_SERVER_SERVICE_OBJECT_PATH,
 904                    STT_SERVER_SERVICE_INTERFACE,
 905                    STT_METHOD_IS_TYPE_SUPPORTED);
 906
 907         if (NULL == msg) {
 908                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
 909                 return STT_ERROR_OPERATION_FAILED;
 910         } else {
 911                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
 912         }
 913
 914         dbus_message_append_args(msg,
 915                 DBUS_TYPE_INT32, &uid,
 916                 DBUS_TYPE_STRING, &type,
 917                 DBUS_TYPE_INVALID);
 918
 919         DBusError err;
 920         dbus_error_init(&err);
 921
 922         DBusMessage* result_msg;
 923         int result = STT_ERROR_OPERATION_FAILED;
 924         int result_support = -1;
 925
 926         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 927         dbus_message_unref(msg);
 928         if (dbus_error_is_set(&err)) {
 929                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 930                 dbus_error_free(&err);
 931         }
 932
 933         if (NULL != result_msg) {
 934                 dbus_message_get_args(result_msg, &err,
 935                         DBUS_TYPE_INT32, &result,
 936                         DBUS_TYPE_INT32, &result_support,
 937                         DBUS_TYPE_INVALID);
 938
 939                 if (dbus_error_is_set(&err)) {
 940                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 941                         dbus_error_free(&err);
 942                         result = STT_ERROR_OPERATION_FAILED;
 943                 }
 944                 dbus_message_unref(result_msg);
 945
 946                 if (0 == result) {
 947                         *support = (bool)result_support;
 948                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
 949                 } else {
 950                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
 951                 }
 952         } else {
 953                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 954                 stt_dbus_reconnect();
 955                 result = STT_ERROR_TIMED_OUT;
 956         }
 957
 958         return result;
 959 }
 960
 961 int stt_dbus_request_set_start_sound(int uid, const char* file)
 962 {
 963         if (NULL == file) {
 964                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 965                 return STT_ERROR_INVALID_PARAMETER;
 966         }
 967
 968         DBusMessage* msg;
 969
 970         msg = dbus_message_new_method_call(
 971                    STT_SERVER_SERVICE_NAME,
 972                    STT_SERVER_SERVICE_OBJECT_PATH,
 973                    STT_SERVER_SERVICE_INTERFACE,
 974                    STT_METHOD_SET_START_SOUND);
 975
 976         if (NULL == msg) {
 977                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
 978                 return STT_ERROR_OPERATION_FAILED;
 979         } else {
 980                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
 981         }
 982
 983         dbus_message_append_args(msg,
 984                 DBUS_TYPE_INT32, &uid,
 985                 DBUS_TYPE_STRING, &file,
 986                 DBUS_TYPE_INVALID);
 987
 988         DBusError err;
 989         dbus_error_init(&err);
 990
 991         DBusMessage* result_msg;
 992         int result = STT_ERROR_OPERATION_FAILED;
 993
 994         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 995         dbus_message_unref(msg);
 996         if (dbus_error_is_set(&err)) {
 997                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 998                 dbus_error_free(&err);
 999         }
1000
1001         if (NULL != result_msg) {
1002                 dbus_message_get_args(result_msg, &err,
1003                         DBUS_TYPE_INT32, &result,
1004                         DBUS_TYPE_INVALID);
1005
1006                 if (dbus_error_is_set(&err)) {
1007                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1008                         dbus_error_free(&err);
1009                         result = STT_ERROR_OPERATION_FAILED;
1010                 }
1011                 dbus_message_unref(result_msg);
1012
1013                 if (0 == result) {
1014                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1015                 } else {
1016                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1017                 }
1018         } else {
1019                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1020                 stt_dbus_reconnect();
1021                 result = STT_ERROR_TIMED_OUT;
1022         }
1023
1024         return result;
1025 }
1026
1027 int stt_dbus_request_unset_start_sound(int uid)
1028 {
1029         DBusMessage* msg;
1030
1031         msg = dbus_message_new_method_call(
1032                    STT_SERVER_SERVICE_NAME,
1033                    STT_SERVER_SERVICE_OBJECT_PATH,
1034                    STT_SERVER_SERVICE_INTERFACE,
1035                    STT_METHOD_UNSET_START_SOUND);
1036
1037         if (NULL == msg) {
1038                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1039                 return STT_ERROR_OPERATION_FAILED;
1040         } else {
1041                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1042         }
1043
1044         dbus_message_append_args(msg,
1045                 DBUS_TYPE_INT32, &uid,
1046                 DBUS_TYPE_INVALID);
1047
1048         DBusError err;
1049         dbus_error_init(&err);
1050
1051         DBusMessage* result_msg;
1052         int result = STT_ERROR_OPERATION_FAILED;
1053
1054         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1055         dbus_message_unref(msg);
1056         if (dbus_error_is_set(&err)) {
1057                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1058                 dbus_error_free(&err);
1059         }
1060
1061         if (NULL != result_msg) {
1062                 dbus_message_get_args(result_msg, &err,
1063                         DBUS_TYPE_INT32, &result,
1064                         DBUS_TYPE_INVALID);
1065
1066                 if (dbus_error_is_set(&err)) {
1067                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1068                         dbus_error_free(&err);
1069                         result = STT_ERROR_OPERATION_FAILED;
1070                 }
1071                 dbus_message_unref(result_msg);
1072
1073                 if (0 == result) {
1074                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1075                 } else {
1076                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1077                 }
1078         } else {
1079                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1080                 stt_dbus_reconnect();
1081                 result = STT_ERROR_TIMED_OUT;
1082         }
1083
1084         return result;
1085 }
1086
1087 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1088 {
1089         if (NULL == file) {
1090                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1091                 return STT_ERROR_INVALID_PARAMETER;
1092         }
1093
1094         DBusMessage* msg;
1095
1096         msg = dbus_message_new_method_call(
1097                    STT_SERVER_SERVICE_NAME,
1098                    STT_SERVER_SERVICE_OBJECT_PATH,
1099                    STT_SERVER_SERVICE_INTERFACE,
1100                    STT_METHOD_SET_STOP_SOUND);
1101
1102         if (NULL == msg) {
1103                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1104                 return STT_ERROR_OPERATION_FAILED;
1105         } else {
1106                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1107         }
1108
1109         dbus_message_append_args(msg,
1110                 DBUS_TYPE_INT32, &uid,
1111                 DBUS_TYPE_STRING, &file,
1112                 DBUS_TYPE_INVALID);
1113
1114         DBusError err;
1115         dbus_error_init(&err);
1116
1117         DBusMessage* result_msg;
1118         int result = STT_ERROR_OPERATION_FAILED;
1119
1120         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1121         dbus_message_unref(msg);
1122         if (dbus_error_is_set(&err)) {
1123                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1124                 dbus_error_free(&err);
1125         }
1126
1127         if (NULL != result_msg) {
1128                 dbus_message_get_args(result_msg, &err,
1129                         DBUS_TYPE_INT32, &result,
1130                         DBUS_TYPE_INVALID);
1131
1132                 if (dbus_error_is_set(&err)) {
1133                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1134                         dbus_error_free(&err);
1135                         result = STT_ERROR_OPERATION_FAILED;
1136                 }
1137                 dbus_message_unref(result_msg);
1138
1139                 if (0 == result) {
1140                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1141                 } else {
1142                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1143                 }
1144         } else {
1145                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1146                 stt_dbus_reconnect();
1147                 result = STT_ERROR_TIMED_OUT;
1148         }
1149
1150         return result;
1151 }
1152
1153 int stt_dbus_request_unset_stop_sound(int uid)
1154 {
1155         DBusMessage* msg;
1156
1157         msg = dbus_message_new_method_call(
1158                    STT_SERVER_SERVICE_NAME,
1159                    STT_SERVER_SERVICE_OBJECT_PATH,
1160                    STT_SERVER_SERVICE_INTERFACE,
1161                    STT_METHOD_UNSET_STOP_SOUND);
1162
1163         if (NULL == msg) {
1164                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1165                 return STT_ERROR_OPERATION_FAILED;
1166         } else {
1167                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1168         }
1169
1170         dbus_message_append_args(msg,
1171                 DBUS_TYPE_INT32, &uid,
1172                 DBUS_TYPE_INVALID);
1173
1174         DBusError err;
1175         dbus_error_init(&err);
1176
1177         DBusMessage* result_msg;
1178         int result = STT_ERROR_OPERATION_FAILED;
1179
1180         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1181         dbus_message_unref(msg);
1182         if (dbus_error_is_set(&err)) {
1183                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1184                 dbus_error_free(&err);
1185         }
1186
1187         if (NULL != result_msg) {
1188                 dbus_message_get_args(result_msg, &err,
1189                         DBUS_TYPE_INT32, &result,
1190                         DBUS_TYPE_INVALID);
1191
1192                 if (dbus_error_is_set(&err)) {
1193                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1194                         dbus_error_free(&err);
1195                         result = STT_ERROR_OPERATION_FAILED;
1196                 }
1197                 dbus_message_unref(result_msg);
1198
1199                 if (0 == result) {
1200                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1201                 } else {
1202                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1203                 }
1204         } else {
1205                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1206                 stt_dbus_reconnect();
1207                 result = STT_ERROR_TIMED_OUT;
1208         }
1209
1210         return result;
1211 }
1212
1213 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1214 {
1215         if (NULL == lang || NULL == type || NULL == appid) {
1216                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1217                 return STT_ERROR_INVALID_PARAMETER;
1218         }
1219
1220         DBusMessage* msg;
1221
1222         /* create a signal & check for errors */
1223         msg = dbus_message_new_method_call(
1224                 STT_SERVER_SERVICE_NAME,
1225                 STT_SERVER_SERVICE_OBJECT_PATH,
1226                 STT_SERVER_SERVICE_INTERFACE,
1227                 STT_METHOD_START);
1228
1229         if (NULL == msg) {
1230                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1231                 return STT_ERROR_OPERATION_FAILED;
1232         } else {
1233                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1234         }
1235
1236         if (NULL == credential)
1237                 credential = strdup("NULL");
1238
1239         dbus_message_append_args(msg,
1240                 DBUS_TYPE_INT32, &uid,
1241                 DBUS_TYPE_STRING, &lang,
1242                 DBUS_TYPE_STRING, &type,
1243                 DBUS_TYPE_INT32, &silence,
1244                 DBUS_TYPE_STRING, &appid,
1245                 DBUS_TYPE_STRING, &credential,
1246                 DBUS_TYPE_INVALID);
1247 #if 1
1248         if (g_conn_sender) {
1249                 dbus_message_set_no_reply(msg, TRUE);
1250
1251                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1252                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1253                         return STT_ERROR_OUT_OF_MEMORY;
1254                 } else {
1255                         dbus_connection_flush(g_conn_sender);
1256                 }
1257
1258                 dbus_message_unref(msg);
1259
1260         } else {
1261                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1262                 return STT_ERROR_OPERATION_FAILED;
1263         }
1264
1265         return 0;
1266 #else
1267         DBusError err;
1268         dbus_error_init(&err);
1269
1270         DBusMessage* result_msg;
1271         int result = STT_ERROR_OPERATION_FAILED;
1272
1273         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1274         dbus_message_unref(msg);
1275         if (dbus_error_is_set(&err)) {
1276                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1277                 dbus_error_free(&err);
1278         }
1279
1280         if (NULL != result_msg) {
1281                 dbus_message_get_args(result_msg, &err,
1282                         DBUS_TYPE_INT32, &result,
1283                         DBUS_TYPE_INVALID);
1284
1285                 if (dbus_error_is_set(&err)) {
1286                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1287                         dbus_error_free(&err);
1288                         result = STT_ERROR_OPERATION_FAILED;
1289                 }
1290                 dbus_message_unref(result_msg);
1291
1292                 if (0 == result) {
1293                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1294                 } else {
1295                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1296                 }
1297         } else {
1298                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1299                 stt_dbus_reconnect();
1300                 result = STT_ERROR_TIMED_OUT;
1301         }
1302
1303         return result;
1304 #endif
1305 }
1306
1307 int stt_dbus_request_stop(int uid)
1308 {
1309         DBusMessage* msg;
1310
1311         /* create a signal & check for errors */
1312         msg = dbus_message_new_method_call(
1313                 STT_SERVER_SERVICE_NAME,
1314                 STT_SERVER_SERVICE_OBJECT_PATH,
1315                 STT_SERVER_SERVICE_INTERFACE,
1316                 STT_METHOD_STOP);
1317
1318         if (NULL == msg) {
1319                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1320                 return STT_ERROR_OPERATION_FAILED;
1321         } else {
1322                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1323         }
1324
1325         dbus_message_append_args(msg,
1326                 DBUS_TYPE_INT32, &uid,
1327                 DBUS_TYPE_INVALID);
1328 #if 1
1329         if (g_conn_sender) {
1330                 dbus_message_set_no_reply(msg, TRUE);
1331
1332                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1333                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1334                         return STT_ERROR_OUT_OF_MEMORY;
1335                 } else {
1336                         dbus_connection_flush(g_conn_sender);
1337                 }
1338
1339                 dbus_message_unref(msg);
1340         } else {
1341                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1342                 return STT_ERROR_OPERATION_FAILED;
1343         }
1344
1345         return 0;
1346 #else
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 stop : result = %d ", result);
1374                 } else {
1375                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : 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 #endif
1385 }
1386
1387 int stt_dbus_request_cancel(int uid)
1388 {
1389         DBusMessage* msg;
1390
1391         /* create a signal & check for errors */
1392         msg = dbus_message_new_method_call(
1393                 STT_SERVER_SERVICE_NAME,
1394                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1395                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
1396                 STT_METHOD_CANCEL);     /* name of the signal */
1397
1398         if (NULL == msg) {
1399                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1400                 return STT_ERROR_OPERATION_FAILED;
1401         } else {
1402                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1403         }
1404
1405         dbus_message_append_args(msg,
1406                 DBUS_TYPE_INT32, &uid,
1407                 DBUS_TYPE_INVALID);
1408 #if 1
1409         if (g_conn_sender) {
1410                 dbus_message_set_no_reply(msg, TRUE);
1411
1412                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1413                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1414                         return STT_ERROR_OUT_OF_MEMORY;
1415                 } else {
1416                         dbus_connection_flush(g_conn_sender);
1417                 }
1418
1419                 dbus_message_unref(msg);
1420         } else {
1421                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1422                 return STT_ERROR_OPERATION_FAILED;
1423         }
1424
1425         return 0;
1426 #else
1427         DBusError err;
1428         dbus_error_init(&err);
1429
1430         DBusMessage* result_msg;
1431         int result = STT_ERROR_OPERATION_FAILED;
1432
1433         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1434         dbus_message_unref(msg);
1435         if (dbus_error_is_set(&err)) {
1436                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1437                 dbus_error_free(&err);
1438         }
1439
1440         if (NULL != result_msg) {
1441                 dbus_message_get_args(result_msg, &err,
1442                         DBUS_TYPE_INT32, &result,
1443                         DBUS_TYPE_INVALID);
1444
1445                 if (dbus_error_is_set(&err)) {
1446                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1447                         dbus_error_free(&err);
1448                         result = STT_ERROR_OPERATION_FAILED;
1449                 }
1450                 dbus_message_unref(result_msg);
1451
1452                 if (0 == result) {
1453                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1454                 } else {
1455                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1456                 }
1457         } else {
1458                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1459                 stt_dbus_reconnect();
1460                 result = STT_ERROR_TIMED_OUT;
1461         }
1462
1463         return result;
1464 #endif
1465 }