client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2016 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 #include <vconf/vconf.h>
  22 #include <buxton2.h>
  23
  24 static int g_waiting_time = 3000;
  25 static int g_waiting_short_time = 500;
  26
  27 static char* g_server_service_name = NULL;
  28 static char* g_server_service_object = NULL;
  29 static char* g_server_service_interface = NULL;
  30
  31 static Ecore_Fd_Handler* g_fd_handler = NULL;
  32
  33 static DBusConnection* g_conn_sender = NULL;
  34 static DBusConnection* g_conn_listener = NULL;
  35
  36 void __stt_dbus_service_free();
  37
  38 extern int __stt_cb_error(int uid, int reason, char* err_msg);
  39
  40 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
  41
  42 extern int __stt_cb_set_state(int uid, int state);
  43
  44 extern int __stt_cb_set_volume(int uid, float volume);
  45
  46 extern int __stt_cb_speech_status(int uid, int status);
  47
  48 char* __stt_get_service_name(char* engine_id)
  49 {
  50         char* service_name = NULL;
  51         const char* engine_default = NULL;
  52
  53         struct buxton_client * bux_cli;
  54         struct buxton_layer * bux_layer;
  55         struct buxton_value * bux_val;
  56
  57         int ret = buxton_open(&bux_cli, NULL, NULL);
  58         if (0 != ret) {
  59                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
  60                 return NULL;
  61         }
  62         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_open: %d", ret);
  63         bux_layer = buxton_create_layer("system");
  64         if (NULL == bux_layer) {
  65                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
  66                 buxton_close(bux_cli);
  67                 bux_cli = NULL;
  68                 return NULL;
  69         }
  70
  71         bux_val = buxton_value_create_string("stt-engine-default");
  72         if (NULL == bux_val) {
  73                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
  74                 buxton_free_layer(bux_layer);
  75                 buxton_close(bux_cli);
  76                 bux_layer = NULL;
  77                 bux_cli = NULL;
  78                 return NULL;
  79         }
  80
  81         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
  82         if (0 != ret) {
  83                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
  84                 buxton_value_free(bux_val);
  85                 buxton_free_layer(bux_layer);
  86                 buxton_close(bux_cli);
  87
  88                 bux_cli = NULL;
  89                 bux_layer = NULL;
  90                 bux_val = NULL;
  91                 return NULL;
  92         }
  93         ret = buxton_value_get_string(bux_val, &engine_default);
  94         if (0 != ret) {
  95                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value string, ret(%d)", ret);
  96                 buxton_value_free(bux_val);
  97                 buxton_free_layer(bux_layer);
  98                 buxton_close(bux_cli);
  99
 100                 bux_cli = NULL;
 101                 bux_layer = NULL;
 102                 bux_val = NULL;
 103                 return NULL;
 104         }
 105         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 106
 107
 108         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 109                 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + 1, sizeof(char));
 110                 if (NULL == service_name) {
 111                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 112                         buxton_value_free(bux_val);
 113                         buxton_free_layer(bux_layer);
 114                         buxton_close(bux_cli);
 115
 116                         bux_cli = NULL;
 117                         bux_layer = NULL;
 118                         bux_val = NULL;
 119                         return NULL;
 120                 }
 121                 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + 1, "%s", STT_SERVER_SERVICE_NAME);
 122         } else {
 123                 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, sizeof(char));
 124                 if (NULL == service_name) {
 125                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 126                         buxton_value_free(bux_val);
 127                         buxton_free_layer(bux_layer);
 128                         buxton_close(bux_cli);
 129
 130                         bux_cli = NULL;
 131                         bux_layer = NULL;
 132                         bux_val = NULL;
 133                         return NULL;
 134                 }
 135                 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_NAME, ".", (engine_id + 10));
 136         }
 137
 138         buxton_value_free(bux_val);
 139         buxton_free_layer(bux_layer);
 140         buxton_close(bux_cli);
 141
 142         bux_cli = NULL;
 143         bux_layer = NULL;
 144         bux_val = NULL;
 145
 146         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_name] FINISH!! service name: %s", service_name);
 147
 148         return service_name;
 149 }
 150
 151 char* __stt_get_service_object(char* engine_id)
 152 {
 153         char* service_object = NULL;
 154         const char* engine_default = NULL;
 155
 156         struct buxton_client * bux_cli;
 157         struct buxton_layer * bux_layer;
 158         struct buxton_value * bux_val;
 159
 160         int ret = buxton_open(&bux_cli, NULL, NULL);
 161         if (0 != ret) {
 162                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
 163                 return NULL;
 164         }
 165         bux_layer = buxton_create_layer("system");
 166         if (NULL == bux_layer) {
 167                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
 168                 buxton_close(bux_cli);
 169                 bux_cli = NULL;
 170                 return NULL;
 171         }
 172
 173         bux_val = buxton_value_create_string("stt-engine-default");
 174         if (NULL == bux_val) {
 175                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
 176                 buxton_free_layer(bux_layer);
 177                 buxton_close(bux_cli);
 178                 bux_layer = NULL;
 179                 bux_cli = NULL;
 180                 return NULL;
 181         }
 182
 183         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
 184         if (0 != ret) {
 185                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
 186                 buxton_value_free(bux_val);
 187                 buxton_free_layer(bux_layer);
 188                 buxton_close(bux_cli);
 189
 190                 bux_cli = NULL;
 191                 bux_layer = NULL;
 192                 bux_val = NULL;
 193                 return NULL;
 194         }
 195         ret = buxton_value_get_string(bux_val, &engine_default);
 196         if (0 != ret) {
 197                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
 198                 buxton_value_free(bux_val);
 199                 buxton_free_layer(bux_layer);
 200                 buxton_close(bux_cli);
 201
 202                 bux_cli = NULL;
 203                 bux_layer = NULL;
 204                 bux_val = NULL;
 205                 return NULL;
 206         }
 207         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 208
 209         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 210                 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, sizeof(char));
 211                 if (NULL == service_object) {
 212                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 213                         buxton_value_free(bux_val);
 214                         buxton_free_layer(bux_layer);
 215                         buxton_close(bux_cli);
 216
 217                         bux_cli = NULL;
 218                         bux_layer = NULL;
 219                         bux_val = NULL;
 220                         return NULL;
 221                 }
 222                 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, "%s", STT_SERVER_SERVICE_OBJECT_PATH);
 223         } else {
 224                 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, sizeof(char));
 225                 if (NULL == service_object) {
 226                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 227                         buxton_value_free(bux_val);
 228                         buxton_free_layer(bux_layer);
 229                         buxton_close(bux_cli);
 230
 231                         bux_cli = NULL;
 232                         bux_layer = NULL;
 233                         bux_val = NULL;
 234                         return NULL;
 235                 }
 236                 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_OBJECT_PATH, "/", (engine_id + 10));
 237         }
 238
 239         buxton_value_free(bux_val);
 240         buxton_free_layer(bux_layer);
 241         buxton_close(bux_cli);
 242
 243         bux_cli = NULL;
 244         bux_layer = NULL;
 245         bux_val = NULL;
 246
 247         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_object] FINISH!! service object: %s", service_object);
 248
 249         return service_object;
 250 }
 251
 252 char* __stt_get_service_interface(char* engine_id)
 253 {
 254         char* service_interface = NULL;
 255         const char* engine_default = NULL;
 256
 257         struct buxton_client * bux_cli;
 258         struct buxton_layer * bux_layer;
 259         struct buxton_value * bux_val;
 260
 261         int ret = buxton_open(&bux_cli, NULL, NULL);
 262         if (0 != ret) {
 263                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
 264                 return NULL;
 265         }
 266         bux_layer = buxton_create_layer("system");
 267         if (NULL == bux_layer) {
 268                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
 269                 buxton_close(bux_cli);
 270                 bux_cli = NULL;
 271                 return NULL;
 272         }
 273
 274         bux_val = buxton_value_create_string("stt-engine-default");
 275         if (NULL == bux_val) {
 276                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
 277                 buxton_free_layer(bux_layer);
 278                 buxton_close(bux_cli);
 279                 bux_layer = NULL;
 280                 bux_cli = NULL;
 281                 return NULL;
 282         }
 283
 284         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
 285         if (0 != ret) {
 286                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
 287                 buxton_value_free(bux_val);
 288                 buxton_free_layer(bux_layer);
 289                 buxton_close(bux_cli);
 290
 291                 bux_cli = NULL;
 292                 bux_layer = NULL;
 293                 bux_val = NULL;
 294                 return NULL;
 295         }
 296         ret = buxton_value_get_string(bux_val, &engine_default);
 297         if (0 != ret) {
 298                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
 299                 buxton_value_free(bux_val);
 300                 buxton_free_layer(bux_layer);
 301                 buxton_close(bux_cli);
 302
 303                 bux_cli = NULL;
 304                 bux_layer = NULL;
 305                 bux_val = NULL;
 306                 return NULL;
 307         }
 308         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 309
 310         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 311                 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + 1, sizeof(char));
 312                 if (NULL == service_interface) {
 313                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 314                         buxton_value_free(bux_val);
 315                         buxton_free_layer(bux_layer);
 316                         buxton_close(bux_cli);
 317
 318                         bux_cli = NULL;
 319                         bux_layer = NULL;
 320                         bux_val = NULL;
 321                         return NULL;
 322                 }
 323                 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + 1, "%s", STT_SERVER_SERVICE_INTERFACE);
 324         } else {
 325                 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, sizeof(char));
 326                 if (NULL == service_interface) {
 327                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 328                         buxton_value_free(bux_val);
 329                         buxton_free_layer(bux_layer);
 330                         buxton_close(bux_cli);
 331
 332                         bux_cli = NULL;
 333                         bux_layer = NULL;
 334                         bux_val = NULL;
 335                         return NULL;
 336                 }
 337                 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_INTERFACE, ".", (engine_id + 10));
 338         }
 339
 340         char* ret_char = strchr(service_interface, '-');
 341         while (NULL != ret_char) {
 342                 ret_char[0] = '_';
 343                 ret_char = strchr(service_interface, '-');
 344         }
 345
 346         buxton_value_free(bux_val);
 347         buxton_free_layer(bux_layer);
 348         ret = buxton_close(bux_cli);
 349
 350         bux_cli = NULL;
 351         bux_layer = NULL;
 352         bux_val = NULL;
 353
 354         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_interface] FINISH!! service interface: %s", service_interface);
 355
 356         return service_interface;
 357 }
 358
 359
 360 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 361 {
 362         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 363
 364         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 365
 366         while (1) {
 367                 DBusMessage* msg = NULL;
 368                 msg = dbus_connection_pop_message(g_conn_listener);
 369
 370                 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
 371                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
 372                         break;
 373                 }
 374
 375                 /* loop again if we haven't read a message */
 376                 if (NULL == msg) {
 377                         break;
 378                 }
 379
 380                 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Message is arrived");
 381
 382                 DBusError err;
 383                 dbus_error_init(&err);
 384
 385                 DBusMessage *reply = NULL;
 386
 387                 char if_name[64];
 388                 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
 389
 390                 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
 391                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
 392                         int uid = 0;
 393                         int response = -1;
 394
 395                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 396                         if (dbus_error_is_set(&err)) {
 397                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 398                                 dbus_error_free(&err);
 399                         }
 400
 401                         if (uid > 0) {
 402                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
 403
 404                                 /* check uid */
 405                                 stt_client_s* client = stt_client_get_by_uid(uid);
 406                                 if (NULL != client)
 407                                         response = 1;
 408                                 else
 409                                         response = 0;
 410                         } else {
 411                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
 412                         }
 413
 414                         reply = dbus_message_new_method_return(msg);
 415
 416                         if (NULL != reply) {
 417                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 418
 419                                 if (!dbus_connection_send(g_conn_listener, reply, NULL))
 420                                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
 421                                 else
 422                                         SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
 423
 424                                 dbus_connection_flush(g_conn_listener);
 425                                 dbus_message_unref(reply);
 426                         } else {
 427                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 428                         }
 429
 430                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 431                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 432                 } /* STTD_METHOD_HELLO */
 433
 434                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
 435                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
 436                         int uid = 0;
 437                         int state = -1;
 438
 439                         dbus_message_get_args(msg, &err,
 440                                 DBUS_TYPE_INT32, &uid,
 441                                 DBUS_TYPE_INT32, &state,
 442                                 DBUS_TYPE_INVALID);
 443
 444                         if (dbus_error_is_set(&err)) {
 445                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 446                                 dbus_error_free(&err);
 447                         }
 448
 449                         if (uid > 0 && state >= 0) {
 450                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
 451                                 __stt_cb_set_state(uid, state);
 452                         } else {
 453                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
 454                         }
 455
 456                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 457                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 458                 } /* STTD_METHOD_SET_STATE */
 459
 460                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
 461                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
 462                         int uid = 0;
 463                         float volume = 0;
 464
 465                         dbus_message_get_args(msg, &err,
 466                                 DBUS_TYPE_INT32, &uid,
 467                                 DBUS_TYPE_INT32, &volume,
 468                                 DBUS_TYPE_INVALID);
 469
 470                         if (dbus_error_is_set(&err)) {
 471                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 472                                 dbus_error_free(&err);
 473                         }
 474
 475                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
 476                         __stt_cb_set_volume(uid, volume);
 477
 478                         /* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
 479                         /* SLOG(LOG_DEBUG, TAG_STTC, " "); */
 480                 } /* STTD_METHOD_SET_VOLUME */
 481
 482                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
 483                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
 484                         int uid = 0;
 485                         DBusMessageIter args;
 486
 487                         dbus_message_iter_init(msg, &args);
 488
 489                         /* Get result */
 490                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 491                                 dbus_message_iter_get_basic(&args, &uid);
 492                                 dbus_message_iter_next(&args);
 493                         }
 494
 495                         stt_client_s* client = NULL;
 496                         client = stt_client_get_by_uid(uid);
 497                         if (NULL != client) {
 498                                 char** temp_result = NULL;
 499                                 char* temp_msg = NULL;
 500                                 char* temp_char = NULL;
 501                                 int temp_event = 0;
 502                                 int temp_count = 0;
 503                                 int temp_result_id = 0;
 504
 505                                 /* Get recognition type */
 506                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 507                                         dbus_message_iter_get_basic(&args, &temp_event);
 508                                         dbus_message_iter_next(&args);
 509                                 }
 510
 511                                 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 512                                         dbus_message_iter_get_basic(&args, &(temp_msg));
 513                                         dbus_message_iter_next(&args);
 514                                 }
 515
 516                                 /* Get voice size */
 517                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 518                                         dbus_message_iter_get_basic(&args, &temp_count);
 519                                         dbus_message_iter_next(&args);
 520                                 }
 521
 522                                 /* Get result id */
 523                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 524                                         dbus_message_iter_get_basic(&args, &temp_result_id);
 525                                         dbus_message_iter_next(&args);
 526                                 }
 527
 528                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
 529                                         uid, temp_event, temp_msg, temp_count, temp_result_id);
 530
 531                                 if (temp_count <= 0) {
 532                                         __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
 533                                 } else {
 534                                         temp_result = (char**)calloc(temp_count, sizeof(char*));
 535
 536                                         if (NULL == temp_result)        {
 537                                                 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
 538                                         } else {
 539                                                 int i = 0;
 540                                                 for (i = 0; i < temp_count; i++) {
 541                                                         dbus_message_iter_get_basic(&args, &(temp_char));
 542                                                         dbus_message_iter_next(&args);
 543
 544                                                         if (NULL != temp_char) {
 545                                                                 temp_result[i] = strdup(temp_char);
 546                                                                 SECURE_SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
 547                                                         }
 548                                                 }
 549
 550                                                 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
 551
 552                                                 for (i = 0; i < temp_count; i++) {
 553                                                         if (NULL != temp_result[i])
 554                                                                 free(temp_result[i]);
 555                                                 }
 556
 557                                                 free(temp_result);
 558                                         }
 559                                 }
 560                         } else {
 561                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
 562                         }
 563
 564                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 565                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 566                 } /* STTD_METHOD_RESULT */
 567
 568                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
 569                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
 570                         int uid;
 571                         int reason;
 572                         char* err_msg;
 573
 574                         dbus_message_get_args(msg, &err,
 575                                 DBUS_TYPE_INT32, &uid,
 576                                 DBUS_TYPE_INT32, &reason,
 577                                 DBUS_TYPE_STRING, &err_msg,
 578                                 DBUS_TYPE_INVALID);
 579
 580                         if (dbus_error_is_set(&err)) {
 581                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
 582                                 dbus_error_free(&err);
 583                         } else {
 584                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
 585                                 __stt_cb_error(uid, reason, err_msg);
 586                         }
 587
 588                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 589                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 590                 } /* STTD_METHOD_ERROR */
 591
 592                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SPEECH_STATUS)) {
 593                         SLOG(LOG_DEBUG, TAG_STTC, "===== Speech status");
 594                         int uid = 0;
 595                         int status = -1;
 596
 597                         dbus_message_get_args(msg, &err,
 598                                 DBUS_TYPE_INT32, &uid,
 599                                 DBUS_TYPE_INT32, &status,
 600                                 DBUS_TYPE_INVALID);
 601
 602                         if (dbus_error_is_set(&err)) {
 603                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 604                                 dbus_error_free(&err);
 605                         }
 606
 607                         if (uid > 0 && status >= 0) {
 608                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt speech status : uid(%d), status(%d)", uid, status);
 609                                 __stt_cb_speech_status(uid, status);
 610                         } else {
 611                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set status : invalid uid or status");
 612                         }
 613
 614                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 615                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 616                 } /* STTD_METHOD_SPEECH_STATUS */
 617
 618                 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 619                         SLOG(LOG_DEBUG, TAG_STTC, "===== Owner Changed");
 620                         DBusError err;
 621                         dbus_error_init(&err);
 622
 623                         /* remove a rule for daemon error */
 624                         char rule_err[256] = {0, };
 625                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
 626                         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
 627                         dbus_connection_flush(g_conn_listener);
 628                         if (dbus_error_is_set(&err)) {
 629                                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 630                                 dbus_error_free(&err);
 631                         }
 632
 633                         __stt_cb_error(-1, STT_ERROR_SERVICE_RESET, "Daemon Reset");
 634                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 635                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 636                 } /* NameOwnerChanged */
 637
 638                 else {
 639                         SLOG(LOG_DEBUG, TAG_STTC, "Message is NOT valid");
 640                         dbus_message_unref(msg);
 641                         break;
 642                 }
 643
 644                 /* free the message */
 645                 dbus_message_unref(msg);
 646         } /* while */
 647
 648         return ECORE_CALLBACK_RENEW;
 649 }
 650
 651 static void __stt_dbus_connection_free()
 652 {
 653         if (NULL != g_conn_listener) {
 654                 dbus_connection_close(g_conn_listener);
 655                 dbus_connection_unref(g_conn_listener);
 656                 g_conn_listener = NULL;
 657         }
 658         if (NULL != g_conn_sender) {
 659                 dbus_connection_close(g_conn_sender);
 660                 dbus_connection_unref(g_conn_sender);
 661                 g_conn_sender = NULL;
 662         }
 663 }
 664
 665 int stt_dbus_open_connection()
 666 {
 667         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 668                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 669                 return 0;
 670         }
 671
 672         DBusError err;
 673
 674         /* initialise the error value */
 675         dbus_error_init(&err);
 676
 677         /* connect to the DBUS system bus, and check for errors */
 678         if (NULL == g_conn_sender) {
 679                 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 680                 if (dbus_error_is_set(&err)) {
 681                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
 682                         dbus_error_free(&err);
 683                 }
 684         }
 685
 686         if (NULL == g_conn_sender) {
 687                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
 688                 return STT_ERROR_OPERATION_FAILED;
 689         }
 690
 691         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 692
 693         /* connect to the DBUS system bus, and check for errors */
 694         if (NULL == g_conn_listener) {
 695                 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 696                 if (dbus_error_is_set(&err)) {
 697                         SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
 698                         dbus_error_free(&err);
 699                 }
 700         }
 701
 702         if (NULL == g_conn_listener) {
 703                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 704                 __stt_dbus_connection_free();
 705                 return STT_ERROR_OPERATION_FAILED;
 706         }
 707
 708         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 709
 710         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 711
 712         int pid = getpid();
 713
 714         char service_name[64];
 715         memset(service_name, '\0', 64);
 716         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 717
 718         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
 719
 720         /* register our name on the bus, and check for errors */
 721         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 722
 723         if (dbus_error_is_set(&err)) {
 724                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
 725                 dbus_error_free(&err);
 726         }
 727
 728         char rule[128] = {0, };
 729         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 730
 731         /* add a rule for which messages we want to see */
 732         dbus_bus_add_match(g_conn_listener, rule, &err);
 733         dbus_connection_flush(g_conn_listener);
 734
 735         if (dbus_error_is_set(&err)) {
 736                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 737                 dbus_error_free(&err);
 738                 __stt_dbus_connection_free();
 739                 return STT_ERROR_OPERATION_FAILED;
 740         }
 741
 742         int fd = 0;
 743         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 744                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
 745                 __stt_dbus_connection_free();
 746                 return STT_ERROR_OPERATION_FAILED;
 747         } else {
 748                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
 749         }
 750
 751         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 752         if (NULL == g_fd_handler) {
 753                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 754                 __stt_dbus_connection_free();
 755                 return STT_ERROR_OPERATION_FAILED;
 756         }
 757
 758         return 0;
 759 }
 760
 761 int stt_dbus_close_connection()
 762 {
 763         DBusError err;
 764         dbus_error_init(&err);
 765
 766         if (NULL != g_fd_handler) {
 767                 ecore_main_fd_handler_del(g_fd_handler);
 768                 g_fd_handler = NULL;
 769         }
 770
 771         if (NULL != g_conn_listener) {
 772                 int pid = getpid();
 773
 774                 char service_name[64];
 775                 memset(service_name, '\0', 64);
 776                 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 777
 778                 dbus_bus_release_name(g_conn_listener, service_name, &err);
 779                 if (dbus_error_is_set(&err)) {
 780                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 781                         dbus_error_free(&err);
 782                 }
 783         }
 784
 785         __stt_dbus_connection_free();
 786         __stt_dbus_service_free();
 787
 788         return 0;
 789 }
 790
 791 int stt_dbus_reconnect()
 792 {
 793         if (!g_conn_sender || !g_conn_listener) {
 794                 stt_dbus_close_connection();
 795
 796                 if (0 != stt_dbus_open_connection()) {
 797                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 798                         return -1;
 799                 }
 800
 801                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 802                 return 0;
 803         }
 804
 805         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 806         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 807         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
 808                 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 809
 810         if (false == sender_connected || false == listener_connected) {
 811                 stt_dbus_close_connection();
 812
 813                 if (0 != stt_dbus_open_connection()) {
 814                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 815                         return -1;
 816                 }
 817
 818                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 819         }
 820
 821         return 0;
 822 }
 823
 824 void __stt_dbus_service_free()
 825 {
 826         if (NULL != g_server_service_name) {
 827                 free(g_server_service_name);
 828                 g_server_service_name = NULL;
 829         }
 830         if (NULL != g_server_service_object) {
 831                 free(g_server_service_object);
 832                 g_server_service_object = NULL;
 833         }
 834         if (NULL != g_server_service_interface) {
 835                 free(g_server_service_interface);
 836                 g_server_service_interface = NULL;
 837         }
 838 }
 839
 840 int stt_dbus_request_hello(int uid)
 841 {
 842         stt_client_s* client = stt_client_get_by_uid(uid);
 843
 844         /* Check whether there is any dbus whose name has owner or not */
 845         dbus_bool_t is_exist = FALSE;
 846         DBusError err;
 847         dbus_error_init(&err);
 848
 849         DBusMessage* msg = NULL;
 850         DBusMessage* result_msg = NULL;
 851         int result = 0;
 852
 853         if (g_conn_sender) {
 854                 if (NULL != client) {
 855                         __stt_dbus_service_free();
 856
 857                         if (NULL == client->current_engine_id) {
 858                                 /* Default engine */
 859                                 g_server_service_name = strdup(STT_SERVER_SERVICE_NAME);
 860                                 if (NULL == g_server_service_name) {
 861                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 862                                         return STT_ERROR_OUT_OF_MEMORY;
 863                                 }
 864                                 g_server_service_object = strdup(STT_SERVER_SERVICE_OBJECT_PATH);
 865                                 if (NULL == g_server_service_name) {
 866                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 867                                         return STT_ERROR_OUT_OF_MEMORY;
 868                                 }
 869                                 g_server_service_interface = strdup(STT_SERVER_SERVICE_INTERFACE);
 870                                 if (NULL == g_server_service_name) {
 871                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 872                                         return STT_ERROR_OUT_OF_MEMORY;
 873                                 }
 874
 875                                 msg = dbus_message_new_method_call(
 876                                         STT_SERVER_SERVICE_NAME,
 877                                         STT_SERVER_SERVICE_OBJECT_PATH,
 878                                         STT_SERVER_SERVICE_INTERFACE,
 879                                         STT_METHOD_HELLO);
 880                         } else {
 881                                 /* Get service name, object, interface */
 882                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] current_engine_id: %s", client->current_engine_id);
 883
 884                                 g_server_service_name = __stt_get_service_name(client->current_engine_id);
 885                                 g_server_service_object = __stt_get_service_object(client->current_engine_id);
 886                                 g_server_service_interface = __stt_get_service_interface(client->current_engine_id);
 887
 888                                 if (NULL == g_server_service_name || NULL == g_server_service_object || NULL == g_server_service_interface) {
 889                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] dbus service info invalid");
 890                                         return STT_ERROR_OPERATION_FAILED;
 891                                 }
 892
 893                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] service name: %s, object path: %s, interface: %s", g_server_service_name, g_server_service_object, g_server_service_interface);
 894
 895                                 /* Custom engine */
 896                                 is_exist = dbus_bus_name_has_owner(g_conn_sender, g_server_service_name, &err);
 897                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] is there dbus name has owner??: %s (g_server_service_name: %s)", (is_exist == TRUE) ? "True" : "False", g_server_service_name);
 898
 899                                 if (TRUE == is_exist) {
 900                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: True");
 901                                         msg = dbus_message_new_method_call(
 902                                                 g_server_service_name,
 903                                                 g_server_service_object,
 904                                                 g_server_service_interface,
 905                                                 STT_METHOD_HELLO);
 906                                 } else {
 907                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: False");
 908                                         msg = dbus_message_new_method_call(
 909                                                 STT_SERVER_CUSTOM_SERVICE_NAME,
 910                                                 STT_SERVER_CUSTOM_SERVICE_OBJECT_PATH,
 911                                                 STT_SERVER_CUSTOM_SERVICE_INTERFACE,
 912                                                 STT_METHOD_HELLO);
 913                                 }
 914                         }
 915                 }
 916         }
 917
 918         if (NULL == msg) {
 919 //              SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 920                 result = stt_dbus_reconnect();
 921                 if (0 != result)
 922                         return STT_ERROR_OPERATION_FAILED;
 923         }
 924
 925         if (g_conn_sender) {
 926                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, -1, &err);
 927                 dbus_message_unref(msg);
 928                 if (dbus_error_is_set(&err)) {
 929                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 930                         dbus_error_free(&err);
 931                 }
 932
 933                 if (NULL != result_msg) {
 934                         dbus_message_unref(result_msg);
 935
 936                         if (dbus_error_is_set(&err)) {
 937                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 938                                 dbus_error_free(&err);
 939                         }
 940
 941                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 942                 } else {
 943                         if (dbus_error_is_set(&err)) {
 944                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 945                                 dbus_error_free(&err);
 946                         }
 947
 948                         result = STT_ERROR_TIMED_OUT;
 949                 }
 950         } else {
 951                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 952                 stt_dbus_reconnect();
 953                 result = STT_ERROR_OPERATION_FAILED;
 954         }
 955
 956         return result;
 957 }
 958
 959
 960 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 961 {
 962         DBusMessage* msg;
 963
 964         msg = dbus_message_new_method_call(
 965                 g_server_service_name,
 966                 g_server_service_object,
 967                 g_server_service_interface,
 968                 STT_METHOD_INITIALIZE);
 969
 970         if (NULL == msg) {
 971                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 972                 return STT_ERROR_OPERATION_FAILED;
 973         } else {
 974                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 975         }
 976
 977         int pid = getpid();
 978         dbus_message_append_args(msg,
 979                 DBUS_TYPE_INT32, &pid,
 980                 DBUS_TYPE_INT32, &uid,
 981                 DBUS_TYPE_INVALID);
 982
 983         DBusError err;
 984         dbus_error_init(&err);
 985
 986         DBusMessage* result_msg;
 987         int result = STT_ERROR_OPERATION_FAILED;
 988
 989         if (g_conn_sender) {
 990                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 991                 dbus_message_unref(msg);
 992                 if (dbus_error_is_set(&err)) {
 993                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 994                         dbus_error_free(&err);
 995                 }
 996
 997                 if (NULL != result_msg) {
 998                         int int_silence_supported = 0;
 999                         int int_credential_needed = 0;
1000                         dbus_message_get_args(result_msg, &err,
1001                                 DBUS_TYPE_INT32, &result,
1002                                 DBUS_TYPE_INT32, &int_silence_supported,
1003                                 DBUS_TYPE_INT32, &int_credential_needed,
1004                                 DBUS_TYPE_INVALID);
1005
1006                         *silence_supported = (bool)(int_silence_supported);
1007                         *credential_needed = (bool)(int_credential_needed);
1008
1009                         if (dbus_error_is_set(&err)) {
1010                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1011                                 dbus_error_free(&err);
1012                                 result = STT_ERROR_OPERATION_FAILED;
1013                         }
1014
1015                         if (0 == result) {
1016                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
1017                                         result, *silence_supported, *credential_needed);
1018
1019                                 stt_client_s* client = stt_client_get_by_uid(uid);
1020                                 if (NULL == client) {
1021                                         SLOG(LOG_ERROR, TAG_STTC, "Fail to get STT client");
1022                                         return STT_ERROR_OPERATION_FAILED;
1023                                 }
1024
1025                                 if (STT_ERROR_SERVICE_RESET != client->reason) {
1026                                         /* add a rule for daemon error */
1027                                         char rule_err[256] = {0, };
1028
1029                                         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
1030                                         dbus_bus_add_match(g_conn_listener, rule_err, &err);
1031                                         dbus_connection_flush(g_conn_listener);
1032
1033                                         if (dbus_error_is_set(&err)) {
1034                                                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1035                                                 dbus_error_free(&err);
1036                                                 return STT_ERROR_OPERATION_FAILED;
1037                                         }
1038                                 }
1039                         } else {
1040                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
1041                         }
1042
1043                         dbus_message_unref(result_msg);
1044                 } else {
1045                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1046                         stt_dbus_reconnect();
1047                         result = STT_ERROR_TIMED_OUT;
1048                 }
1049         } else {
1050                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1051                 result = STT_ERROR_OPERATION_FAILED;
1052         }
1053
1054         return result;
1055 }
1056
1057 int stt_dbus_request_finalize(int uid)
1058 {
1059         DBusMessage* msg;
1060
1061         DBusError err;
1062         dbus_error_init(&err);
1063
1064         /* remove a rule for daemon error */
1065         char rule_err[256] = {0, };
1066         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", g_server_service_interface);
1067         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
1068         dbus_connection_flush(g_conn_listener);
1069         if (dbus_error_is_set(&err)) {
1070                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1071                 dbus_error_free(&err);
1072         }
1073
1074         SLOG(LOG_DEBUG, TAG_STTC, "[dbus_info] service name: %s, service object: %s, service interface: %s", g_server_service_name, g_server_service_object, g_server_service_interface);
1075
1076         msg = dbus_message_new_method_call(
1077                 g_server_service_name,
1078                 g_server_service_object,
1079                 g_server_service_interface,
1080                 STT_METHOD_FINALIZE);
1081
1082         if (NULL == msg) {
1083                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
1084                 return STT_ERROR_OPERATION_FAILED;
1085         } else {
1086                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
1087         }
1088
1089         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1090
1091         DBusMessage* result_msg;
1092         int result = STT_ERROR_OPERATION_FAILED;
1093
1094         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
1095         dbus_message_unref(msg);
1096         if (dbus_error_is_set(&err)) {
1097                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1098                 dbus_error_free(&err);
1099         }
1100
1101         if (NULL != result_msg) {
1102                 dbus_message_get_args(result_msg, &err,
1103                                 DBUS_TYPE_INT32, &result,
1104                                 DBUS_TYPE_INVALID);
1105
1106                 if (dbus_error_is_set(&err)) {
1107                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1108                         dbus_error_free(&err);
1109                         result = STT_ERROR_OPERATION_FAILED;
1110                 }
1111
1112                 dbus_message_unref(result_msg);
1113
1114                 if (0 == result) {
1115                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1116                 } else {
1117                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
1118                 }
1119         } else {
1120                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1121                 stt_dbus_reconnect();
1122                 result = STT_ERROR_TIMED_OUT;
1123         }
1124
1125         return result;
1126 }
1127
1128 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1129 {
1130         DBusMessage* msg;
1131
1132         msg = dbus_message_new_method_call(
1133                 g_server_service_name,
1134                 g_server_service_object,
1135                 g_server_service_interface,
1136                 STT_METHOD_SET_CURRENT_ENGINE);
1137
1138
1139         if (NULL == msg) {
1140                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1141                 return STT_ERROR_OPERATION_FAILED;
1142         } else {
1143                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1144         }
1145
1146         dbus_message_append_args(msg,
1147                 DBUS_TYPE_INT32, &uid,
1148                 DBUS_TYPE_STRING, &engine_id,
1149                 DBUS_TYPE_INVALID);
1150
1151         DBusError err;
1152         dbus_error_init(&err);
1153
1154         DBusMessage* result_msg;
1155         int result = STT_ERROR_OPERATION_FAILED;
1156
1157         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1158         dbus_message_unref(msg);
1159         if (dbus_error_is_set(&err)) {
1160                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1161                 dbus_error_free(&err);
1162         }
1163
1164         if (NULL != result_msg) {
1165                 int int_silence_supported = 0;
1166                 int int_credential_needed = 0;
1167
1168                 dbus_message_get_args(result_msg, &err,
1169                         DBUS_TYPE_INT32, &result,
1170                         DBUS_TYPE_INT32, &int_silence_supported,
1171                         DBUS_TYPE_INT32, &int_credential_needed,
1172                         DBUS_TYPE_INVALID);
1173
1174                 *silence_supported = (bool)(int_silence_supported);
1175                 *credential_needed = (bool)(int_credential_needed);
1176
1177                 if (dbus_error_is_set(&err)) {
1178                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1179                         dbus_error_free(&err);
1180                         result = STT_ERROR_OPERATION_FAILED;
1181                 }
1182
1183                 dbus_message_unref(result_msg);
1184
1185                 if (0 == result) {
1186                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1187                                 result, *silence_supported, *credential_needed);
1188                 } else {
1189                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1190                 }
1191         } else {
1192                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1193                 stt_dbus_reconnect();
1194                 result = STT_ERROR_TIMED_OUT;
1195         }
1196
1197         return result;
1198 }
1199
1200 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1201 {
1202         if (NULL == appid || NULL == value) {
1203                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1204                 return STT_ERROR_INVALID_PARAMETER;
1205         }
1206
1207         DBusMessage* msg;
1208
1209         msg = dbus_message_new_method_call(
1210                 g_server_service_name,
1211                 g_server_service_object,
1212                 g_server_service_interface,
1213                 STT_METHOD_CHECK_APP_AGREED);
1214
1215         if (NULL == msg) {
1216                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1217                 return STT_ERROR_OPERATION_FAILED;
1218         } else {
1219                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1220         }
1221
1222         dbus_message_append_args(msg,
1223                 DBUS_TYPE_INT32, &uid,
1224                 DBUS_TYPE_STRING, &appid,
1225                 DBUS_TYPE_INVALID);
1226
1227         DBusError err;
1228         dbus_error_init(&err);
1229
1230         DBusMessage* result_msg;
1231         int result = STT_ERROR_OPERATION_FAILED;
1232         int available = -1;
1233
1234         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1235         dbus_message_unref(msg);
1236         if (dbus_error_is_set(&err)) {
1237                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1238                 dbus_error_free(&err);
1239         }
1240
1241         if (NULL != result_msg) {
1242                 dbus_message_get_args(result_msg, &err,
1243                         DBUS_TYPE_INT32, &result,
1244                         DBUS_TYPE_INT32, &available,
1245                         DBUS_TYPE_INVALID);
1246
1247                 if (dbus_error_is_set(&err)) {
1248                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1249                         dbus_error_free(&err);
1250                         result = STT_ERROR_OPERATION_FAILED;
1251                 }
1252                 dbus_message_unref(result_msg);
1253
1254                 if (0 == result) {
1255                         *value = (bool)available;
1256                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1257                 } else {
1258                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1259                 }
1260         } else {
1261                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1262                 stt_dbus_reconnect();
1263                 result = STT_ERROR_TIMED_OUT;
1264         }
1265
1266         return result;
1267 }
1268
1269 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1270 {
1271         if (NULL == stt || NULL == callback) {
1272                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1273                 return STT_ERROR_INVALID_PARAMETER;
1274         }
1275
1276         DBusMessage* msg;
1277
1278         msg = dbus_message_new_method_call(
1279                 g_server_service_name,
1280                 g_server_service_object,
1281                 g_server_service_interface,
1282                 STT_METHOD_GET_SUPPORT_LANGS);
1283
1284         if (NULL == msg) {
1285                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1286                 return STT_ERROR_OPERATION_FAILED;
1287         } else {
1288                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1289         }
1290
1291         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1292
1293         DBusError err;
1294         dbus_error_init(&err);
1295
1296         DBusMessage* result_msg;
1297         DBusMessageIter args;
1298         int result = STT_ERROR_OPERATION_FAILED;
1299
1300         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1301         dbus_message_unref(msg);
1302         if (dbus_error_is_set(&err)) {
1303                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1304                 dbus_error_free(&err);
1305         }
1306
1307         if (NULL != result_msg) {
1308                 if (dbus_message_iter_init(result_msg, &args)) {
1309                         /* Get result */
1310                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1311                                 dbus_message_iter_get_basic(&args, &result);
1312                                 dbus_message_iter_next(&args);
1313                         }
1314
1315                         if (0 == result) {
1316                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1317
1318                                 /* Get voice size */
1319                                 int size = 0;
1320                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1321                                         dbus_message_iter_get_basic(&args, &size);
1322                                         dbus_message_iter_next(&args);
1323                                 }
1324
1325                                 if (0 >= size) {
1326                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1327                                 } else {
1328                                         int i = 0;
1329                                         char* temp_lang;
1330
1331                                         for (i = 0; i < size; i++) {
1332                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
1333                                                 dbus_message_iter_next(&args);
1334
1335                                                 if (true != callback(stt, temp_lang, user_data)) {
1336                                                         break;
1337                                                 }
1338                                         }
1339                                 }
1340                         } else {
1341                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1342                         }
1343                 }
1344                 dbus_message_unref(result_msg);
1345         } else {
1346                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1347                 stt_dbus_reconnect();
1348                 result = STT_ERROR_TIMED_OUT;
1349         }
1350
1351         return result;
1352 }
1353
1354 int stt_dbus_request_get_default_lang(int uid, char** language)
1355 {
1356         if (NULL == language) {
1357                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1358                 return STT_ERROR_INVALID_PARAMETER;
1359         }
1360
1361         DBusMessage* msg;
1362
1363         msg = dbus_message_new_method_call(
1364                 g_server_service_name,
1365                 g_server_service_object,
1366                 g_server_service_interface,
1367                 STT_METHOD_GET_CURRENT_LANG);
1368
1369         if (NULL == msg) {
1370                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1371                 return STT_ERROR_OPERATION_FAILED;
1372         } else {
1373                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
1374         }
1375
1376         dbus_message_append_args(msg,
1377                 DBUS_TYPE_INT32, &uid,
1378                 DBUS_TYPE_INVALID);
1379
1380         DBusError err;
1381         dbus_error_init(&err);
1382
1383         DBusMessage* result_msg;
1384         int result = STT_ERROR_OPERATION_FAILED;
1385         char* temp_lang = NULL;
1386
1387         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1388         dbus_message_unref(msg);
1389         if (dbus_error_is_set(&err)) {
1390                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1391                 dbus_error_free(&err);
1392         }
1393
1394         if (NULL != result_msg) {
1395                 dbus_message_get_args(result_msg, &err,
1396                         DBUS_TYPE_INT32, &result,
1397                         DBUS_TYPE_STRING, &temp_lang,
1398                         DBUS_TYPE_INVALID);
1399
1400                 if (dbus_error_is_set(&err)) {
1401                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1402                         dbus_error_free(&err);
1403                         result = STT_ERROR_OPERATION_FAILED;
1404                 }
1405                 dbus_message_unref(result_msg);
1406
1407                 if (0 == result) {
1408                         *language = strdup(temp_lang);
1409                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1410                 } else {
1411                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1412                 }
1413         } else {
1414                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1415                 stt_dbus_reconnect();
1416                 result = STT_ERROR_TIMED_OUT;
1417         }
1418
1419         return result;
1420 }
1421
1422 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1423 {
1424         if (NULL == key || NULL == data) {
1425                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1426                 return STT_ERROR_INVALID_PARAMETER;
1427         }
1428
1429         DBusMessage* msg;
1430
1431         msg = dbus_message_new_method_call(
1432                 g_server_service_name,
1433                 g_server_service_object,
1434                 g_server_service_interface,
1435                 STT_METHOD_SET_PRIVATE_DATA);
1436
1437         if (NULL == msg) {
1438                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
1439                 return STT_ERROR_OPERATION_FAILED;
1440         } else {
1441                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1442         }
1443
1444         if (true != dbus_message_append_args(msg,
1445                         DBUS_TYPE_INT32, &uid,
1446                         DBUS_TYPE_STRING, &key,
1447                         DBUS_TYPE_STRING, &data,
1448                         DBUS_TYPE_INVALID)) {
1449                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1450                 return STT_ERROR_OPERATION_FAILED;
1451         }
1452
1453         DBusError err;
1454         dbus_error_init(&err);
1455
1456         DBusMessage* result_msg;
1457         int result = STT_ERROR_OPERATION_FAILED;
1458
1459         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1460         dbus_message_unref(msg);
1461         if (dbus_error_is_set(&err)) {
1462                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1463                 dbus_error_free(&err);
1464         }
1465
1466         if (NULL != result_msg) {
1467                 dbus_message_get_args(result_msg, &err,
1468                         DBUS_TYPE_INT32, &result,
1469                         DBUS_TYPE_INVALID);
1470
1471                 if (dbus_error_is_set(&err)) {
1472                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1473                         dbus_error_free(&err);
1474                         result = STT_ERROR_OPERATION_FAILED;
1475                 }
1476                 dbus_message_unref(result_msg);
1477
1478                 if (0 == result) {
1479                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1480                 } else {
1481                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
1482                 }
1483         } else {
1484                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1485                 stt_dbus_reconnect();
1486                 result = STT_ERROR_TIMED_OUT;
1487         }
1488
1489         return result;
1490 }
1491
1492 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1493 {
1494         if (NULL == key || NULL == data) {
1495                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1496                 return STT_ERROR_INVALID_PARAMETER;
1497         }
1498
1499         DBusMessage* msg;
1500
1501         msg = dbus_message_new_method_call(
1502                 g_server_service_name,
1503                 g_server_service_object,
1504                 g_server_service_interface,
1505                 STT_METHOD_GET_PRIVATE_DATA);
1506
1507         if (NULL == msg) {
1508                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
1509                 return STT_ERROR_OPERATION_FAILED;
1510         } else {
1511                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1512         }
1513
1514         if (true != dbus_message_append_args(msg,
1515                         DBUS_TYPE_INT32, &uid,
1516                         DBUS_TYPE_STRING, &key,
1517                         DBUS_TYPE_INVALID)) {
1518                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1519                 return STT_ERROR_OPERATION_FAILED;
1520         }
1521
1522         DBusError err;
1523         dbus_error_init(&err);
1524
1525         DBusMessage* result_msg;
1526         int result = STT_ERROR_OPERATION_FAILED;
1527
1528         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1529         dbus_message_unref(msg);
1530         if (dbus_error_is_set(&err)) {
1531                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1532                 dbus_error_free(&err);
1533         }
1534
1535         char* temp = NULL;
1536         if (NULL != result_msg) {
1537                 dbus_message_get_args(result_msg, &err,
1538                         DBUS_TYPE_INT32, &result,
1539                         DBUS_TYPE_STRING, &temp,
1540                         DBUS_TYPE_INVALID);
1541
1542                 if (dbus_error_is_set(&err)) {
1543                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1544                         dbus_error_free(&err);
1545                         result = STT_ERROR_OPERATION_FAILED;
1546                 }
1547                 dbus_message_unref(result_msg);
1548
1549                 if (0 == result) {
1550                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1551                         if (NULL != temp) {
1552                                 *data = strdup(temp);
1553                         }
1554                 } else {
1555                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1556                 }
1557         } else {
1558                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1559                 stt_dbus_reconnect();
1560                 result = STT_ERROR_TIMED_OUT;
1561         }
1562
1563         return result;
1564 }
1565
1566
1567
1568 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1569 {
1570         if (NULL == support || NULL == type) {
1571                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1572                 return STT_ERROR_INVALID_PARAMETER;
1573         }
1574
1575         DBusMessage* msg;
1576
1577         msg = dbus_message_new_method_call(
1578                 g_server_service_name,
1579                 g_server_service_object,
1580                 g_server_service_interface,
1581                 STT_METHOD_IS_TYPE_SUPPORTED);
1582
1583         if (NULL == msg) {
1584                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1585                 return STT_ERROR_OPERATION_FAILED;
1586         } else {
1587                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1588         }
1589
1590         dbus_message_append_args(msg,
1591                 DBUS_TYPE_INT32, &uid,
1592                 DBUS_TYPE_STRING, &type,
1593                 DBUS_TYPE_INVALID);
1594
1595         DBusError err;
1596         dbus_error_init(&err);
1597
1598         DBusMessage* result_msg;
1599         int result = STT_ERROR_OPERATION_FAILED;
1600         int result_support = -1;
1601
1602         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1603         dbus_message_unref(msg);
1604         if (dbus_error_is_set(&err)) {
1605                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1606                 dbus_error_free(&err);
1607         }
1608
1609         if (NULL != result_msg) {
1610                 dbus_message_get_args(result_msg, &err,
1611                         DBUS_TYPE_INT32, &result,
1612                         DBUS_TYPE_INT32, &result_support,
1613                         DBUS_TYPE_INVALID);
1614
1615                 if (dbus_error_is_set(&err)) {
1616                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1617                         dbus_error_free(&err);
1618                         result = STT_ERROR_OPERATION_FAILED;
1619                 }
1620                 dbus_message_unref(result_msg);
1621
1622                 if (0 == result) {
1623                         *support = (bool)result_support;
1624                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1625                 } else {
1626                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1627                 }
1628         } else {
1629                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1630                 stt_dbus_reconnect();
1631                 result = STT_ERROR_TIMED_OUT;
1632         }
1633
1634         return result;
1635 }
1636
1637 int stt_dbus_request_set_start_sound(int uid, const char* file)
1638 {
1639         if (NULL == file) {
1640                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1641                 return STT_ERROR_INVALID_PARAMETER;
1642         }
1643
1644         DBusMessage* msg;
1645
1646         msg = dbus_message_new_method_call(
1647                 g_server_service_name,
1648                 g_server_service_object,
1649                 g_server_service_interface,
1650                 STT_METHOD_SET_START_SOUND);
1651
1652         if (NULL == msg) {
1653                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1654                 return STT_ERROR_OPERATION_FAILED;
1655         } else {
1656                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1657         }
1658
1659         dbus_message_append_args(msg,
1660                 DBUS_TYPE_INT32, &uid,
1661                 DBUS_TYPE_STRING, &file,
1662                 DBUS_TYPE_INVALID);
1663
1664         DBusError err;
1665         dbus_error_init(&err);
1666
1667         DBusMessage* result_msg;
1668         int result = STT_ERROR_OPERATION_FAILED;
1669
1670         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1671         dbus_message_unref(msg);
1672         if (dbus_error_is_set(&err)) {
1673                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1674                 dbus_error_free(&err);
1675         }
1676
1677         if (NULL != result_msg) {
1678                 dbus_message_get_args(result_msg, &err,
1679                         DBUS_TYPE_INT32, &result,
1680                         DBUS_TYPE_INVALID);
1681
1682                 if (dbus_error_is_set(&err)) {
1683                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1684                         dbus_error_free(&err);
1685                         result = STT_ERROR_OPERATION_FAILED;
1686                 }
1687                 dbus_message_unref(result_msg);
1688
1689                 if (0 == result) {
1690                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1691                 } else {
1692                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1693                 }
1694         } else {
1695                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1696                 stt_dbus_reconnect();
1697                 result = STT_ERROR_TIMED_OUT;
1698         }
1699
1700         return result;
1701 }
1702
1703 int stt_dbus_request_unset_start_sound(int uid)
1704 {
1705         DBusMessage* msg;
1706
1707         msg = dbus_message_new_method_call(
1708                 g_server_service_name,
1709                 g_server_service_object,
1710                 g_server_service_interface,
1711                 STT_METHOD_UNSET_START_SOUND);
1712
1713         if (NULL == msg) {
1714                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1715                 return STT_ERROR_OPERATION_FAILED;
1716         } else {
1717                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1718         }
1719
1720         dbus_message_append_args(msg,
1721                 DBUS_TYPE_INT32, &uid,
1722                 DBUS_TYPE_INVALID);
1723
1724         DBusError err;
1725         dbus_error_init(&err);
1726
1727         DBusMessage* result_msg;
1728         int result = STT_ERROR_OPERATION_FAILED;
1729
1730         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1731         dbus_message_unref(msg);
1732         if (dbus_error_is_set(&err)) {
1733                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1734                 dbus_error_free(&err);
1735         }
1736
1737         if (NULL != result_msg) {
1738                 dbus_message_get_args(result_msg, &err,
1739                         DBUS_TYPE_INT32, &result,
1740                         DBUS_TYPE_INVALID);
1741
1742                 if (dbus_error_is_set(&err)) {
1743                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1744                         dbus_error_free(&err);
1745                         result = STT_ERROR_OPERATION_FAILED;
1746                 }
1747                 dbus_message_unref(result_msg);
1748
1749                 if (0 == result) {
1750                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1751                 } else {
1752                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1753                 }
1754         } else {
1755                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1756                 stt_dbus_reconnect();
1757                 result = STT_ERROR_TIMED_OUT;
1758         }
1759
1760         return result;
1761 }
1762
1763 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1764 {
1765         if (NULL == file) {
1766                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1767                 return STT_ERROR_INVALID_PARAMETER;
1768         }
1769
1770         DBusMessage* msg;
1771
1772         msg = dbus_message_new_method_call(
1773                 g_server_service_name,
1774                 g_server_service_object,
1775                 g_server_service_interface,
1776                 STT_METHOD_SET_STOP_SOUND);
1777
1778         if (NULL == msg) {
1779                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1780                 return STT_ERROR_OPERATION_FAILED;
1781         } else {
1782                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1783         }
1784
1785         dbus_message_append_args(msg,
1786                 DBUS_TYPE_INT32, &uid,
1787                 DBUS_TYPE_STRING, &file,
1788                 DBUS_TYPE_INVALID);
1789
1790         DBusError err;
1791         dbus_error_init(&err);
1792
1793         DBusMessage* result_msg;
1794         int result = STT_ERROR_OPERATION_FAILED;
1795
1796         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1797         dbus_message_unref(msg);
1798         if (dbus_error_is_set(&err)) {
1799                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1800                 dbus_error_free(&err);
1801         }
1802
1803         if (NULL != result_msg) {
1804                 dbus_message_get_args(result_msg, &err,
1805                         DBUS_TYPE_INT32, &result,
1806                         DBUS_TYPE_INVALID);
1807
1808                 if (dbus_error_is_set(&err)) {
1809                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1810                         dbus_error_free(&err);
1811                         result = STT_ERROR_OPERATION_FAILED;
1812                 }
1813                 dbus_message_unref(result_msg);
1814
1815                 if (0 == result) {
1816                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1817                 } else {
1818                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1819                 }
1820         } else {
1821                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1822                 stt_dbus_reconnect();
1823                 result = STT_ERROR_TIMED_OUT;
1824         }
1825
1826         return result;
1827 }
1828
1829 int stt_dbus_request_unset_stop_sound(int uid)
1830 {
1831         DBusMessage* msg;
1832
1833         msg = dbus_message_new_method_call(
1834                 g_server_service_name,
1835                 g_server_service_object,
1836                 g_server_service_interface,
1837                 STT_METHOD_UNSET_STOP_SOUND);
1838
1839         if (NULL == msg) {
1840                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1841                 return STT_ERROR_OPERATION_FAILED;
1842         } else {
1843                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1844         }
1845
1846         dbus_message_append_args(msg,
1847                 DBUS_TYPE_INT32, &uid,
1848                 DBUS_TYPE_INVALID);
1849
1850         DBusError err;
1851         dbus_error_init(&err);
1852
1853         DBusMessage* result_msg;
1854         int result = STT_ERROR_OPERATION_FAILED;
1855
1856         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1857         dbus_message_unref(msg);
1858         if (dbus_error_is_set(&err)) {
1859                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1860                 dbus_error_free(&err);
1861         }
1862
1863         if (NULL != result_msg) {
1864                 dbus_message_get_args(result_msg, &err,
1865                         DBUS_TYPE_INT32, &result,
1866                         DBUS_TYPE_INVALID);
1867
1868                 if (dbus_error_is_set(&err)) {
1869                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1870                         dbus_error_free(&err);
1871                         result = STT_ERROR_OPERATION_FAILED;
1872                 }
1873                 dbus_message_unref(result_msg);
1874
1875                 if (0 == result) {
1876                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1877                 } else {
1878                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1879                 }
1880         } else {
1881                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1882                 stt_dbus_reconnect();
1883                 result = STT_ERROR_TIMED_OUT;
1884         }
1885
1886         return result;
1887 }
1888
1889 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1890 {
1891         if (NULL == lang || NULL == type || NULL == appid) {
1892                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1893                 return STT_ERROR_INVALID_PARAMETER;
1894         }
1895
1896         DBusMessage* msg;
1897
1898         /* create a signal & check for errors */
1899         msg = dbus_message_new_method_call(
1900                 g_server_service_name,
1901                 g_server_service_object,
1902                 g_server_service_interface,
1903                 STT_METHOD_START);
1904
1905         if (NULL == msg) {
1906                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1907                 return STT_ERROR_OPERATION_FAILED;
1908         } else {
1909                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1910         }
1911
1912         char *temp = NULL;
1913         if (NULL == credential) {
1914                 temp = strdup("NULL");
1915         } else {
1916                 temp = strdup(credential);
1917         }
1918
1919         dbus_message_append_args(msg,
1920                 DBUS_TYPE_INT32, &uid,
1921                 DBUS_TYPE_STRING, &lang,
1922                 DBUS_TYPE_STRING, &type,
1923                 DBUS_TYPE_INT32, &silence,
1924                 DBUS_TYPE_STRING, &appid,
1925                 DBUS_TYPE_STRING, &temp,
1926                 DBUS_TYPE_INVALID);
1927 #if 1
1928         if (g_conn_sender) {
1929                 dbus_message_set_no_reply(msg, TRUE);
1930
1931                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1932                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1933                         if (NULL != temp) {
1934                                         free(temp);
1935                                         temp = NULL;
1936                         }
1937                         return STT_ERROR_OUT_OF_MEMORY;
1938                 } else {
1939                         dbus_connection_flush(g_conn_sender);
1940                 }
1941
1942                 dbus_message_unref(msg);
1943
1944         } else {
1945                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1946                 if (NULL != temp) {
1947                                 free(temp);
1948                                 temp = NULL;
1949                 }
1950                 return STT_ERROR_OPERATION_FAILED;
1951         }
1952
1953         if (NULL != temp) {
1954                         free(temp);
1955                         temp = NULL;
1956         }
1957         return 0;
1958 #else
1959         DBusError err;
1960         dbus_error_init(&err);
1961
1962         DBusMessage* result_msg;
1963         int result = STT_ERROR_OPERATION_FAILED;
1964
1965         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1966         dbus_message_unref(msg);
1967         if (dbus_error_is_set(&err)) {
1968                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1969                 dbus_error_free(&err);
1970         }
1971
1972         if (NULL != result_msg) {
1973                 dbus_message_get_args(result_msg, &err,
1974                         DBUS_TYPE_INT32, &result,
1975                         DBUS_TYPE_INVALID);
1976
1977                 if (dbus_error_is_set(&err)) {
1978                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1979                         dbus_error_free(&err);
1980                         result = STT_ERROR_OPERATION_FAILED;
1981                 }
1982                 dbus_message_unref(result_msg);
1983
1984                 if (0 == result) {
1985                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1986                 } else {
1987                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1988                 }
1989         } else {
1990                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1991                 stt_dbus_reconnect();
1992                 result = STT_ERROR_TIMED_OUT;
1993         }
1994
1995         return result;
1996 #endif
1997 }
1998
1999 int stt_dbus_request_stop(int uid)
2000 {
2001         DBusMessage* msg;
2002
2003         /* create a signal & check for errors */
2004         msg = dbus_message_new_method_call(
2005                 g_server_service_name,
2006                 g_server_service_object,
2007                 g_server_service_interface,
2008                 STT_METHOD_STOP);
2009
2010         if (NULL == msg) {
2011                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
2012                 return STT_ERROR_OPERATION_FAILED;
2013         } else {
2014                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
2015         }
2016
2017         dbus_message_append_args(msg,
2018                 DBUS_TYPE_INT32, &uid,
2019                 DBUS_TYPE_INVALID);
2020 #if 1
2021         if (g_conn_sender) {
2022                 dbus_message_set_no_reply(msg, TRUE);
2023
2024                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2025                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2026                         return STT_ERROR_OUT_OF_MEMORY;
2027                 } else {
2028                         dbus_connection_flush(g_conn_sender);
2029                 }
2030
2031                 dbus_message_unref(msg);
2032         } else {
2033                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2034                 return STT_ERROR_OPERATION_FAILED;
2035         }
2036
2037         return 0;
2038 #else
2039         DBusError err;
2040         dbus_error_init(&err);
2041
2042         DBusMessage* result_msg;
2043         int result = STT_ERROR_OPERATION_FAILED;
2044
2045         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2046         dbus_message_unref(msg);
2047         if (dbus_error_is_set(&err)) {
2048                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2049                 dbus_error_free(&err);
2050         }
2051
2052         if (NULL != result_msg) {
2053                 dbus_message_get_args(result_msg, &err,
2054                         DBUS_TYPE_INT32, &result,
2055                         DBUS_TYPE_INVALID);
2056
2057                 if (dbus_error_is_set(&err)) {
2058                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2059                         dbus_error_free(&err);
2060                         result = STT_ERROR_OPERATION_FAILED;
2061                 }
2062                 dbus_message_unref(result_msg);
2063
2064                 if (0 == result) {
2065                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
2066                 } else {
2067                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
2068                 }
2069         } else {
2070                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2071                 stt_dbus_reconnect();
2072                 result = STT_ERROR_TIMED_OUT;
2073         }
2074
2075         return result;
2076 #endif
2077 }
2078
2079 int stt_dbus_request_cancel(int uid)
2080 {
2081         DBusMessage* msg;
2082
2083         /* create a signal & check for errors */
2084         msg = dbus_message_new_method_call(
2085                 g_server_service_name,
2086                 g_server_service_object,
2087                 g_server_service_interface,
2088                 STT_METHOD_CANCEL);
2089
2090         if (NULL == msg) {
2091                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
2092                 return STT_ERROR_OPERATION_FAILED;
2093         } else {
2094                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
2095         }
2096
2097         dbus_message_append_args(msg,
2098                 DBUS_TYPE_INT32, &uid,
2099                 DBUS_TYPE_INVALID);
2100 #if 1
2101         if (g_conn_sender) {
2102                 dbus_message_set_no_reply(msg, TRUE);
2103
2104                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2105                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2106                         return STT_ERROR_OUT_OF_MEMORY;
2107                 } else {
2108                         dbus_connection_flush(g_conn_sender);
2109                 }
2110
2111                 dbus_message_unref(msg);
2112         } else {
2113                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2114                 return STT_ERROR_OPERATION_FAILED;
2115         }
2116
2117         return 0;
2118 #else
2119         DBusError err;
2120         dbus_error_init(&err);
2121
2122         DBusMessage* result_msg;
2123         int result = STT_ERROR_OPERATION_FAILED;
2124
2125         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2126         dbus_message_unref(msg);
2127         if (dbus_error_is_set(&err)) {
2128                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2129                 dbus_error_free(&err);
2130         }
2131
2132         if (NULL != result_msg) {
2133                 dbus_message_get_args(result_msg, &err,
2134                         DBUS_TYPE_INT32, &result,
2135                         DBUS_TYPE_INVALID);
2136
2137                 if (dbus_error_is_set(&err)) {
2138                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2139                         dbus_error_free(&err);
2140                         result = STT_ERROR_OPERATION_FAILED;
2141                 }
2142                 dbus_message_unref(result_msg);
2143
2144                 if (0 == result) {
2145                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2146                 } else {
2147                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2148                 }
2149         } else {
2150                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2151                 stt_dbus_reconnect();
2152                 result = STT_ERROR_TIMED_OUT;
2153         }
2154
2155         return result;
2156 #endif
2157 }
2158
2159 int stt_dbus_request_start_file(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential, const char* filepath, stt_audio_type_e audio_type, int sample_rate)
2160 {
2161         if (NULL == lang || NULL == type || NULL == appid) {
2162                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
2163                 return STT_ERROR_INVALID_PARAMETER;
2164         }
2165
2166         DBusMessage* msg;
2167
2168         /* create a signal & check for errors */
2169         msg = dbus_message_new_method_call(
2170                 g_server_service_name,
2171                 g_server_service_object,
2172                 g_server_service_interface,
2173                 STT_METHOD_START_FILE);
2174
2175         if (NULL == msg) {
2176                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start file : Fail to make message");
2177                 return STT_ERROR_OPERATION_FAILED;
2178         } else {
2179                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start file : uid(%d), language(%s), type(%s), appid(%s), filepath(%s), audio_type(%d), sample_rate(%d)", uid, lang, type, appid, filepath, audio_type, sample_rate);
2180         }
2181
2182         char *temp = NULL;
2183         if (NULL == credential) {
2184                 temp = strdup("NULL");
2185         } else {
2186                 temp = strdup(credential);
2187         }
2188
2189         dbus_message_append_args(msg,
2190                 DBUS_TYPE_INT32, &uid,
2191                 DBUS_TYPE_STRING, &lang,
2192                 DBUS_TYPE_STRING, &type,
2193                 DBUS_TYPE_INT32, &silence,
2194                 DBUS_TYPE_STRING, &appid,
2195                 DBUS_TYPE_STRING, &temp,
2196                 DBUS_TYPE_STRING, &filepath,
2197                 DBUS_TYPE_INT32, &audio_type,
2198                 DBUS_TYPE_INT32, &sample_rate,
2199                 DBUS_TYPE_INVALID);
2200         if (g_conn_sender) {
2201                 dbus_message_set_no_reply(msg, TRUE);
2202
2203                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2204                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
2205                         if (NULL != temp) {
2206                                 free(temp);
2207                                 temp = NULL;
2208                         }
2209                         return STT_ERROR_OUT_OF_MEMORY;
2210                 } else {
2211                         dbus_connection_flush(g_conn_sender);
2212                 }
2213
2214                 dbus_message_unref(msg);
2215
2216         } else {
2217                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2218                 if (NULL != temp) {
2219                                 free(temp);
2220                                 temp = NULL;
2221                 }
2222                 return STT_ERROR_OPERATION_FAILED;
2223         }
2224
2225         if (NULL != temp) {
2226                         free(temp);
2227                         temp = NULL;
2228         }
2229         return 0;
2230 }
2231
2232 int stt_dbus_request_cancel_file(int uid)
2233 {
2234         DBusMessage* msg;
2235
2236         /* create a signal & check for errors */
2237         msg = dbus_message_new_method_call(
2238                 g_server_service_name,
2239                 g_server_service_object,
2240                 g_server_service_interface,
2241                 STT_METHOD_CANCEL_FILE);
2242
2243         if (NULL == msg) {
2244                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel file : Fail to make message");
2245                 return STT_ERROR_OPERATION_FAILED;
2246         } else {
2247                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%d)", uid);
2248         }
2249
2250         dbus_message_append_args(msg,
2251                 DBUS_TYPE_INT32, &uid,
2252                 DBUS_TYPE_INVALID);
2253
2254         if (g_conn_sender) {
2255                 dbus_message_set_no_reply(msg, TRUE);
2256
2257                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2258                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2259                         return STT_ERROR_OUT_OF_MEMORY;
2260                 } else {
2261                         dbus_connection_flush(g_conn_sender);
2262                 }
2263
2264                 dbus_message_unref(msg);
2265         } else {
2266                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2267                 return STT_ERROR_OPERATION_FAILED;
2268         }
2269
2270         return 0;
2271 }
2272