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