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