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_set_private_data(int uid, const char* key, const char* data)
 893 {
 894         if (NULL == key || NULL == data) {
 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_SET_PRIVATE_DATA);
 906
 907         if (NULL == msg) {
 908                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
 909                 return STT_ERROR_OPERATION_FAILED;
 910         } else {
 911                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
 912         }
 913
 914         if (true != dbus_message_append_args(msg,
 915                         DBUS_TYPE_INT32, &uid,
 916                         DBUS_TYPE_STRING, &key,
 917                         DBUS_TYPE_STRING, &data,
 918                         DBUS_TYPE_INVALID)) {
 919                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
 920                 return STT_ERROR_OPERATION_FAILED;
 921         }
 922
 923         DBusError err;
 924         dbus_error_init(&err);
 925
 926         DBusMessage* result_msg;
 927         int result = STT_ERROR_OPERATION_FAILED;
 928
 929         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 930         dbus_message_unref(msg);
 931         if (dbus_error_is_set(&err)) {
 932                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 933                 dbus_error_free(&err);
 934         }
 935
 936         if (NULL != result_msg) {
 937                 dbus_message_get_args(result_msg, &err,
 938                         DBUS_TYPE_INT32, &result,
 939                         DBUS_TYPE_INVALID);
 940
 941                 if (dbus_error_is_set(&err)) {
 942                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 943                         dbus_error_free(&err);
 944                         result = STT_ERROR_OPERATION_FAILED;
 945                 }
 946                 dbus_message_unref(result_msg);
 947
 948                 if (0 == result) {
 949                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
 950                 } else {
 951                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
 952                 }
 953         } else {
 954                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 955                 stt_dbus_reconnect();
 956                 result = STT_ERROR_TIMED_OUT;
 957         }
 958
 959         return result;
 960 }
 961
 962 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
 963 {
 964         if (NULL == key || NULL == data) {
 965                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
 966                 return STT_ERROR_INVALID_PARAMETER;
 967         }
 968
 969         DBusMessage* msg;
 970
 971         msg = dbus_message_new_method_call(
 972                 STT_SERVER_SERVICE_NAME,
 973                 STT_SERVER_SERVICE_OBJECT_PATH,
 974                 STT_SERVER_SERVICE_INTERFACE,
 975                 STT_METHOD_GET_PRIVATE_DATA);
 976
 977         if (NULL == msg) {
 978                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
 979                 return STT_ERROR_OPERATION_FAILED;
 980         } else {
 981                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
 982         }
 983
 984         if (true != dbus_message_append_args(msg,
 985                         DBUS_TYPE_INT32, &uid,
 986                         DBUS_TYPE_STRING, &key,
 987                         DBUS_TYPE_INVALID)) {
 988                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
 989                 return STT_ERROR_OPERATION_FAILED;
 990         }
 991
 992         DBusError err;
 993         dbus_error_init(&err);
 994
 995         DBusMessage* result_msg;
 996         int result = STT_ERROR_OPERATION_FAILED;
 997
 998         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 999         dbus_message_unref(msg);
1000         if (dbus_error_is_set(&err)) {
1001                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1002                 dbus_error_free(&err);
1003         }
1004
1005         char* temp = NULL;
1006         if (NULL != result_msg) {
1007                 dbus_message_get_args(result_msg, &err,
1008                         DBUS_TYPE_INT32, &result,
1009                         DBUS_TYPE_STRING, &temp,
1010                         DBUS_TYPE_INVALID);
1011
1012                 if (dbus_error_is_set(&err)) {
1013                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1014                         dbus_error_free(&err);
1015                         result = STT_ERROR_OPERATION_FAILED;
1016                 }
1017                 dbus_message_unref(result_msg);
1018
1019                 if (0 == result) {
1020                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1021                         if (NULL != temp) {
1022                                 *data = strdup(temp);
1023                                 free(temp);
1024                                 temp = NULL;
1025                         }
1026                 } else {
1027                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1028                 }
1029         } else {
1030                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1031                 stt_dbus_reconnect();
1032                 result = STT_ERROR_TIMED_OUT;
1033         }
1034
1035         return result;
1036 }
1037
1038
1039
1040 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1041 {
1042         if (NULL == support || NULL == type) {
1043                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1044                 return STT_ERROR_INVALID_PARAMETER;
1045         }
1046
1047         DBusMessage* msg;
1048
1049         msg = dbus_message_new_method_call(
1050                    STT_SERVER_SERVICE_NAME,
1051                    STT_SERVER_SERVICE_OBJECT_PATH,
1052                    STT_SERVER_SERVICE_INTERFACE,
1053                    STT_METHOD_IS_TYPE_SUPPORTED);
1054
1055         if (NULL == msg) {
1056                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1057                 return STT_ERROR_OPERATION_FAILED;
1058         } else {
1059                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1060         }
1061
1062         dbus_message_append_args(msg,
1063                 DBUS_TYPE_INT32, &uid,
1064                 DBUS_TYPE_STRING, &type,
1065                 DBUS_TYPE_INVALID);
1066
1067         DBusError err;
1068         dbus_error_init(&err);
1069
1070         DBusMessage* result_msg;
1071         int result = STT_ERROR_OPERATION_FAILED;
1072         int result_support = -1;
1073
1074         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1075         dbus_message_unref(msg);
1076         if (dbus_error_is_set(&err)) {
1077                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1078                 dbus_error_free(&err);
1079         }
1080
1081         if (NULL != result_msg) {
1082                 dbus_message_get_args(result_msg, &err,
1083                         DBUS_TYPE_INT32, &result,
1084                         DBUS_TYPE_INT32, &result_support,
1085                         DBUS_TYPE_INVALID);
1086
1087                 if (dbus_error_is_set(&err)) {
1088                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1089                         dbus_error_free(&err);
1090                         result = STT_ERROR_OPERATION_FAILED;
1091                 }
1092                 dbus_message_unref(result_msg);
1093
1094                 if (0 == result) {
1095                         *support = (bool)result_support;
1096                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1097                 } else {
1098                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1099                 }
1100         } else {
1101                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1102                 stt_dbus_reconnect();
1103                 result = STT_ERROR_TIMED_OUT;
1104         }
1105
1106         return result;
1107 }
1108
1109 int stt_dbus_request_set_start_sound(int uid, const char* file)
1110 {
1111         if (NULL == file) {
1112                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1113                 return STT_ERROR_INVALID_PARAMETER;
1114         }
1115
1116         DBusMessage* msg;
1117
1118         msg = dbus_message_new_method_call(
1119                    STT_SERVER_SERVICE_NAME,
1120                    STT_SERVER_SERVICE_OBJECT_PATH,
1121                    STT_SERVER_SERVICE_INTERFACE,
1122                    STT_METHOD_SET_START_SOUND);
1123
1124         if (NULL == msg) {
1125                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1126                 return STT_ERROR_OPERATION_FAILED;
1127         } else {
1128                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1129         }
1130
1131         dbus_message_append_args(msg,
1132                 DBUS_TYPE_INT32, &uid,
1133                 DBUS_TYPE_STRING, &file,
1134                 DBUS_TYPE_INVALID);
1135
1136         DBusError err;
1137         dbus_error_init(&err);
1138
1139         DBusMessage* result_msg;
1140         int result = STT_ERROR_OPERATION_FAILED;
1141
1142         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1143         dbus_message_unref(msg);
1144         if (dbus_error_is_set(&err)) {
1145                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1146                 dbus_error_free(&err);
1147         }
1148
1149         if (NULL != result_msg) {
1150                 dbus_message_get_args(result_msg, &err,
1151                         DBUS_TYPE_INT32, &result,
1152                         DBUS_TYPE_INVALID);
1153
1154                 if (dbus_error_is_set(&err)) {
1155                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1156                         dbus_error_free(&err);
1157                         result = STT_ERROR_OPERATION_FAILED;
1158                 }
1159                 dbus_message_unref(result_msg);
1160
1161                 if (0 == result) {
1162                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1163                 } else {
1164                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1165                 }
1166         } else {
1167                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1168                 stt_dbus_reconnect();
1169                 result = STT_ERROR_TIMED_OUT;
1170         }
1171
1172         return result;
1173 }
1174
1175 int stt_dbus_request_unset_start_sound(int uid)
1176 {
1177         DBusMessage* msg;
1178
1179         msg = dbus_message_new_method_call(
1180                    STT_SERVER_SERVICE_NAME,
1181                    STT_SERVER_SERVICE_OBJECT_PATH,
1182                    STT_SERVER_SERVICE_INTERFACE,
1183                    STT_METHOD_UNSET_START_SOUND);
1184
1185         if (NULL == msg) {
1186                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1187                 return STT_ERROR_OPERATION_FAILED;
1188         } else {
1189                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1190         }
1191
1192         dbus_message_append_args(msg,
1193                 DBUS_TYPE_INT32, &uid,
1194                 DBUS_TYPE_INVALID);
1195
1196         DBusError err;
1197         dbus_error_init(&err);
1198
1199         DBusMessage* result_msg;
1200         int result = STT_ERROR_OPERATION_FAILED;
1201
1202         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1203         dbus_message_unref(msg);
1204         if (dbus_error_is_set(&err)) {
1205                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1206                 dbus_error_free(&err);
1207         }
1208
1209         if (NULL != result_msg) {
1210                 dbus_message_get_args(result_msg, &err,
1211                         DBUS_TYPE_INT32, &result,
1212                         DBUS_TYPE_INVALID);
1213
1214                 if (dbus_error_is_set(&err)) {
1215                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1216                         dbus_error_free(&err);
1217                         result = STT_ERROR_OPERATION_FAILED;
1218                 }
1219                 dbus_message_unref(result_msg);
1220
1221                 if (0 == result) {
1222                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1223                 } else {
1224                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1225                 }
1226         } else {
1227                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1228                 stt_dbus_reconnect();
1229                 result = STT_ERROR_TIMED_OUT;
1230         }
1231
1232         return result;
1233 }
1234
1235 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1236 {
1237         if (NULL == file) {
1238                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1239                 return STT_ERROR_INVALID_PARAMETER;
1240         }
1241
1242         DBusMessage* msg;
1243
1244         msg = dbus_message_new_method_call(
1245                    STT_SERVER_SERVICE_NAME,
1246                    STT_SERVER_SERVICE_OBJECT_PATH,
1247                    STT_SERVER_SERVICE_INTERFACE,
1248                    STT_METHOD_SET_STOP_SOUND);
1249
1250         if (NULL == msg) {
1251                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1252                 return STT_ERROR_OPERATION_FAILED;
1253         } else {
1254                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1255         }
1256
1257         dbus_message_append_args(msg,
1258                 DBUS_TYPE_INT32, &uid,
1259                 DBUS_TYPE_STRING, &file,
1260                 DBUS_TYPE_INVALID);
1261
1262         DBusError err;
1263         dbus_error_init(&err);
1264
1265         DBusMessage* result_msg;
1266         int result = STT_ERROR_OPERATION_FAILED;
1267
1268         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1269         dbus_message_unref(msg);
1270         if (dbus_error_is_set(&err)) {
1271                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1272                 dbus_error_free(&err);
1273         }
1274
1275         if (NULL != result_msg) {
1276                 dbus_message_get_args(result_msg, &err,
1277                         DBUS_TYPE_INT32, &result,
1278                         DBUS_TYPE_INVALID);
1279
1280                 if (dbus_error_is_set(&err)) {
1281                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1282                         dbus_error_free(&err);
1283                         result = STT_ERROR_OPERATION_FAILED;
1284                 }
1285                 dbus_message_unref(result_msg);
1286
1287                 if (0 == result) {
1288                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1289                 } else {
1290                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1291                 }
1292         } else {
1293                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1294                 stt_dbus_reconnect();
1295                 result = STT_ERROR_TIMED_OUT;
1296         }
1297
1298         return result;
1299 }
1300
1301 int stt_dbus_request_unset_stop_sound(int uid)
1302 {
1303         DBusMessage* msg;
1304
1305         msg = dbus_message_new_method_call(
1306                    STT_SERVER_SERVICE_NAME,
1307                    STT_SERVER_SERVICE_OBJECT_PATH,
1308                    STT_SERVER_SERVICE_INTERFACE,
1309                    STT_METHOD_UNSET_STOP_SOUND);
1310
1311         if (NULL == msg) {
1312                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1313                 return STT_ERROR_OPERATION_FAILED;
1314         } else {
1315                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1316         }
1317
1318         dbus_message_append_args(msg,
1319                 DBUS_TYPE_INT32, &uid,
1320                 DBUS_TYPE_INVALID);
1321
1322         DBusError err;
1323         dbus_error_init(&err);
1324
1325         DBusMessage* result_msg;
1326         int result = STT_ERROR_OPERATION_FAILED;
1327
1328         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1329         dbus_message_unref(msg);
1330         if (dbus_error_is_set(&err)) {
1331                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1332                 dbus_error_free(&err);
1333         }
1334
1335         if (NULL != result_msg) {
1336                 dbus_message_get_args(result_msg, &err,
1337                         DBUS_TYPE_INT32, &result,
1338                         DBUS_TYPE_INVALID);
1339
1340                 if (dbus_error_is_set(&err)) {
1341                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1342                         dbus_error_free(&err);
1343                         result = STT_ERROR_OPERATION_FAILED;
1344                 }
1345                 dbus_message_unref(result_msg);
1346
1347                 if (0 == result) {
1348                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1349                 } else {
1350                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1351                 }
1352         } else {
1353                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1354                 stt_dbus_reconnect();
1355                 result = STT_ERROR_TIMED_OUT;
1356         }
1357
1358         return result;
1359 }
1360
1361 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1362 {
1363         if (NULL == lang || NULL == type || NULL == appid) {
1364                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1365                 return STT_ERROR_INVALID_PARAMETER;
1366         }
1367
1368         DBusMessage* msg;
1369
1370         /* create a signal & check for errors */
1371         msg = dbus_message_new_method_call(
1372                 STT_SERVER_SERVICE_NAME,
1373                 STT_SERVER_SERVICE_OBJECT_PATH,
1374                 STT_SERVER_SERVICE_INTERFACE,
1375                 STT_METHOD_START);
1376
1377         if (NULL == msg) {
1378                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1379                 return STT_ERROR_OPERATION_FAILED;
1380         } else {
1381                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1382         }
1383
1384         char *temp = NULL;
1385         if (NULL == credential) {
1386                 temp = strdup("NULL");
1387         } else {
1388                 temp = strdup(credential);
1389         }
1390
1391         dbus_message_append_args(msg,
1392                 DBUS_TYPE_INT32, &uid,
1393                 DBUS_TYPE_STRING, &lang,
1394                 DBUS_TYPE_STRING, &type,
1395                 DBUS_TYPE_INT32, &silence,
1396                 DBUS_TYPE_STRING, &appid,
1397                 DBUS_TYPE_STRING, &temp,
1398                 DBUS_TYPE_INVALID);
1399 #if 1
1400         if (g_conn_sender) {
1401                 dbus_message_set_no_reply(msg, TRUE);
1402
1403                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1404                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1405                         if (NULL != temp) {
1406                                         free(temp);
1407                                         temp = NULL;
1408                         }
1409                         return STT_ERROR_OUT_OF_MEMORY;
1410                 } else {
1411                         dbus_connection_flush(g_conn_sender);
1412                 }
1413
1414                 dbus_message_unref(msg);
1415
1416         } else {
1417                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1418                 if (NULL != temp) {
1419                                 free(temp);
1420                                 temp = NULL;
1421                 }
1422                 return STT_ERROR_OPERATION_FAILED;
1423         }
1424
1425         if (NULL != temp) {
1426                         free(temp);
1427                         temp = NULL;
1428         }
1429         return 0;
1430 #else
1431         DBusError err;
1432         dbus_error_init(&err);
1433
1434         DBusMessage* result_msg;
1435         int result = STT_ERROR_OPERATION_FAILED;
1436
1437         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1438         dbus_message_unref(msg);
1439         if (dbus_error_is_set(&err)) {
1440                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1441                 dbus_error_free(&err);
1442         }
1443
1444         if (NULL != result_msg) {
1445                 dbus_message_get_args(result_msg, &err,
1446                         DBUS_TYPE_INT32, &result,
1447                         DBUS_TYPE_INVALID);
1448
1449                 if (dbus_error_is_set(&err)) {
1450                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1451                         dbus_error_free(&err);
1452                         result = STT_ERROR_OPERATION_FAILED;
1453                 }
1454                 dbus_message_unref(result_msg);
1455
1456                 if (0 == result) {
1457                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1458                 } else {
1459                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1460                 }
1461         } else {
1462                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1463                 stt_dbus_reconnect();
1464                 result = STT_ERROR_TIMED_OUT;
1465         }
1466
1467         return result;
1468 #endif
1469 }
1470
1471 int stt_dbus_request_stop(int uid)
1472 {
1473         DBusMessage* msg;
1474
1475         /* create a signal & check for errors */
1476         msg = dbus_message_new_method_call(
1477                 STT_SERVER_SERVICE_NAME,
1478                 STT_SERVER_SERVICE_OBJECT_PATH,
1479                 STT_SERVER_SERVICE_INTERFACE,
1480                 STT_METHOD_STOP);
1481
1482         if (NULL == msg) {
1483                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1484                 return STT_ERROR_OPERATION_FAILED;
1485         } else {
1486                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1487         }
1488
1489         dbus_message_append_args(msg,
1490                 DBUS_TYPE_INT32, &uid,
1491                 DBUS_TYPE_INVALID);
1492 #if 1
1493         if (g_conn_sender) {
1494                 dbus_message_set_no_reply(msg, TRUE);
1495
1496                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1497                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1498                         return STT_ERROR_OUT_OF_MEMORY;
1499                 } else {
1500                         dbus_connection_flush(g_conn_sender);
1501                 }
1502
1503                 dbus_message_unref(msg);
1504         } else {
1505                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1506                 return STT_ERROR_OPERATION_FAILED;
1507         }
1508
1509         return 0;
1510 #else
1511         DBusError err;
1512         dbus_error_init(&err);
1513
1514         DBusMessage* result_msg;
1515         int result = STT_ERROR_OPERATION_FAILED;
1516
1517         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1518         dbus_message_unref(msg);
1519         if (dbus_error_is_set(&err)) {
1520                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1521                 dbus_error_free(&err);
1522         }
1523
1524         if (NULL != result_msg) {
1525                 dbus_message_get_args(result_msg, &err,
1526                         DBUS_TYPE_INT32, &result,
1527                         DBUS_TYPE_INVALID);
1528
1529                 if (dbus_error_is_set(&err)) {
1530                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1531                         dbus_error_free(&err);
1532                         result = STT_ERROR_OPERATION_FAILED;
1533                 }
1534                 dbus_message_unref(result_msg);
1535
1536                 if (0 == result) {
1537                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1538                 } else {
1539                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1540                 }
1541         } else {
1542                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1543                 stt_dbus_reconnect();
1544                 result = STT_ERROR_TIMED_OUT;
1545         }
1546
1547         return result;
1548 #endif
1549 }
1550
1551 int stt_dbus_request_cancel(int uid)
1552 {
1553         DBusMessage* msg;
1554
1555         /* create a signal & check for errors */
1556         msg = dbus_message_new_method_call(
1557                 STT_SERVER_SERVICE_NAME,
1558                 STT_SERVER_SERVICE_OBJECT_PATH, /* object name of the signal */
1559                 STT_SERVER_SERVICE_INTERFACE,   /* interface name of the signal */
1560                 STT_METHOD_CANCEL);     /* name of the signal */
1561
1562         if (NULL == msg) {
1563                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1564                 return STT_ERROR_OPERATION_FAILED;
1565         } else {
1566                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1567         }
1568
1569         dbus_message_append_args(msg,
1570                 DBUS_TYPE_INT32, &uid,
1571                 DBUS_TYPE_INVALID);
1572 #if 1
1573         if (g_conn_sender) {
1574                 dbus_message_set_no_reply(msg, TRUE);
1575
1576                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1577                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1578                         return STT_ERROR_OUT_OF_MEMORY;
1579                 } else {
1580                         dbus_connection_flush(g_conn_sender);
1581                 }
1582
1583                 dbus_message_unref(msg);
1584         } else {
1585                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1586                 return STT_ERROR_OPERATION_FAILED;
1587         }
1588
1589         return 0;
1590 #else
1591         DBusError err;
1592         dbus_error_init(&err);
1593
1594         DBusMessage* result_msg;
1595         int result = STT_ERROR_OPERATION_FAILED;
1596
1597         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1598         dbus_message_unref(msg);
1599         if (dbus_error_is_set(&err)) {
1600                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1601                 dbus_error_free(&err);
1602         }
1603
1604         if (NULL != result_msg) {
1605                 dbus_message_get_args(result_msg, &err,
1606                         DBUS_TYPE_INT32, &result,
1607                         DBUS_TYPE_INVALID);
1608
1609                 if (dbus_error_is_set(&err)) {
1610                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1611                         dbus_error_free(&err);
1612                         result = STT_ERROR_OPERATION_FAILED;
1613                 }
1614                 dbus_message_unref(result_msg);
1615
1616                 if (0 == result) {
1617                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1618                 } else {
1619                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
1620                 }
1621         } else {
1622                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1623                 stt_dbus_reconnect();
1624                 result = STT_ERROR_TIMED_OUT;
1625         }
1626
1627         return result;
1628 #endif
1629 }