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                 g_conn_listener = NULL;
 656         }
 657         if (NULL != g_conn_sender) {
 658                 dbus_connection_close(g_conn_sender);
 659                 g_conn_sender = NULL;
 660         }
 661 }
 662
 663 int stt_dbus_open_connection()
 664 {
 665         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 666                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 667                 return 0;
 668         }
 669
 670         DBusError err;
 671
 672         /* initialise the error value */
 673         dbus_error_init(&err);
 674
 675         /* connect to the DBUS system bus, and check for errors */
 676         if (NULL == g_conn_sender) {
 677                 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 678                 if (dbus_error_is_set(&err)) {
 679                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
 680                         dbus_error_free(&err);
 681                 }
 682         }
 683
 684         if (NULL == g_conn_sender) {
 685                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
 686                 return STT_ERROR_OPERATION_FAILED;
 687         }
 688
 689         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 690
 691         /* connect to the DBUS system bus, and check for errors */
 692         if (NULL == g_conn_listener) {
 693                 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 694                 if (dbus_error_is_set(&err)) {
 695                         SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
 696                         dbus_error_free(&err);
 697                 }
 698         }
 699
 700         if (NULL == g_conn_listener) {
 701                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 702                 __stt_dbus_connection_free();
 703                 return STT_ERROR_OPERATION_FAILED;
 704         }
 705
 706         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 707
 708         dbus_connection_set_exit_on_disconnect(g_conn_listener, false);
 709
 710         int pid = getpid();
 711
 712         char service_name[64];
 713         memset(service_name, '\0', 64);
 714         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 715
 716         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
 717
 718         /* register our name on the bus, and check for errors */
 719         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 720
 721         if (dbus_error_is_set(&err)) {
 722                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
 723                 dbus_error_free(&err);
 724         }
 725
 726         char rule[128] = {0, };
 727         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 728
 729         /* add a rule for which messages we want to see */
 730         dbus_bus_add_match(g_conn_listener, rule, &err);
 731         dbus_connection_flush(g_conn_listener);
 732
 733         if (dbus_error_is_set(&err)) {
 734                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 735                 dbus_error_free(&err);
 736                 __stt_dbus_connection_free();
 737                 return STT_ERROR_OPERATION_FAILED;
 738         }
 739
 740         int fd = 0;
 741         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 742                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
 743                 __stt_dbus_connection_free();
 744                 return STT_ERROR_OPERATION_FAILED;
 745         } else {
 746                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
 747         }
 748
 749         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 750         if (NULL == g_fd_handler) {
 751                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 752                 __stt_dbus_connection_free();
 753                 return STT_ERROR_OPERATION_FAILED;
 754         }
 755
 756         return 0;
 757 }
 758
 759 int stt_dbus_close_connection()
 760 {
 761         DBusError err;
 762         dbus_error_init(&err);
 763
 764         if (NULL != g_fd_handler) {
 765                 ecore_main_fd_handler_del(g_fd_handler);
 766                 g_fd_handler = NULL;
 767         }
 768
 769         if (NULL != g_conn_listener) {
 770                 int pid = getpid();
 771
 772                 char service_name[64];
 773                 memset(service_name, '\0', 64);
 774                 snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 775
 776                 dbus_bus_release_name(g_conn_listener, service_name, &err);
 777                 if (dbus_error_is_set(&err)) {
 778                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 779                         dbus_error_free(&err);
 780                 }
 781         }
 782
 783         __stt_dbus_connection_free();
 784         __stt_dbus_service_free();
 785
 786         return 0;
 787 }
 788
 789 int stt_dbus_reconnect()
 790 {
 791         if (!g_conn_sender || !g_conn_listener) {
 792                 stt_dbus_close_connection();
 793
 794                 if (0 != stt_dbus_open_connection()) {
 795                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 796                         return -1;
 797                 }
 798
 799                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 800                 return 0;
 801         }
 802
 803         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 804         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 805         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
 806                 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 807
 808         if (false == sender_connected || false == listener_connected) {
 809                 stt_dbus_close_connection();
 810
 811                 if (0 != stt_dbus_open_connection()) {
 812                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 813                         return -1;
 814                 }
 815
 816                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 817         }
 818
 819         return 0;
 820 }
 821
 822 void __stt_dbus_service_free()
 823 {
 824         if (NULL != g_server_service_name) {
 825                 free(g_server_service_name);
 826                 g_server_service_name = NULL;
 827         }
 828         if (NULL != g_server_service_object) {
 829                 free(g_server_service_object);
 830                 g_server_service_object = NULL;
 831         }
 832         if (NULL != g_server_service_interface) {
 833                 free(g_server_service_interface);
 834                 g_server_service_interface = NULL;
 835         }
 836 }
 837
 838 int stt_dbus_request_hello(int uid)
 839 {
 840         stt_client_s* client = stt_client_get_by_uid(uid);
 841
 842         /* Check whether there is any dbus whose name has owner or not */
 843         dbus_bool_t is_exist = FALSE;
 844         DBusError err;
 845         dbus_error_init(&err);
 846
 847         DBusMessage* msg = NULL;
 848         DBusMessage* result_msg = NULL;
 849         int result = 0;
 850
 851         if (g_conn_sender) {
 852                 if (NULL != client) {
 853                         __stt_dbus_service_free();
 854
 855                         if (NULL == client->current_engine_id) {
 856                                 /* Default engine */
 857                                 g_server_service_name = strdup(STT_SERVER_SERVICE_NAME);
 858                                 if (NULL == g_server_service_name) {
 859                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 860                                         return STT_ERROR_OUT_OF_MEMORY;
 861                                 }
 862                                 g_server_service_object = strdup(STT_SERVER_SERVICE_OBJECT_PATH);
 863                                 if (NULL == g_server_service_name) {
 864                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 865                                         return STT_ERROR_OUT_OF_MEMORY;
 866                                 }
 867                                 g_server_service_interface = strdup(STT_SERVER_SERVICE_INTERFACE);
 868                                 if (NULL == g_server_service_name) {
 869                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 870                                         return STT_ERROR_OUT_OF_MEMORY;
 871                                 }
 872
 873                                 msg = dbus_message_new_method_call(
 874                                         STT_SERVER_SERVICE_NAME,
 875                                         STT_SERVER_SERVICE_OBJECT_PATH,
 876                                         STT_SERVER_SERVICE_INTERFACE,
 877                                         STT_METHOD_HELLO);
 878                         } else {
 879                                 /* Get service name, object, interface */
 880                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] current_engine_id: %s", client->current_engine_id);
 881
 882                                 g_server_service_name = __stt_get_service_name(client->current_engine_id);
 883                                 g_server_service_object = __stt_get_service_object(client->current_engine_id);
 884                                 g_server_service_interface = __stt_get_service_interface(client->current_engine_id);
 885
 886                                 if (NULL == g_server_service_name || NULL == g_server_service_object || NULL == g_server_service_interface) {
 887                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] dbus service info invalid");
 888                                         return STT_ERROR_OPERATION_FAILED;
 889                                 }
 890
 891                                 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);
 892
 893                                 /* Custom engine */
 894                                 is_exist = dbus_bus_name_has_owner(g_conn_sender, g_server_service_name, &err);
 895                                 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);
 896
 897                                 if (TRUE == is_exist) {
 898                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: True");
 899                                         msg = dbus_message_new_method_call(
 900                                                 g_server_service_name,
 901                                                 g_server_service_object,
 902                                                 g_server_service_interface,
 903                                                 STT_METHOD_HELLO);
 904                                 } else {
 905                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: False");
 906                                         msg = dbus_message_new_method_call(
 907                                                 STT_SERVER_CUSTOM_SERVICE_NAME,
 908                                                 STT_SERVER_CUSTOM_SERVICE_OBJECT_PATH,
 909                                                 STT_SERVER_CUSTOM_SERVICE_INTERFACE,
 910                                                 STT_METHOD_HELLO);
 911                                 }
 912                         }
 913                 }
 914         }
 915
 916         if (NULL == msg) {
 917 //              SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 918                 result = stt_dbus_reconnect();
 919                 if (0 != result)
 920                         return STT_ERROR_OPERATION_FAILED;
 921         }
 922
 923         if (g_conn_sender) {
 924                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 925                 dbus_message_unref(msg);
 926                 if (dbus_error_is_set(&err)) {
 927                         dbus_error_free(&err);
 928                 }
 929
 930                 if (NULL != result_msg) {
 931                         dbus_message_unref(result_msg);
 932
 933                         if (dbus_error_is_set(&err)) {
 934                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 935                                 dbus_error_free(&err);
 936                         }
 937
 938                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 939                 } else {
 940                         if (dbus_error_is_set(&err)) {
 941                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 942                                 dbus_error_free(&err);
 943                         }
 944
 945                         result = STT_ERROR_TIMED_OUT;
 946                 }
 947         } else {
 948                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 949                 stt_dbus_reconnect();
 950                 result = STT_ERROR_OPERATION_FAILED;
 951         }
 952
 953         return result;
 954 }
 955
 956
 957 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 958 {
 959         DBusMessage* msg;
 960
 961         msg = dbus_message_new_method_call(
 962                 g_server_service_name,
 963                 g_server_service_object,
 964                 g_server_service_interface,
 965                 STT_METHOD_INITIALIZE);
 966
 967         if (NULL == msg) {
 968                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 969                 return STT_ERROR_OPERATION_FAILED;
 970         } else {
 971                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 972         }
 973
 974         int pid = getpid();
 975         dbus_message_append_args(msg,
 976                 DBUS_TYPE_INT32, &pid,
 977                 DBUS_TYPE_INT32, &uid,
 978                 DBUS_TYPE_INVALID);
 979
 980         DBusError err;
 981         dbus_error_init(&err);
 982
 983         DBusMessage* result_msg;
 984         int result = STT_ERROR_OPERATION_FAILED;
 985
 986         if (g_conn_sender) {
 987                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 988                 dbus_message_unref(msg);
 989                 if (dbus_error_is_set(&err)) {
 990                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 991                         dbus_error_free(&err);
 992                 }
 993
 994                 if (NULL != result_msg) {
 995                         int int_silence_supported = 0;
 996                         int int_credential_needed = 0;
 997                         dbus_message_get_args(result_msg, &err,
 998                                 DBUS_TYPE_INT32, &result,
 999                                 DBUS_TYPE_INT32, &int_silence_supported,
1000                                 DBUS_TYPE_INT32, &int_credential_needed,
1001                                 DBUS_TYPE_INVALID);
1002
1003                         *silence_supported = (bool)(int_silence_supported);
1004                         *credential_needed = (bool)(int_credential_needed);
1005
1006                         if (dbus_error_is_set(&err)) {
1007                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1008                                 dbus_error_free(&err);
1009                                 result = STT_ERROR_OPERATION_FAILED;
1010                         }
1011
1012                         if (0 == result) {
1013                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
1014                                         result, *silence_supported, *credential_needed);
1015
1016                                 stt_client_s* client = stt_client_get_by_uid(uid);
1017                                 if (NULL == client) {
1018                                         SLOG(LOG_ERROR, TAG_STTC, "Fail to get STT client");
1019                                         return STT_ERROR_OPERATION_FAILED;
1020                                 }
1021
1022                                 if (STT_ERROR_SERVICE_RESET != client->reason) {
1023                                         /* add a rule for daemon error */
1024                                         char rule_err[256] = {0, };
1025
1026                                         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);
1027                                         dbus_bus_add_match(g_conn_listener, rule_err, &err);
1028                                         dbus_connection_flush(g_conn_listener);
1029
1030                                         if (dbus_error_is_set(&err)) {
1031                                                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1032                                                 dbus_error_free(&err);
1033                                                 return STT_ERROR_OPERATION_FAILED;
1034                                         }
1035                                 }
1036                         } else {
1037                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
1038                         }
1039
1040                         dbus_message_unref(result_msg);
1041                 } else {
1042                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1043                         stt_dbus_reconnect();
1044                         result = STT_ERROR_TIMED_OUT;
1045                 }
1046         } else {
1047                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1048                 result = STT_ERROR_OPERATION_FAILED;
1049         }
1050
1051         return result;
1052 }
1053
1054 int stt_dbus_request_finalize(int uid)
1055 {
1056         DBusMessage* msg;
1057
1058         DBusError err;
1059         dbus_error_init(&err);
1060
1061         /* remove a rule for daemon error */
1062         char rule_err[256] = {0, };
1063         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);
1064         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
1065         dbus_connection_flush(g_conn_listener);
1066         if (dbus_error_is_set(&err)) {
1067                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1068                 dbus_error_free(&err);
1069         }
1070
1071         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);
1072
1073         msg = dbus_message_new_method_call(
1074                 g_server_service_name,
1075                 g_server_service_object,
1076                 g_server_service_interface,
1077                 STT_METHOD_FINALIZE);
1078
1079         if (NULL == msg) {
1080                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
1081                 return STT_ERROR_OPERATION_FAILED;
1082         } else {
1083                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
1084         }
1085
1086         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1087
1088         DBusMessage* result_msg;
1089         int result = STT_ERROR_OPERATION_FAILED;
1090
1091         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
1092         dbus_message_unref(msg);
1093         if (dbus_error_is_set(&err)) {
1094                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1095                 dbus_error_free(&err);
1096         }
1097
1098         if (NULL != result_msg) {
1099                 dbus_message_get_args(result_msg, &err,
1100                                 DBUS_TYPE_INT32, &result,
1101                                 DBUS_TYPE_INVALID);
1102
1103                 if (dbus_error_is_set(&err)) {
1104                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1105                         dbus_error_free(&err);
1106                         result = STT_ERROR_OPERATION_FAILED;
1107                 }
1108
1109                 dbus_message_unref(result_msg);
1110
1111                 if (0 == result) {
1112                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1113                 } else {
1114                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
1115                 }
1116         } else {
1117                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1118                 stt_dbus_reconnect();
1119                 result = STT_ERROR_TIMED_OUT;
1120         }
1121
1122         return result;
1123 }
1124
1125 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1126 {
1127         DBusMessage* msg;
1128
1129         msg = dbus_message_new_method_call(
1130                 g_server_service_name,
1131                 g_server_service_object,
1132                 g_server_service_interface,
1133                 STT_METHOD_SET_CURRENT_ENGINE);
1134
1135
1136         if (NULL == msg) {
1137                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1138                 return STT_ERROR_OPERATION_FAILED;
1139         } else {
1140                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1141         }
1142
1143         dbus_message_append_args(msg,
1144                 DBUS_TYPE_INT32, &uid,
1145                 DBUS_TYPE_STRING, &engine_id,
1146                 DBUS_TYPE_INVALID);
1147
1148         DBusError err;
1149         dbus_error_init(&err);
1150
1151         DBusMessage* result_msg;
1152         int result = STT_ERROR_OPERATION_FAILED;
1153
1154         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1155         dbus_message_unref(msg);
1156         if (dbus_error_is_set(&err)) {
1157                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1158                 dbus_error_free(&err);
1159         }
1160
1161         if (NULL != result_msg) {
1162                 int int_silence_supported = 0;
1163                 int int_credential_needed = 0;
1164
1165                 dbus_message_get_args(result_msg, &err,
1166                         DBUS_TYPE_INT32, &result,
1167                         DBUS_TYPE_INT32, &int_silence_supported,
1168                         DBUS_TYPE_INT32, &int_credential_needed,
1169                         DBUS_TYPE_INVALID);
1170
1171                 *silence_supported = (bool)(int_silence_supported);
1172                 *credential_needed = (bool)(int_credential_needed);
1173
1174                 if (dbus_error_is_set(&err)) {
1175                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1176                         dbus_error_free(&err);
1177                         result = STT_ERROR_OPERATION_FAILED;
1178                 }
1179
1180                 dbus_message_unref(result_msg);
1181
1182                 if (0 == result) {
1183                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1184                                 result, *silence_supported, *credential_needed);
1185                 } else {
1186                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1187                 }
1188         } else {
1189                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1190                 stt_dbus_reconnect();
1191                 result = STT_ERROR_TIMED_OUT;
1192         }
1193
1194         return result;
1195 }
1196
1197 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1198 {
1199         if (NULL == appid || NULL == value) {
1200                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1201                 return STT_ERROR_INVALID_PARAMETER;
1202         }
1203
1204         DBusMessage* msg;
1205
1206         msg = dbus_message_new_method_call(
1207                 g_server_service_name,
1208                 g_server_service_object,
1209                 g_server_service_interface,
1210                 STT_METHOD_CHECK_APP_AGREED);
1211
1212         if (NULL == msg) {
1213                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1214                 return STT_ERROR_OPERATION_FAILED;
1215         } else {
1216                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1217         }
1218
1219         dbus_message_append_args(msg,
1220                 DBUS_TYPE_INT32, &uid,
1221                 DBUS_TYPE_STRING, &appid,
1222                 DBUS_TYPE_INVALID);
1223
1224         DBusError err;
1225         dbus_error_init(&err);
1226
1227         DBusMessage* result_msg;
1228         int result = STT_ERROR_OPERATION_FAILED;
1229         int available = -1;
1230
1231         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1232         dbus_message_unref(msg);
1233         if (dbus_error_is_set(&err)) {
1234                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1235                 dbus_error_free(&err);
1236         }
1237
1238         if (NULL != result_msg) {
1239                 dbus_message_get_args(result_msg, &err,
1240                         DBUS_TYPE_INT32, &result,
1241                         DBUS_TYPE_INT32, &available,
1242                         DBUS_TYPE_INVALID);
1243
1244                 if (dbus_error_is_set(&err)) {
1245                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1246                         dbus_error_free(&err);
1247                         result = STT_ERROR_OPERATION_FAILED;
1248                 }
1249                 dbus_message_unref(result_msg);
1250
1251                 if (0 == result) {
1252                         *value = (bool)available;
1253                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1254                 } else {
1255                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1256                 }
1257         } else {
1258                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1259                 stt_dbus_reconnect();
1260                 result = STT_ERROR_TIMED_OUT;
1261         }
1262
1263         return result;
1264 }
1265
1266 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1267 {
1268         if (NULL == stt || NULL == callback) {
1269                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1270                 return STT_ERROR_INVALID_PARAMETER;
1271         }
1272
1273         DBusMessage* msg;
1274
1275         msg = dbus_message_new_method_call(
1276                 g_server_service_name,
1277                 g_server_service_object,
1278                 g_server_service_interface,
1279                 STT_METHOD_GET_SUPPORT_LANGS);
1280
1281         if (NULL == msg) {
1282                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1283                 return STT_ERROR_OPERATION_FAILED;
1284         } else {
1285                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1286         }
1287
1288         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1289
1290         DBusError err;
1291         dbus_error_init(&err);
1292
1293         DBusMessage* result_msg;
1294         DBusMessageIter args;
1295         int result = STT_ERROR_OPERATION_FAILED;
1296
1297         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1298         dbus_message_unref(msg);
1299         if (dbus_error_is_set(&err)) {
1300                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1301                 dbus_error_free(&err);
1302         }
1303
1304         if (NULL != result_msg) {
1305                 if (dbus_message_iter_init(result_msg, &args)) {
1306                         /* Get result */
1307                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1308                                 dbus_message_iter_get_basic(&args, &result);
1309                                 dbus_message_iter_next(&args);
1310                         }
1311
1312                         if (0 == result) {
1313                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1314
1315                                 /* Get voice size */
1316                                 int size = 0;
1317                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1318                                         dbus_message_iter_get_basic(&args, &size);
1319                                         dbus_message_iter_next(&args);
1320                                 }
1321
1322                                 if (0 >= size) {
1323                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1324                                 } else {
1325                                         int i = 0;
1326                                         char* temp_lang;
1327
1328                                         for (i = 0; i < size; i++) {
1329                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
1330                                                 dbus_message_iter_next(&args);
1331
1332                                                 if (true != callback(stt, temp_lang, user_data)) {
1333                                                         break;
1334                                                 }
1335                                         }
1336                                 }
1337                         } else {
1338                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1339                         }
1340                 }
1341                 dbus_message_unref(result_msg);
1342         } else {
1343                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1344                 stt_dbus_reconnect();
1345                 result = STT_ERROR_TIMED_OUT;
1346         }
1347
1348         return result;
1349 }
1350
1351 int stt_dbus_request_get_default_lang(int uid, char** language)
1352 {
1353         if (NULL == language) {
1354                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1355                 return STT_ERROR_INVALID_PARAMETER;
1356         }
1357
1358         DBusMessage* msg;
1359
1360         msg = dbus_message_new_method_call(
1361                 g_server_service_name,
1362                 g_server_service_object,
1363                 g_server_service_interface,
1364                 STT_METHOD_GET_CURRENT_LANG);
1365
1366         if (NULL == msg) {
1367                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1368                 return STT_ERROR_OPERATION_FAILED;
1369         } else {
1370                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
1371         }
1372
1373         dbus_message_append_args(msg,
1374                 DBUS_TYPE_INT32, &uid,
1375                 DBUS_TYPE_INVALID);
1376
1377         DBusError err;
1378         dbus_error_init(&err);
1379
1380         DBusMessage* result_msg;
1381         int result = STT_ERROR_OPERATION_FAILED;
1382         char* temp_lang = NULL;
1383
1384         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1385         dbus_message_unref(msg);
1386         if (dbus_error_is_set(&err)) {
1387                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1388                 dbus_error_free(&err);
1389         }
1390
1391         if (NULL != result_msg) {
1392                 dbus_message_get_args(result_msg, &err,
1393                         DBUS_TYPE_INT32, &result,
1394                         DBUS_TYPE_STRING, &temp_lang,
1395                         DBUS_TYPE_INVALID);
1396
1397                 if (dbus_error_is_set(&err)) {
1398                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1399                         dbus_error_free(&err);
1400                         result = STT_ERROR_OPERATION_FAILED;
1401                 }
1402                 dbus_message_unref(result_msg);
1403
1404                 if (0 == result) {
1405                         *language = strdup(temp_lang);
1406                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1407                 } else {
1408                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1409                 }
1410         } else {
1411                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1412                 stt_dbus_reconnect();
1413                 result = STT_ERROR_TIMED_OUT;
1414         }
1415
1416         return result;
1417 }
1418
1419 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1420 {
1421         if (NULL == key || NULL == data) {
1422                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1423                 return STT_ERROR_INVALID_PARAMETER;
1424         }
1425
1426         DBusMessage* msg;
1427
1428         msg = dbus_message_new_method_call(
1429                 g_server_service_name,
1430                 g_server_service_object,
1431                 g_server_service_interface,
1432                 STT_METHOD_SET_PRIVATE_DATA);
1433
1434         if (NULL == msg) {
1435                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
1436                 return STT_ERROR_OPERATION_FAILED;
1437         } else {
1438                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1439         }
1440
1441         if (true != dbus_message_append_args(msg,
1442                         DBUS_TYPE_INT32, &uid,
1443                         DBUS_TYPE_STRING, &key,
1444                         DBUS_TYPE_STRING, &data,
1445                         DBUS_TYPE_INVALID)) {
1446                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1447                 return STT_ERROR_OPERATION_FAILED;
1448         }
1449
1450         DBusError err;
1451         dbus_error_init(&err);
1452
1453         DBusMessage* result_msg;
1454         int result = STT_ERROR_OPERATION_FAILED;
1455
1456         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1457         dbus_message_unref(msg);
1458         if (dbus_error_is_set(&err)) {
1459                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1460                 dbus_error_free(&err);
1461         }
1462
1463         if (NULL != result_msg) {
1464                 dbus_message_get_args(result_msg, &err,
1465                         DBUS_TYPE_INT32, &result,
1466                         DBUS_TYPE_INVALID);
1467
1468                 if (dbus_error_is_set(&err)) {
1469                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1470                         dbus_error_free(&err);
1471                         result = STT_ERROR_OPERATION_FAILED;
1472                 }
1473                 dbus_message_unref(result_msg);
1474
1475                 if (0 == result) {
1476                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1477                 } else {
1478                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
1479                 }
1480         } else {
1481                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1482                 stt_dbus_reconnect();
1483                 result = STT_ERROR_TIMED_OUT;
1484         }
1485
1486         return result;
1487 }
1488
1489 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1490 {
1491         if (NULL == key || NULL == data) {
1492                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1493                 return STT_ERROR_INVALID_PARAMETER;
1494         }
1495
1496         DBusMessage* msg;
1497
1498         msg = dbus_message_new_method_call(
1499                 g_server_service_name,
1500                 g_server_service_object,
1501                 g_server_service_interface,
1502                 STT_METHOD_GET_PRIVATE_DATA);
1503
1504         if (NULL == msg) {
1505                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
1506                 return STT_ERROR_OPERATION_FAILED;
1507         } else {
1508                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1509         }
1510
1511         if (true != dbus_message_append_args(msg,
1512                         DBUS_TYPE_INT32, &uid,
1513                         DBUS_TYPE_STRING, &key,
1514                         DBUS_TYPE_INVALID)) {
1515                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1516                 return STT_ERROR_OPERATION_FAILED;
1517         }
1518
1519         DBusError err;
1520         dbus_error_init(&err);
1521
1522         DBusMessage* result_msg;
1523         int result = STT_ERROR_OPERATION_FAILED;
1524
1525         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1526         dbus_message_unref(msg);
1527         if (dbus_error_is_set(&err)) {
1528                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1529                 dbus_error_free(&err);
1530         }
1531
1532         char* temp = NULL;
1533         if (NULL != result_msg) {
1534                 dbus_message_get_args(result_msg, &err,
1535                         DBUS_TYPE_INT32, &result,
1536                         DBUS_TYPE_STRING, &temp,
1537                         DBUS_TYPE_INVALID);
1538
1539                 if (dbus_error_is_set(&err)) {
1540                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1541                         dbus_error_free(&err);
1542                         result = STT_ERROR_OPERATION_FAILED;
1543                 }
1544                 dbus_message_unref(result_msg);
1545
1546                 if (0 == result) {
1547                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1548                         if (NULL != temp) {
1549                                 *data = strdup(temp);
1550                         }
1551                 } else {
1552                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1553                 }
1554         } else {
1555                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1556                 stt_dbus_reconnect();
1557                 result = STT_ERROR_TIMED_OUT;
1558         }
1559
1560         return result;
1561 }
1562
1563
1564
1565 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1566 {
1567         if (NULL == support || NULL == type) {
1568                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1569                 return STT_ERROR_INVALID_PARAMETER;
1570         }
1571
1572         DBusMessage* msg;
1573
1574         msg = dbus_message_new_method_call(
1575                 g_server_service_name,
1576                 g_server_service_object,
1577                 g_server_service_interface,
1578                 STT_METHOD_IS_TYPE_SUPPORTED);
1579
1580         if (NULL == msg) {
1581                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1582                 return STT_ERROR_OPERATION_FAILED;
1583         } else {
1584                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1585         }
1586
1587         dbus_message_append_args(msg,
1588                 DBUS_TYPE_INT32, &uid,
1589                 DBUS_TYPE_STRING, &type,
1590                 DBUS_TYPE_INVALID);
1591
1592         DBusError err;
1593         dbus_error_init(&err);
1594
1595         DBusMessage* result_msg;
1596         int result = STT_ERROR_OPERATION_FAILED;
1597         int result_support = -1;
1598
1599         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1600         dbus_message_unref(msg);
1601         if (dbus_error_is_set(&err)) {
1602                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1603                 dbus_error_free(&err);
1604         }
1605
1606         if (NULL != result_msg) {
1607                 dbus_message_get_args(result_msg, &err,
1608                         DBUS_TYPE_INT32, &result,
1609                         DBUS_TYPE_INT32, &result_support,
1610                         DBUS_TYPE_INVALID);
1611
1612                 if (dbus_error_is_set(&err)) {
1613                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1614                         dbus_error_free(&err);
1615                         result = STT_ERROR_OPERATION_FAILED;
1616                 }
1617                 dbus_message_unref(result_msg);
1618
1619                 if (0 == result) {
1620                         *support = (bool)result_support;
1621                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1622                 } else {
1623                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1624                 }
1625         } else {
1626                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1627                 stt_dbus_reconnect();
1628                 result = STT_ERROR_TIMED_OUT;
1629         }
1630
1631         return result;
1632 }
1633
1634 int stt_dbus_request_set_start_sound(int uid, const char* file)
1635 {
1636         if (NULL == file) {
1637                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1638                 return STT_ERROR_INVALID_PARAMETER;
1639         }
1640
1641         DBusMessage* msg;
1642
1643         msg = dbus_message_new_method_call(
1644                 g_server_service_name,
1645                 g_server_service_object,
1646                 g_server_service_interface,
1647                 STT_METHOD_SET_START_SOUND);
1648
1649         if (NULL == msg) {
1650                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1651                 return STT_ERROR_OPERATION_FAILED;
1652         } else {
1653                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1654         }
1655
1656         dbus_message_append_args(msg,
1657                 DBUS_TYPE_INT32, &uid,
1658                 DBUS_TYPE_STRING, &file,
1659                 DBUS_TYPE_INVALID);
1660
1661         DBusError err;
1662         dbus_error_init(&err);
1663
1664         DBusMessage* result_msg;
1665         int result = STT_ERROR_OPERATION_FAILED;
1666
1667         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1668         dbus_message_unref(msg);
1669         if (dbus_error_is_set(&err)) {
1670                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1671                 dbus_error_free(&err);
1672         }
1673
1674         if (NULL != result_msg) {
1675                 dbus_message_get_args(result_msg, &err,
1676                         DBUS_TYPE_INT32, &result,
1677                         DBUS_TYPE_INVALID);
1678
1679                 if (dbus_error_is_set(&err)) {
1680                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1681                         dbus_error_free(&err);
1682                         result = STT_ERROR_OPERATION_FAILED;
1683                 }
1684                 dbus_message_unref(result_msg);
1685
1686                 if (0 == result) {
1687                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1688                 } else {
1689                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1690                 }
1691         } else {
1692                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1693                 stt_dbus_reconnect();
1694                 result = STT_ERROR_TIMED_OUT;
1695         }
1696
1697         return result;
1698 }
1699
1700 int stt_dbus_request_unset_start_sound(int uid)
1701 {
1702         DBusMessage* msg;
1703
1704         msg = dbus_message_new_method_call(
1705                 g_server_service_name,
1706                 g_server_service_object,
1707                 g_server_service_interface,
1708                 STT_METHOD_UNSET_START_SOUND);
1709
1710         if (NULL == msg) {
1711                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1712                 return STT_ERROR_OPERATION_FAILED;
1713         } else {
1714                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1715         }
1716
1717         dbus_message_append_args(msg,
1718                 DBUS_TYPE_INT32, &uid,
1719                 DBUS_TYPE_INVALID);
1720
1721         DBusError err;
1722         dbus_error_init(&err);
1723
1724         DBusMessage* result_msg;
1725         int result = STT_ERROR_OPERATION_FAILED;
1726
1727         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1728         dbus_message_unref(msg);
1729         if (dbus_error_is_set(&err)) {
1730                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1731                 dbus_error_free(&err);
1732         }
1733
1734         if (NULL != result_msg) {
1735                 dbus_message_get_args(result_msg, &err,
1736                         DBUS_TYPE_INT32, &result,
1737                         DBUS_TYPE_INVALID);
1738
1739                 if (dbus_error_is_set(&err)) {
1740                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1741                         dbus_error_free(&err);
1742                         result = STT_ERROR_OPERATION_FAILED;
1743                 }
1744                 dbus_message_unref(result_msg);
1745
1746                 if (0 == result) {
1747                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1748                 } else {
1749                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1750                 }
1751         } else {
1752                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1753                 stt_dbus_reconnect();
1754                 result = STT_ERROR_TIMED_OUT;
1755         }
1756
1757         return result;
1758 }
1759
1760 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1761 {
1762         if (NULL == file) {
1763                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1764                 return STT_ERROR_INVALID_PARAMETER;
1765         }
1766
1767         DBusMessage* msg;
1768
1769         msg = dbus_message_new_method_call(
1770                 g_server_service_name,
1771                 g_server_service_object,
1772                 g_server_service_interface,
1773                 STT_METHOD_SET_STOP_SOUND);
1774
1775         if (NULL == msg) {
1776                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1777                 return STT_ERROR_OPERATION_FAILED;
1778         } else {
1779                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1780         }
1781
1782         dbus_message_append_args(msg,
1783                 DBUS_TYPE_INT32, &uid,
1784                 DBUS_TYPE_STRING, &file,
1785                 DBUS_TYPE_INVALID);
1786
1787         DBusError err;
1788         dbus_error_init(&err);
1789
1790         DBusMessage* result_msg;
1791         int result = STT_ERROR_OPERATION_FAILED;
1792
1793         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1794         dbus_message_unref(msg);
1795         if (dbus_error_is_set(&err)) {
1796                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1797                 dbus_error_free(&err);
1798         }
1799
1800         if (NULL != result_msg) {
1801                 dbus_message_get_args(result_msg, &err,
1802                         DBUS_TYPE_INT32, &result,
1803                         DBUS_TYPE_INVALID);
1804
1805                 if (dbus_error_is_set(&err)) {
1806                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1807                         dbus_error_free(&err);
1808                         result = STT_ERROR_OPERATION_FAILED;
1809                 }
1810                 dbus_message_unref(result_msg);
1811
1812                 if (0 == result) {
1813                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1814                 } else {
1815                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1816                 }
1817         } else {
1818                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1819                 stt_dbus_reconnect();
1820                 result = STT_ERROR_TIMED_OUT;
1821         }
1822
1823         return result;
1824 }
1825
1826 int stt_dbus_request_unset_stop_sound(int uid)
1827 {
1828         DBusMessage* msg;
1829
1830         msg = dbus_message_new_method_call(
1831                 g_server_service_name,
1832                 g_server_service_object,
1833                 g_server_service_interface,
1834                 STT_METHOD_UNSET_STOP_SOUND);
1835
1836         if (NULL == msg) {
1837                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1838                 return STT_ERROR_OPERATION_FAILED;
1839         } else {
1840                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1841         }
1842
1843         dbus_message_append_args(msg,
1844                 DBUS_TYPE_INT32, &uid,
1845                 DBUS_TYPE_INVALID);
1846
1847         DBusError err;
1848         dbus_error_init(&err);
1849
1850         DBusMessage* result_msg;
1851         int result = STT_ERROR_OPERATION_FAILED;
1852
1853         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1854         dbus_message_unref(msg);
1855         if (dbus_error_is_set(&err)) {
1856                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1857                 dbus_error_free(&err);
1858         }
1859
1860         if (NULL != result_msg) {
1861                 dbus_message_get_args(result_msg, &err,
1862                         DBUS_TYPE_INT32, &result,
1863                         DBUS_TYPE_INVALID);
1864
1865                 if (dbus_error_is_set(&err)) {
1866                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1867                         dbus_error_free(&err);
1868                         result = STT_ERROR_OPERATION_FAILED;
1869                 }
1870                 dbus_message_unref(result_msg);
1871
1872                 if (0 == result) {
1873                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1874                 } else {
1875                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1876                 }
1877         } else {
1878                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1879                 stt_dbus_reconnect();
1880                 result = STT_ERROR_TIMED_OUT;
1881         }
1882
1883         return result;
1884 }
1885
1886 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1887 {
1888         if (NULL == lang || NULL == type || NULL == appid) {
1889                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1890                 return STT_ERROR_INVALID_PARAMETER;
1891         }
1892
1893         DBusMessage* msg;
1894
1895         /* create a signal & check for errors */
1896         msg = dbus_message_new_method_call(
1897                 g_server_service_name,
1898                 g_server_service_object,
1899                 g_server_service_interface,
1900                 STT_METHOD_START);
1901
1902         if (NULL == msg) {
1903                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1904                 return STT_ERROR_OPERATION_FAILED;
1905         } else {
1906                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1907         }
1908
1909         char *temp = NULL;
1910         if (NULL == credential) {
1911                 temp = strdup("NULL");
1912         } else {
1913                 temp = strdup(credential);
1914         }
1915
1916         dbus_message_append_args(msg,
1917                 DBUS_TYPE_INT32, &uid,
1918                 DBUS_TYPE_STRING, &lang,
1919                 DBUS_TYPE_STRING, &type,
1920                 DBUS_TYPE_INT32, &silence,
1921                 DBUS_TYPE_STRING, &appid,
1922                 DBUS_TYPE_STRING, &temp,
1923                 DBUS_TYPE_INVALID);
1924 #if 1
1925         if (g_conn_sender) {
1926                 dbus_message_set_no_reply(msg, TRUE);
1927
1928                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1929                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1930                         if (NULL != temp) {
1931                                         free(temp);
1932                                         temp = NULL;
1933                         }
1934                         return STT_ERROR_OUT_OF_MEMORY;
1935                 } else {
1936                         dbus_connection_flush(g_conn_sender);
1937                 }
1938
1939                 dbus_message_unref(msg);
1940
1941         } else {
1942                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1943                 if (NULL != temp) {
1944                                 free(temp);
1945                                 temp = NULL;
1946                 }
1947                 return STT_ERROR_OPERATION_FAILED;
1948         }
1949
1950         if (NULL != temp) {
1951                         free(temp);
1952                         temp = NULL;
1953         }
1954         return 0;
1955 #else
1956         DBusError err;
1957         dbus_error_init(&err);
1958
1959         DBusMessage* result_msg;
1960         int result = STT_ERROR_OPERATION_FAILED;
1961
1962         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1963         dbus_message_unref(msg);
1964         if (dbus_error_is_set(&err)) {
1965                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1966                 dbus_error_free(&err);
1967         }
1968
1969         if (NULL != result_msg) {
1970                 dbus_message_get_args(result_msg, &err,
1971                         DBUS_TYPE_INT32, &result,
1972                         DBUS_TYPE_INVALID);
1973
1974                 if (dbus_error_is_set(&err)) {
1975                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1976                         dbus_error_free(&err);
1977                         result = STT_ERROR_OPERATION_FAILED;
1978                 }
1979                 dbus_message_unref(result_msg);
1980
1981                 if (0 == result) {
1982                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1983                 } else {
1984                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1985                 }
1986         } else {
1987                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1988                 stt_dbus_reconnect();
1989                 result = STT_ERROR_TIMED_OUT;
1990         }
1991
1992         return result;
1993 #endif
1994 }
1995
1996 int stt_dbus_request_stop(int uid)
1997 {
1998         DBusMessage* msg;
1999
2000         /* create a signal & check for errors */
2001         msg = dbus_message_new_method_call(
2002                 g_server_service_name,
2003                 g_server_service_object,
2004                 g_server_service_interface,
2005                 STT_METHOD_STOP);
2006
2007         if (NULL == msg) {
2008                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
2009                 return STT_ERROR_OPERATION_FAILED;
2010         } else {
2011                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
2012         }
2013
2014         dbus_message_append_args(msg,
2015                 DBUS_TYPE_INT32, &uid,
2016                 DBUS_TYPE_INVALID);
2017 #if 1
2018         if (g_conn_sender) {
2019                 dbus_message_set_no_reply(msg, TRUE);
2020
2021                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2022                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2023                         return STT_ERROR_OUT_OF_MEMORY;
2024                 } else {
2025                         dbus_connection_flush(g_conn_sender);
2026                 }
2027
2028                 dbus_message_unref(msg);
2029         } else {
2030                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2031                 return STT_ERROR_OPERATION_FAILED;
2032         }
2033
2034         return 0;
2035 #else
2036         DBusError err;
2037         dbus_error_init(&err);
2038
2039         DBusMessage* result_msg;
2040         int result = STT_ERROR_OPERATION_FAILED;
2041
2042         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2043         dbus_message_unref(msg);
2044         if (dbus_error_is_set(&err)) {
2045                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2046                 dbus_error_free(&err);
2047         }
2048
2049         if (NULL != result_msg) {
2050                 dbus_message_get_args(result_msg, &err,
2051                         DBUS_TYPE_INT32, &result,
2052                         DBUS_TYPE_INVALID);
2053
2054                 if (dbus_error_is_set(&err)) {
2055                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2056                         dbus_error_free(&err);
2057                         result = STT_ERROR_OPERATION_FAILED;
2058                 }
2059                 dbus_message_unref(result_msg);
2060
2061                 if (0 == result) {
2062                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
2063                 } else {
2064                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
2065                 }
2066         } else {
2067                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2068                 stt_dbus_reconnect();
2069                 result = STT_ERROR_TIMED_OUT;
2070         }
2071
2072         return result;
2073 #endif
2074 }
2075
2076 int stt_dbus_request_cancel(int uid)
2077 {
2078         DBusMessage* msg;
2079
2080         /* create a signal & check for errors */
2081         msg = dbus_message_new_method_call(
2082                 g_server_service_name,
2083                 g_server_service_object,
2084                 g_server_service_interface,
2085                 STT_METHOD_CANCEL);
2086
2087         if (NULL == msg) {
2088                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
2089                 return STT_ERROR_OPERATION_FAILED;
2090         } else {
2091                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
2092         }
2093
2094         dbus_message_append_args(msg,
2095                 DBUS_TYPE_INT32, &uid,
2096                 DBUS_TYPE_INVALID);
2097 #if 1
2098         if (g_conn_sender) {
2099                 dbus_message_set_no_reply(msg, TRUE);
2100
2101                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2102                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2103                         return STT_ERROR_OUT_OF_MEMORY;
2104                 } else {
2105                         dbus_connection_flush(g_conn_sender);
2106                 }
2107
2108                 dbus_message_unref(msg);
2109         } else {
2110                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2111                 return STT_ERROR_OPERATION_FAILED;
2112         }
2113
2114         return 0;
2115 #else
2116         DBusError err;
2117         dbus_error_init(&err);
2118
2119         DBusMessage* result_msg;
2120         int result = STT_ERROR_OPERATION_FAILED;
2121
2122         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2123         dbus_message_unref(msg);
2124         if (dbus_error_is_set(&err)) {
2125                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2126                 dbus_error_free(&err);
2127         }
2128
2129         if (NULL != result_msg) {
2130                 dbus_message_get_args(result_msg, &err,
2131                         DBUS_TYPE_INT32, &result,
2132                         DBUS_TYPE_INVALID);
2133
2134                 if (dbus_error_is_set(&err)) {
2135                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2136                         dbus_error_free(&err);
2137                         result = STT_ERROR_OPERATION_FAILED;
2138                 }
2139                 dbus_message_unref(result_msg);
2140
2141                 if (0 == result) {
2142                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2143                 } else {
2144                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2145                 }
2146         } else {
2147                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2148                 stt_dbus_reconnect();
2149                 result = STT_ERROR_TIMED_OUT;
2150         }
2151
2152         return result;
2153 #endif
2154 }
2155
2156 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)
2157 {
2158         if (NULL == lang || NULL == type || NULL == appid) {
2159                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
2160                 return STT_ERROR_INVALID_PARAMETER;
2161         }
2162
2163         DBusMessage* msg;
2164
2165         /* create a signal & check for errors */
2166         msg = dbus_message_new_method_call(
2167                 g_server_service_name,
2168                 g_server_service_object,
2169                 g_server_service_interface,
2170                 STT_METHOD_START_FILE);
2171
2172         if (NULL == msg) {
2173                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start file : Fail to make message");
2174                 return STT_ERROR_OPERATION_FAILED;
2175         } else {
2176                 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);
2177         }
2178
2179         char *temp = NULL;
2180         if (NULL == credential) {
2181                 temp = strdup("NULL");
2182         } else {
2183                 temp = strdup(credential);
2184         }
2185
2186         dbus_message_append_args(msg,
2187                 DBUS_TYPE_INT32, &uid,
2188                 DBUS_TYPE_STRING, &lang,
2189                 DBUS_TYPE_STRING, &type,
2190                 DBUS_TYPE_INT32, &silence,
2191                 DBUS_TYPE_STRING, &appid,
2192                 DBUS_TYPE_STRING, &temp,
2193                 DBUS_TYPE_STRING, &filepath,
2194                 DBUS_TYPE_INT32, &audio_type,
2195                 DBUS_TYPE_INT32, &sample_rate,
2196                 DBUS_TYPE_INVALID);
2197         if (g_conn_sender) {
2198                 dbus_message_set_no_reply(msg, TRUE);
2199
2200                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2201                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
2202                         if (NULL != temp) {
2203                                 free(temp);
2204                                 temp = NULL;
2205                         }
2206                         return STT_ERROR_OUT_OF_MEMORY;
2207                 } else {
2208                         dbus_connection_flush(g_conn_sender);
2209                 }
2210
2211                 dbus_message_unref(msg);
2212
2213         } else {
2214                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2215                 if (NULL != temp) {
2216                                 free(temp);
2217                                 temp = NULL;
2218                 }
2219                 return STT_ERROR_OPERATION_FAILED;
2220         }
2221
2222         if (NULL != temp) {
2223                         free(temp);
2224                         temp = NULL;
2225         }
2226         return 0;
2227 }
2228
2229 int stt_dbus_request_cancel_file(int uid)
2230 {
2231         DBusMessage* msg;
2232
2233         /* create a signal & check for errors */
2234         msg = dbus_message_new_method_call(
2235                 g_server_service_name,
2236                 g_server_service_object,
2237                 g_server_service_interface,
2238                 STT_METHOD_CANCEL_FILE);
2239
2240         if (NULL == msg) {
2241                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel file : Fail to make message");
2242                 return STT_ERROR_OPERATION_FAILED;
2243         } else {
2244                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel file : uid(%d)", uid);
2245         }
2246
2247         dbus_message_append_args(msg,
2248                 DBUS_TYPE_INT32, &uid,
2249                 DBUS_TYPE_INVALID);
2250
2251         if (g_conn_sender) {
2252                 dbus_message_set_no_reply(msg, TRUE);
2253
2254                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2255                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2256                         return STT_ERROR_OUT_OF_MEMORY;
2257                 } else {
2258                         dbus_connection_flush(g_conn_sender);
2259                 }
2260
2261                 dbus_message_unref(msg);
2262         } else {
2263                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2264                 return STT_ERROR_OPERATION_FAILED;
2265         }
2266
2267         return 0;
2268 }
2269