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