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