client/stt_dbus.c

   1 /*
   2 *  Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *  Licensed under the Apache License, Version 2.0 (the "License");
   4 *  you may not use this file except in compliance with the License.
   5 *  You may obtain a copy of the License at
   6 *  http://www.apache.org/licenses/LICENSE-2.0
   7 *  Unless required by applicable law or agreed to in writing, software
   8 *  distributed under the License is distributed on an "AS IS" BASIS,
   9 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  10 *  See the License for the specific language governing permissions and
  11 *  limitations under the License.
  12 */
  13
  14
  15 #include "stt_main.h"
  16 #include "stt_dbus.h"
  17 #include "stt_defs.h"
  18
  19 #include "stt_client.h"
  20
  21 #include <vconf/vconf.h>
  22 #include <buxton2.h>
  23
  24 static int g_waiting_time = 3000;
  25 static int g_waiting_short_time = 500;
  26
  27 static char* g_server_service_name = NULL;
  28 static char* g_server_service_object = NULL;
  29 static char* g_server_service_interface = NULL;
  30
  31 static Ecore_Fd_Handler* g_fd_handler = NULL;
  32
  33 static DBusConnection* g_conn_sender = NULL;
  34 static DBusConnection* g_conn_listener = NULL;
  35
  36 void __stt_dbus_service_free();
  37
  38 extern int __stt_cb_error(int uid, int reason, char* err_msg);
  39
  40 extern int __stt_cb_result(int uid, int event, char** data, int data_count, const char* msg);
  41
  42 extern int __stt_cb_set_state(int uid, int state);
  43
  44 extern int __stt_cb_set_volume(int uid, float volume);
  45
  46 extern int __stt_cb_speech_status(int uid, int status);
  47
  48 char* __stt_get_service_name(char* engine_id)
  49 {
  50         char* service_name = NULL;
  51         const char* engine_default = NULL;
  52
  53         struct buxton_client * bux_cli;
  54         struct buxton_layer * bux_layer;
  55         struct buxton_value * bux_val;
  56
  57         int ret = buxton_open(&bux_cli, NULL, NULL);
  58         if (0 != ret) {
  59                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
  60                 return NULL;
  61         }
  62         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_open: %d", ret);
  63         bux_layer = buxton_create_layer("system");
  64         if (NULL == bux_layer) {
  65                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
  66                 buxton_close(bux_cli);
  67                 bux_cli = NULL;
  68                 return NULL;
  69         }
  70
  71         bux_val = buxton_value_create_string("stt-engine-default");
  72         if (NULL == bux_val) {
  73                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
  74                 buxton_free_layer(bux_layer);
  75                 buxton_close(bux_cli);
  76                 bux_layer = NULL;
  77                 bux_cli = NULL;
  78                 return NULL;
  79         }
  80
  81         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
  82         if (0 != ret) {
  83                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
  84                 buxton_value_free(bux_val);
  85                 buxton_free_layer(bux_layer);
  86                 buxton_close(bux_cli);
  87
  88                 bux_cli = NULL;
  89                 bux_layer = NULL;
  90                 bux_val = NULL;
  91                 return NULL;
  92         }
  93         ret = buxton_value_get_string(bux_val, &engine_default);
  94         if (0 != ret) {
  95                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value string, ret(%d)", ret);
  96                 buxton_value_free(bux_val);
  97                 buxton_free_layer(bux_layer);
  98                 buxton_close(bux_cli);
  99
 100                 bux_cli = NULL;
 101                 bux_layer = NULL;
 102                 bux_val = NULL;
 103                 return NULL;
 104         }
 105         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 106
 107
 108         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 109                 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + 1, sizeof(char));
 110                 if (NULL == service_name) {
 111                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 112                         buxton_value_free(bux_val);
 113                         buxton_free_layer(bux_layer);
 114                         buxton_close(bux_cli);
 115
 116                         bux_cli = NULL;
 117                         bux_layer = NULL;
 118                         bux_val = NULL;
 119                         return NULL;
 120                 }
 121                 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + 1, "%s", STT_SERVER_SERVICE_NAME);
 122         } else {
 123                 service_name = (char*)calloc(strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, sizeof(char));
 124                 if (NULL == service_name) {
 125                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 126                         buxton_value_free(bux_val);
 127                         buxton_free_layer(bux_layer);
 128                         buxton_close(bux_cli);
 129
 130                         bux_cli = NULL;
 131                         bux_layer = NULL;
 132                         bux_val = NULL;
 133                         return NULL;
 134                 }
 135                 snprintf(service_name, strlen(STT_SERVER_SERVICE_NAME) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_NAME, ".", (engine_id + 10));
 136         }
 137
 138         buxton_value_free(bux_val);
 139         buxton_free_layer(bux_layer);
 140         buxton_close(bux_cli);
 141
 142         bux_cli = NULL;
 143         bux_layer = NULL;
 144         bux_val = NULL;
 145
 146         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_name] FINISH!! service name: %s", service_name);
 147
 148         return service_name;
 149 }
 150
 151 char* __stt_get_service_object(char* engine_id)
 152 {
 153         char* service_object = NULL;
 154         const char* engine_default = NULL;
 155
 156         struct buxton_client * bux_cli;
 157         struct buxton_layer * bux_layer;
 158         struct buxton_value * bux_val;
 159
 160         int ret = buxton_open(&bux_cli, NULL, NULL);
 161         if (0 != ret) {
 162                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
 163                 return NULL;
 164         }
 165         bux_layer = buxton_create_layer("system");
 166         if (NULL == bux_layer) {
 167                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
 168                 buxton_close(bux_cli);
 169                 bux_cli = NULL;
 170                 return NULL;
 171         }
 172
 173         bux_val = buxton_value_create_string("stt-engine-default");
 174         if (NULL == bux_val) {
 175                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
 176                 buxton_free_layer(bux_layer);
 177                 buxton_close(bux_cli);
 178                 bux_layer = NULL;
 179                 bux_cli = NULL;
 180                 return NULL;
 181         }
 182
 183         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
 184         if (0 != ret) {
 185                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
 186                 buxton_value_free(bux_val);
 187                 buxton_free_layer(bux_layer);
 188                 buxton_close(bux_cli);
 189
 190                 bux_cli = NULL;
 191                 bux_layer = NULL;
 192                 bux_val = NULL;
 193                 return NULL;
 194         }
 195         ret = buxton_value_get_string(bux_val, &engine_default);
 196         if (0 != ret) {
 197                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
 198                 buxton_value_free(bux_val);
 199                 buxton_free_layer(bux_layer);
 200                 buxton_close(bux_cli);
 201
 202                 bux_cli = NULL;
 203                 bux_layer = NULL;
 204                 bux_val = NULL;
 205                 return NULL;
 206         }
 207         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 208
 209         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 210                 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, sizeof(char));
 211                 if (NULL == service_object) {
 212                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 213                         buxton_value_free(bux_val);
 214                         buxton_free_layer(bux_layer);
 215                         buxton_close(bux_cli);
 216
 217                         bux_cli = NULL;
 218                         bux_layer = NULL;
 219                         bux_val = NULL;
 220                         return NULL;
 221                 }
 222                 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + 1, "%s", STT_SERVER_SERVICE_OBJECT_PATH);
 223         } else {
 224                 service_object = (char*)calloc(strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, sizeof(char));
 225                 if (NULL == service_object) {
 226                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 227                         buxton_value_free(bux_val);
 228                         buxton_free_layer(bux_layer);
 229                         buxton_close(bux_cli);
 230
 231                         bux_cli = NULL;
 232                         bux_layer = NULL;
 233                         bux_val = NULL;
 234                         return NULL;
 235                 }
 236                 snprintf(service_object, strlen(STT_SERVER_SERVICE_OBJECT_PATH) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_OBJECT_PATH, "/", (engine_id + 10));
 237         }
 238
 239         buxton_value_free(bux_val);
 240         buxton_free_layer(bux_layer);
 241         buxton_close(bux_cli);
 242
 243         bux_cli = NULL;
 244         bux_layer = NULL;
 245         bux_val = NULL;
 246
 247         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_object] FINISH!! service object: %s", service_object);
 248
 249         return service_object;
 250 }
 251
 252 char* __stt_get_service_interface(char* engine_id)
 253 {
 254         char* service_interface = NULL;
 255         const char* engine_default = NULL;
 256
 257         struct buxton_client * bux_cli;
 258         struct buxton_layer * bux_layer;
 259         struct buxton_value * bux_val;
 260
 261         int ret = buxton_open(&bux_cli, NULL, NULL);
 262         if (0 != ret) {
 263                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to open buxton client, ret(%d)", ret);
 264                 return NULL;
 265         }
 266         bux_layer = buxton_create_layer("system");
 267         if (NULL == bux_layer) {
 268                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_create_layer FAIL");
 269                 buxton_close(bux_cli);
 270                 bux_cli = NULL;
 271                 return NULL;
 272         }
 273
 274         bux_val = buxton_value_create_string("stt-engine-default");
 275         if (NULL == bux_val) {
 276                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] buxton_value_create_string FAIL");
 277                 buxton_free_layer(bux_layer);
 278                 buxton_close(bux_cli);
 279                 bux_layer = NULL;
 280                 bux_cli = NULL;
 281                 return NULL;
 282         }
 283
 284         ret = buxton_get_value_sync(bux_cli, bux_layer, STT_ENGINE_DB_DEFAULT, &bux_val);
 285         if (0 != ret) {
 286                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get value sync, ret(%d)", ret);
 287                 buxton_value_free(bux_val);
 288                 buxton_free_layer(bux_layer);
 289                 buxton_close(bux_cli);
 290
 291                 bux_cli = NULL;
 292                 bux_layer = NULL;
 293                 bux_val = NULL;
 294                 return NULL;
 295         }
 296         ret = buxton_value_get_string(bux_val, &engine_default);
 297         if (0 != ret) {
 298                 SLOG(LOG_ERROR, TAG_STTC, "[DBUS-BUXTON2] Fail to get string, ret(%d)", ret);
 299                 buxton_value_free(bux_val);
 300                 buxton_free_layer(bux_layer);
 301                 buxton_close(bux_cli);
 302
 303                 bux_cli = NULL;
 304                 bux_layer = NULL;
 305                 bux_val = NULL;
 306                 return NULL;
 307         }
 308         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS-BUXTON2] buxton_value_get_string: engine_default: %s", engine_default);
 309
 310         if (NULL == engine_id || NULL == engine_default || 0 == strncmp(engine_id, engine_default, strlen(engine_id))) {
 311                 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + 1, sizeof(char));
 312                 if (NULL == service_interface) {
 313                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 314                         buxton_value_free(bux_val);
 315                         buxton_free_layer(bux_layer);
 316                         buxton_close(bux_cli);
 317
 318                         bux_cli = NULL;
 319                         bux_layer = NULL;
 320                         bux_val = NULL;
 321                         return NULL;
 322                 }
 323                 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + 1, "%s", STT_SERVER_SERVICE_INTERFACE);
 324         } else {
 325                 service_interface = (char*)calloc(strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, sizeof(char));
 326                 if (NULL == service_interface) {
 327                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Memory allocation Failed!!");
 328                         buxton_value_free(bux_val);
 329                         buxton_free_layer(bux_layer);
 330                         buxton_close(bux_cli);
 331
 332                         bux_cli = NULL;
 333                         bux_layer = NULL;
 334                         bux_val = NULL;
 335                         return NULL;
 336                 }
 337                 snprintf(service_interface, strlen(STT_SERVER_SERVICE_INTERFACE) + strlen(engine_id) - 8, "%s%s%s", STT_SERVER_SERVICE_INTERFACE, ".", (engine_id + 10));
 338         }
 339
 340         char* ret_char = strchr(service_interface, '-');
 341         while (NULL != ret_char) {
 342                 ret_char[0] = '_';
 343                 ret_char = strchr(service_interface, '-');
 344         }
 345
 346         buxton_value_free(bux_val);
 347         buxton_free_layer(bux_layer);
 348         ret = buxton_close(bux_cli);
 349
 350         bux_cli = NULL;
 351         bux_layer = NULL;
 352         bux_val = NULL;
 353
 354         SLOG(LOG_DEBUG, TAG_STTC, "[get_service_interface] FINISH!! service interface: %s", service_interface);
 355
 356         return service_interface;
 357 }
 358
 359
 360 static Eina_Bool listener_event_callback(void* data, Ecore_Fd_Handler *fd_handler)
 361 {
 362         if (NULL == g_conn_listener)    return ECORE_CALLBACK_RENEW;
 363
 364         dbus_connection_read_write_dispatch(g_conn_listener, 50);
 365
 366         while (1) {
 367                 DBusMessage* msg = NULL;
 368                 msg = dbus_connection_pop_message(g_conn_listener);
 369
 370                 if (true != dbus_connection_get_is_connected(g_conn_listener)) {
 371                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Connection is disconnected");
 372                         break;
 373                 }
 374
 375                 /* loop again if we haven't read a message */
 376                 if (NULL == msg) {
 377                         break;
 378                 }
 379
 380                 SLOG(LOG_DEBUG, TAG_STTC, "[DEBUG] Message is arrived");
 381
 382                 DBusError err;
 383                 dbus_error_init(&err);
 384
 385                 DBusMessage *reply = NULL;
 386
 387                 char if_name[64];
 388                 snprintf(if_name, 64, "%s%d", STT_CLIENT_SERVICE_INTERFACE, getpid());
 389
 390                 if (dbus_message_is_method_call(msg, if_name, STTD_METHOD_HELLO)) {
 391                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Hello");
 392                         int uid = 0;
 393                         int response = -1;
 394
 395                         dbus_message_get_args(msg, &err, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 396                         if (dbus_error_is_set(&err)) {
 397                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 398                                 dbus_error_free(&err);
 399                         }
 400
 401                         if (uid > 0) {
 402                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get hello : uid(%d)", uid);
 403
 404                                 /* check uid */
 405                                 stt_client_s* client = stt_client_get_by_uid(uid);
 406                                 if (NULL != client)
 407                                         response = 1;
 408                                 else
 409                                         response = 0;
 410                         } else {
 411                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get hello : invalid uid");
 412                         }
 413
 414                         reply = dbus_message_new_method_return(msg);
 415
 416                         if (NULL != reply) {
 417                                 dbus_message_append_args(reply, DBUS_TYPE_INT32, &response, DBUS_TYPE_INVALID);
 418
 419                                 if (!dbus_connection_send(g_conn_listener, reply, NULL))
 420                                         SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to send reply");
 421                                 else
 422                                         SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get hello : result(%d)", response);
 423
 424                                 dbus_connection_flush(g_conn_listener);
 425                                 dbus_message_unref(reply);
 426                         } else {
 427                                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get hello : fail to create reply message");
 428                         }
 429
 430                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 431                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 432                 } /* STTD_METHOD_HELLO */
 433
 434                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_STATE)) {
 435                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set State");
 436                         int uid = 0;
 437                         int state = -1;
 438
 439                         dbus_message_get_args(msg, &err,
 440                                 DBUS_TYPE_INT32, &uid,
 441                                 DBUS_TYPE_INT32, &state,
 442                                 DBUS_TYPE_INVALID);
 443
 444                         if (dbus_error_is_set(&err)) {
 445                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 446                                 dbus_error_free(&err);
 447                         }
 448
 449                         if (uid > 0 && state >= 0) {
 450                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set state : uid(%d), state(%d)", uid, state);
 451                                 __stt_cb_set_state(uid, state);
 452                         } else {
 453                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set state : invalid uid or state");
 454                         }
 455
 456                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 457                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 458                 } /* STTD_METHOD_SET_STATE */
 459
 460                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SET_VOLUME)) {
 461                         SLOG(LOG_DEBUG, TAG_STTC, "===== Set volume : signal");
 462                         int uid = 0;
 463                         float volume = 0;
 464
 465                         dbus_message_get_args(msg, &err,
 466                                 DBUS_TYPE_INT32, &uid,
 467                                 DBUS_TYPE_INT32, &volume,
 468                                 DBUS_TYPE_INVALID);
 469
 470                         if (dbus_error_is_set(&err)) {
 471                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 472                                 dbus_error_free(&err);
 473                         }
 474
 475                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set volume : uid(%d), volume(%f)", uid, volume);
 476                         __stt_cb_set_volume(uid, volume);
 477
 478                         /* SLOG(LOG_DEBUG, TAG_STTC, "====="); */
 479                         /* SLOG(LOG_DEBUG, TAG_STTC, " "); */
 480                 } /* STTD_METHOD_SET_VOLUME */
 481
 482                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_RESULT)) {
 483                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Result : signal");
 484                         int uid = 0;
 485                         DBusMessageIter args;
 486
 487                         dbus_message_iter_init(msg, &args);
 488
 489                         /* Get result */
 490                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 491                                 dbus_message_iter_get_basic(&args, &uid);
 492                                 dbus_message_iter_next(&args);
 493                         }
 494
 495                         stt_client_s* client = NULL;
 496                         client = stt_client_get_by_uid(uid);
 497                         if (NULL != client) {
 498                                 char** temp_result = NULL;
 499                                 char* temp_msg = NULL;
 500                                 char* temp_char = NULL;
 501                                 int temp_event = 0;
 502                                 int temp_count = 0;
 503                                 int temp_result_id = 0;
 504
 505                                 /* Get recognition type */
 506                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 507                                         dbus_message_iter_get_basic(&args, &temp_event);
 508                                         dbus_message_iter_next(&args);
 509                                 }
 510
 511                                 if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&args)) {
 512                                         dbus_message_iter_get_basic(&args, &(temp_msg));
 513                                         dbus_message_iter_next(&args);
 514                                 }
 515
 516                                 /* Get voice size */
 517                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 518                                         dbus_message_iter_get_basic(&args, &temp_count);
 519                                         dbus_message_iter_next(&args);
 520                                 }
 521
 522                                 /* Get result id */
 523                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
 524                                         dbus_message_iter_get_basic(&args, &temp_result_id);
 525                                         dbus_message_iter_next(&args);
 526                                 }
 527
 528                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get result : uid(%d) event(%d) message(%s) count(%d) result id(%d)",
 529                                         uid, temp_event, temp_msg, temp_count, temp_result_id);
 530
 531                                 if (temp_count <= 0) {
 532                                         __stt_cb_result(uid, temp_event, NULL, 0, temp_msg);
 533                                 } else {
 534                                         temp_result = (char**)calloc(temp_count, sizeof(char*));
 535
 536                                         if (NULL == temp_result)        {
 537                                                 SLOG(LOG_ERROR, TAG_STTC, "Fail : memory allocation error");
 538                                         } else {
 539                                                 int i = 0;
 540                                                 for (i = 0; i < temp_count; i++) {
 541                                                         dbus_message_iter_get_basic(&args, &(temp_char));
 542                                                         dbus_message_iter_next(&args);
 543
 544                                                         if (NULL != temp_char) {
 545                                                                 temp_result[i] = strdup(temp_char);
 546                                                                 SLOG(LOG_DEBUG, TAG_STTC, "result[%d] : %s", i, temp_result[i]);
 547                                                         }
 548                                                 }
 549
 550                                                 __stt_cb_result(uid, temp_event, temp_result, temp_count, temp_msg);
 551
 552                                                 for (i = 0; i < temp_count; i++) {
 553                                                         if (NULL != temp_result[i])
 554                                                                 free(temp_result[i]);
 555                                                 }
 556
 557                                                 free(temp_result);
 558                                         }
 559                                 }
 560                         } else {
 561                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get result : invalid uid");
 562                         }
 563
 564                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 565                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 566                 } /* STTD_METHOD_RESULT */
 567
 568                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_ERROR)) {
 569                         SLOG(LOG_DEBUG, TAG_STTC, "===== Get Error");
 570                         int uid;
 571                         int reason;
 572                         char* err_msg;
 573
 574                         dbus_message_get_args(msg, &err,
 575                                 DBUS_TYPE_INT32, &uid,
 576                                 DBUS_TYPE_INT32, &reason,
 577                                 DBUS_TYPE_STRING, &err_msg,
 578                                 DBUS_TYPE_INVALID);
 579
 580                         if (dbus_error_is_set(&err)) {
 581                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt Get Error message : Get arguments error (%s)", err.message);
 582                                 dbus_error_free(&err);
 583                         } else {
 584                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt Get Error message : uid(%d), reason(%d), err_msg(%s)", uid, reason, (NULL == err_msg) ? "NULL" : err_msg);
 585                                 __stt_cb_error(uid, reason, err_msg);
 586                         }
 587
 588                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 589                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 590                 } /* STTD_METHOD_ERROR */
 591
 592                 else if (dbus_message_is_signal(msg, if_name, STTD_METHOD_SPEECH_STATUS)) {
 593                         SLOG(LOG_DEBUG, TAG_STTC, "===== Speech status");
 594                         int uid = 0;
 595                         int status = -1;
 596
 597                         dbus_message_get_args(msg, &err,
 598                                 DBUS_TYPE_INT32, &uid,
 599                                 DBUS_TYPE_INT32, &status,
 600                                 DBUS_TYPE_INVALID);
 601
 602                         if (dbus_error_is_set(&err)) {
 603                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 604                                 dbus_error_free(&err);
 605                         }
 606
 607                         if (uid > 0 && status >= 0) {
 608                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt speech status : uid(%d), status(%d)", uid, status);
 609                                 __stt_cb_speech_status(uid, status);
 610                         } else {
 611                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set status : invalid uid or status");
 612                         }
 613
 614                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 615                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 616                 } /* STTD_METHOD_SPEECH_STATUS */
 617
 618                 else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameOwnerChanged")) {
 619                         SLOG(LOG_DEBUG, TAG_STTC, "===== Owner Changed");
 620                         __stt_cb_error(-1, STT_ERROR_SERVICE_RESET, "Daemon Reset");
 621                         SLOG(LOG_DEBUG, TAG_STTC, "=====");
 622                         SLOG(LOG_DEBUG, TAG_STTC, " ");
 623                 } /* NameOwnerChanged */
 624
 625                 else {
 626                         SLOG(LOG_DEBUG, TAG_STTC, "Message is NOT valid");
 627                         dbus_message_unref(msg);
 628                         break;
 629                 }
 630
 631                 /* free the message */
 632                 dbus_message_unref(msg);
 633         } /* while */
 634
 635         return ECORE_CALLBACK_RENEW;
 636 }
 637
 638 int stt_dbus_open_connection()
 639 {
 640         if (NULL != g_conn_sender && NULL != g_conn_listener) {
 641                 SLOG(LOG_WARN, TAG_STTC, "already existed connection ");
 642                 return 0;
 643         }
 644
 645         DBusError err;
 646
 647         /* initialise the error value */
 648         dbus_error_init(&err);
 649
 650         /* connect to the DBUS system bus, and check for errors */
 651         if (NULL == g_conn_sender) {
 652                 g_conn_sender = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 653                 if (dbus_error_is_set(&err)) {
 654                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Dbus Connection Error (%s)", err.message);
 655                         dbus_error_free(&err);
 656                 }
 657         }
 658
 659         if (NULL == g_conn_sender) {
 660                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] fail to get dbus connection");
 661                 return STT_ERROR_OPERATION_FAILED;
 662         }
 663
 664         dbus_connection_set_exit_on_disconnect(g_conn_sender, false);
 665
 666         /* connect to the DBUS system bus, and check for errors */
 667         if (NULL == g_conn_listener) {
 668                 g_conn_listener = dbus_bus_get_private(DBUS_BUS_SESSION, &err);
 669                 if (dbus_error_is_set(&err)) {
 670                         SLOG(LOG_ERROR, TAG_STTC, "Dbus Connection Error (%s)", err.message);
 671                         dbus_error_free(&err);
 672                 }
 673         }
 674
 675         if (NULL == g_conn_listener) {
 676                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get dbus connection");
 677                 return STT_ERROR_OPERATION_FAILED;
 678         }
 679
 680         int pid = getpid();
 681
 682         char service_name[64];
 683         memset(service_name, '\0', 64);
 684         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 685
 686         SLOG(LOG_DEBUG, TAG_STTC, "service name is %s", service_name);
 687
 688         /* register our name on the bus, and check for errors */
 689         dbus_bus_request_name(g_conn_listener, service_name, DBUS_NAME_FLAG_REPLACE_EXISTING , &err);
 690
 691         if (dbus_error_is_set(&err)) {
 692                 SLOG(LOG_ERROR, TAG_STTC, "Name Error (%s)", err.message);
 693                 dbus_error_free(&err);
 694         }
 695
 696         char rule[128] = {0, };
 697         snprintf(rule, 128, "type='signal',interface='%s%d'", STT_CLIENT_SERVICE_INTERFACE, pid);
 698
 699         /* add a rule for which messages we want to see */
 700         dbus_bus_add_match(g_conn_listener, rule, &err);
 701         dbus_connection_flush(g_conn_listener);
 702
 703         if (dbus_error_is_set(&err)) {
 704                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 705                 dbus_error_free(&err);
 706                 return STT_ERROR_OPERATION_FAILED;
 707         }
 708
 709         int fd = 0;
 710         if (true != dbus_connection_get_unix_fd(g_conn_listener, &fd)) {
 711                 SLOG(LOG_ERROR, TAG_STTC, "Fail to get fd from dbus");
 712                 return STT_ERROR_OPERATION_FAILED;
 713         } else {
 714                 SLOG(LOG_DEBUG, TAG_STTC, "Get fd from dbus : %d", fd);
 715         }
 716
 717         g_fd_handler = ecore_main_fd_handler_add(fd, ECORE_FD_READ, (Ecore_Fd_Cb)listener_event_callback, g_conn_listener, NULL, NULL);
 718         if (NULL == g_fd_handler) {
 719                 SLOG(LOG_ERROR, TAG_STTC, "fail to get fd handler from ecore");
 720                 return STT_ERROR_OPERATION_FAILED;
 721         }
 722
 723         return 0;
 724 }
 725
 726 int stt_dbus_close_connection()
 727 {
 728         DBusError err;
 729         dbus_error_init(&err);
 730
 731         if (NULL != g_fd_handler) {
 732                 ecore_main_fd_handler_del(g_fd_handler);
 733                 g_fd_handler = NULL;
 734         }
 735
 736         int pid = getpid();
 737
 738         char service_name[64];
 739         memset(service_name, '\0', 64);
 740         snprintf(service_name, 64, "%s%d", STT_CLIENT_SERVICE_NAME, pid);
 741
 742         dbus_bus_release_name(g_conn_listener, service_name, &err);
 743         if (dbus_error_is_set(&err)) {
 744                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Release name Error (%s)", err.message);
 745                 dbus_error_free(&err);
 746         }
 747
 748         dbus_connection_close(g_conn_sender);
 749         dbus_connection_close(g_conn_listener);
 750
 751         dbus_connection_unref(g_conn_sender);
 752         dbus_connection_unref(g_conn_listener);
 753
 754         g_conn_sender = NULL;
 755         g_conn_listener = NULL;
 756
 757         __stt_dbus_service_free();
 758
 759         return 0;
 760 }
 761
 762 int stt_dbus_reconnect()
 763 {
 764         bool sender_connected = dbus_connection_get_is_connected(g_conn_sender);
 765         bool listener_connected = dbus_connection_get_is_connected(g_conn_listener);
 766         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Sender(%s) Listener(%s)",
 767                 sender_connected ? "Connected" : "Not connected", listener_connected ? "Connected" : "Not connected");
 768
 769         if (false == sender_connected || false == listener_connected) {
 770                 stt_dbus_close_connection();
 771
 772                 if (0 != stt_dbus_open_connection()) {
 773                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to reconnect");
 774                         return -1;
 775                 }
 776
 777                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] Reconnect");
 778         }
 779
 780         return 0;
 781 }
 782
 783 void __stt_dbus_service_free()
 784 {
 785         if (NULL != g_server_service_name) {
 786                 free(g_server_service_name);
 787                 g_server_service_name = NULL;
 788         }
 789         if (NULL != g_server_service_object) {
 790                 free(g_server_service_object);
 791                 g_server_service_object = NULL;
 792         }
 793         if (NULL != g_server_service_interface) {
 794                 free(g_server_service_interface);
 795                 g_server_service_interface = NULL;
 796         }
 797 }
 798
 799 int stt_dbus_request_hello(int uid)
 800 {
 801         stt_client_s* client = stt_client_get_by_uid(uid);
 802
 803         /* Check whether there is any dbus whose name has owner or not */
 804         dbus_bool_t is_exist = FALSE;
 805         DBusError err;
 806         dbus_error_init(&err);
 807
 808         DBusMessage* msg = NULL;
 809         DBusMessage* result_msg = NULL;
 810         int result = 0;
 811
 812         if (g_conn_sender) {
 813                 if (NULL != client) {
 814                         __stt_dbus_service_free();
 815
 816                         if (NULL == client->current_engine_id) {
 817                                 /* Default engine */
 818                                 g_server_service_name = strdup(STT_SERVER_SERVICE_NAME);
 819                                 if (NULL == g_server_service_name) {
 820                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 821                                         return STT_ERROR_OUT_OF_MEMORY;
 822                                 }
 823                                 g_server_service_object = strdup(STT_SERVER_SERVICE_OBJECT_PATH);
 824                                 if (NULL == g_server_service_name) {
 825                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 826                                         return STT_ERROR_OUT_OF_MEMORY;
 827                                 }
 828                                 g_server_service_interface = strdup(STT_SERVER_SERVICE_INTERFACE);
 829                                 if (NULL == g_server_service_name) {
 830                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to allocate memory");
 831                                         return STT_ERROR_OUT_OF_MEMORY;
 832                                 }
 833
 834                                 msg = dbus_message_new_method_call(
 835                                         STT_SERVER_SERVICE_NAME,
 836                                         STT_SERVER_SERVICE_OBJECT_PATH,
 837                                         STT_SERVER_SERVICE_INTERFACE,
 838                                         STT_METHOD_HELLO);
 839                         } else {
 840                                 /* Get service name, object, interface */
 841                                 SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] current_engine_id: %s", client->current_engine_id);
 842
 843                                 g_server_service_name = __stt_get_service_name(client->current_engine_id);
 844                                 g_server_service_object = __stt_get_service_object(client->current_engine_id);
 845                                 g_server_service_interface = __stt_get_service_interface(client->current_engine_id);
 846
 847                                 if (NULL == g_server_service_name || NULL == g_server_service_object || NULL == g_server_service_interface) {
 848                                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] dbus service info invalid");
 849                                         return STT_ERROR_OPERATION_FAILED;
 850                                 }
 851
 852                                 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);
 853
 854                                 /* Custom engine */
 855                                 is_exist = dbus_bus_name_has_owner(g_conn_sender, g_server_service_name, &err);
 856                                 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);
 857
 858                                 if (TRUE == is_exist) {
 859                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: True");
 860                                         msg = dbus_message_new_method_call(
 861                                                 g_server_service_name,
 862                                                 g_server_service_object,
 863                                                 g_server_service_interface,
 864                                                 STT_METHOD_HELLO);
 865                                 } else {
 866                                         SLOG(LOG_DEBUG, TAG_STTC, "[DBUS] dbus: is_exist: False");
 867                                         msg = dbus_message_new_method_call(
 868                                                 STT_SERVER_CUSTOM_SERVICE_NAME,
 869                                                 STT_SERVER_CUSTOM_SERVICE_OBJECT_PATH,
 870                                                 STT_SERVER_CUSTOM_SERVICE_INTERFACE,
 871                                                 STT_METHOD_HELLO);
 872                                 }
 873                         }
 874                 }
 875         }
 876
 877         if (NULL == msg) {
 878 //              SLOG(LOG_ERROR, TAG_STTC, ">>>> Request stt hello : Fail to make message");
 879                 result = stt_dbus_reconnect();
 880                 if (0 != result)
 881                         return STT_ERROR_OPERATION_FAILED;
 882         }
 883
 884         if (g_conn_sender) {
 885                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 886                 dbus_message_unref(msg);
 887                 if (dbus_error_is_set(&err)) {
 888                         dbus_error_free(&err);
 889                 }
 890
 891                 if (NULL != result_msg) {
 892                         dbus_message_unref(result_msg);
 893
 894                         if (dbus_error_is_set(&err)) {
 895                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 896                                 dbus_error_free(&err);
 897                         }
 898
 899                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt hello");
 900                 } else {
 901                         if (dbus_error_is_set(&err)) {
 902                                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Get arguments error (%s)", err.message);
 903                                 dbus_error_free(&err);
 904                         }
 905
 906                         result = STT_ERROR_TIMED_OUT;
 907                 }
 908         } else {
 909                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 910                 stt_dbus_reconnect();
 911                 result = STT_ERROR_OPERATION_FAILED;
 912         }
 913
 914         return result;
 915 }
 916
 917
 918 int stt_dbus_request_initialize(int uid, bool* silence_supported, bool* credential_needed)
 919 {
 920         DBusMessage* msg;
 921
 922         msg = dbus_message_new_method_call(
 923                 g_server_service_name,
 924                 g_server_service_object,
 925                 g_server_service_interface,
 926                 STT_METHOD_INITIALIZE);
 927
 928         if (NULL == msg) {
 929                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt initialize : Fail to make message");
 930                 return STT_ERROR_OPERATION_FAILED;
 931         } else {
 932                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt initialize : uid(%d)", uid);
 933         }
 934
 935         int pid = getpid();
 936         dbus_message_append_args(msg,
 937                 DBUS_TYPE_INT32, &pid,
 938                 DBUS_TYPE_INT32, &uid,
 939                 DBUS_TYPE_INVALID);
 940
 941         DBusError err;
 942         dbus_error_init(&err);
 943
 944         DBusMessage* result_msg;
 945         int result = STT_ERROR_OPERATION_FAILED;
 946
 947         if (g_conn_sender) {
 948                 result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
 949                 dbus_message_unref(msg);
 950                 if (dbus_error_is_set(&err)) {
 951                         SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 952                         dbus_error_free(&err);
 953                 }
 954
 955                 if (NULL != result_msg) {
 956                         int int_silence_supported = 0;
 957                         int int_credential_needed = 0;
 958                         dbus_message_get_args(result_msg, &err,
 959                                 DBUS_TYPE_INT32, &result,
 960                                 DBUS_TYPE_INT32, &int_silence_supported,
 961                                 DBUS_TYPE_INT32, &int_credential_needed,
 962                                 DBUS_TYPE_INVALID);
 963
 964                         *silence_supported = (bool)(int_silence_supported);
 965                         *credential_needed = (bool)(int_credential_needed);
 966
 967                         if (dbus_error_is_set(&err)) {
 968                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 969                                 dbus_error_free(&err);
 970                                 result = STT_ERROR_OPERATION_FAILED;
 971                         }
 972
 973                         if (0 == result) {
 974                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
 975                                         result, *silence_supported, *credential_needed);
 976
 977                                 /* add a rule for daemon error */
 978                                 char rule_err[256] = {0, };
 979                                 snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", STT_SERVER_SERVICE_INTERFACE);
 980                                 dbus_bus_add_match(g_conn_listener, rule_err, &err);
 981                                 dbus_connection_flush(g_conn_listener);
 982
 983                                 if (dbus_error_is_set(&err)) {
 984                                         SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
 985                                         dbus_error_free(&err);
 986                                         return STT_ERROR_OPERATION_FAILED;
 987                                 }
 988                         } else {
 989                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 990                         }
 991
 992                         dbus_message_unref(result_msg);
 993                 } else {
 994                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 995                         stt_dbus_reconnect();
 996                         result = STT_ERROR_TIMED_OUT;
 997                 }
 998         } else {
 999                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1000                 result = STT_ERROR_OPERATION_FAILED;
1001         }
1002
1003         return result;
1004 }
1005
1006 int stt_dbus_request_finalize(int uid)
1007 {
1008         DBusMessage* msg;
1009
1010         DBusError err;
1011         dbus_error_init(&err);
1012
1013         /* remove a rule for daemon error */
1014         char rule_err[256] = {0, };
1015         snprintf(rule_err, 256, "sender='org.freedesktop.DBus',path='/org/freedesktop/DBus',interface='org.freedesktop.DBus',member='NameOwnerChanged',type='signal',arg0='%s'", STT_SERVER_SERVICE_INTERFACE);
1016         dbus_bus_remove_match(g_conn_listener, rule_err, &err);
1017         dbus_connection_flush(g_conn_listener);
1018         if (dbus_error_is_set(&err)) {
1019                 SLOG(LOG_ERROR, TAG_STTC, "Match Error (%s)", err.message);
1020                 dbus_error_free(&err);
1021         }
1022
1023         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);
1024
1025         msg = dbus_message_new_method_call(
1026                 g_server_service_name,
1027                 g_server_service_object,
1028                 g_server_service_interface,
1029                 STT_METHOD_FINALIZE);
1030
1031         if (NULL == msg) {
1032                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
1033                 return STT_ERROR_OPERATION_FAILED;
1034         } else {
1035                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
1036         }
1037
1038         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1039
1040         DBusMessage* result_msg;
1041         int result = STT_ERROR_OPERATION_FAILED;
1042
1043         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
1044         dbus_message_unref(msg);
1045         if (dbus_error_is_set(&err)) {
1046                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1047                 dbus_error_free(&err);
1048         }
1049
1050         if (NULL != result_msg) {
1051                 dbus_message_get_args(result_msg, &err,
1052                                 DBUS_TYPE_INT32, &result,
1053                                 DBUS_TYPE_INVALID);
1054
1055                 if (dbus_error_is_set(&err)) {
1056                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1057                         dbus_error_free(&err);
1058                         result = STT_ERROR_OPERATION_FAILED;
1059                 }
1060
1061                 dbus_message_unref(result_msg);
1062
1063                 if (0 == result) {
1064                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1065                 } else {
1066                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
1067                 }
1068         } else {
1069                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1070                 stt_dbus_reconnect();
1071                 result = STT_ERROR_TIMED_OUT;
1072         }
1073
1074         return result;
1075 }
1076
1077 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1078 {
1079         DBusMessage* msg;
1080
1081         msg = dbus_message_new_method_call(
1082                 g_server_service_name,
1083                 g_server_service_object,
1084                 g_server_service_interface,
1085                 STT_METHOD_SET_CURRENT_ENGINE);
1086
1087
1088         if (NULL == msg) {
1089                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1090                 return STT_ERROR_OPERATION_FAILED;
1091         } else {
1092                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1093         }
1094
1095         dbus_message_append_args(msg,
1096                 DBUS_TYPE_INT32, &uid,
1097                 DBUS_TYPE_STRING, &engine_id,
1098                 DBUS_TYPE_INVALID);
1099
1100         DBusError err;
1101         dbus_error_init(&err);
1102
1103         DBusMessage* result_msg;
1104         int result = STT_ERROR_OPERATION_FAILED;
1105
1106         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1107         dbus_message_unref(msg);
1108         if (dbus_error_is_set(&err)) {
1109                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1110                 dbus_error_free(&err);
1111         }
1112
1113         if (NULL != result_msg) {
1114                 int int_silence_supported = 0;
1115                 int int_credential_needed = 0;
1116
1117                 dbus_message_get_args(result_msg, &err,
1118                         DBUS_TYPE_INT32, &result,
1119                         DBUS_TYPE_INT32, &int_silence_supported,
1120                         DBUS_TYPE_INT32, &int_credential_needed,
1121                         DBUS_TYPE_INVALID);
1122
1123                 *silence_supported = (bool)(int_silence_supported);
1124                 *credential_needed = (bool)(int_credential_needed);
1125
1126                 if (dbus_error_is_set(&err)) {
1127                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1128                         dbus_error_free(&err);
1129                         result = STT_ERROR_OPERATION_FAILED;
1130                 }
1131
1132                 dbus_message_unref(result_msg);
1133
1134                 if (0 == result) {
1135                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1136                                 result, *silence_supported, *credential_needed);
1137                 } else {
1138                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1139                 }
1140         } else {
1141                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1142                 stt_dbus_reconnect();
1143                 result = STT_ERROR_TIMED_OUT;
1144         }
1145
1146         return result;
1147 }
1148
1149 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1150 {
1151         if (NULL == appid || NULL == value) {
1152                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1153                 return STT_ERROR_INVALID_PARAMETER;
1154         }
1155
1156         DBusMessage* msg;
1157
1158         msg = dbus_message_new_method_call(
1159                 g_server_service_name,
1160                 g_server_service_object,
1161                 g_server_service_interface,
1162                 STT_METHOD_CHECK_APP_AGREED);
1163
1164         if (NULL == msg) {
1165                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1166                 return STT_ERROR_OPERATION_FAILED;
1167         } else {
1168                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1169         }
1170
1171         dbus_message_append_args(msg,
1172                 DBUS_TYPE_INT32, &uid,
1173                 DBUS_TYPE_STRING, &appid,
1174                 DBUS_TYPE_INVALID);
1175
1176         DBusError err;
1177         dbus_error_init(&err);
1178
1179         DBusMessage* result_msg;
1180         int result = STT_ERROR_OPERATION_FAILED;
1181         int available = -1;
1182
1183         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1184         dbus_message_unref(msg);
1185         if (dbus_error_is_set(&err)) {
1186                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1187                 dbus_error_free(&err);
1188         }
1189
1190         if (NULL != result_msg) {
1191                 dbus_message_get_args(result_msg, &err,
1192                         DBUS_TYPE_INT32, &result,
1193                         DBUS_TYPE_INT32, &available,
1194                         DBUS_TYPE_INVALID);
1195
1196                 if (dbus_error_is_set(&err)) {
1197                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1198                         dbus_error_free(&err);
1199                         result = STT_ERROR_OPERATION_FAILED;
1200                 }
1201                 dbus_message_unref(result_msg);
1202
1203                 if (0 == result) {
1204                         *value = (bool)available;
1205                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1206                 } else {
1207                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1208                 }
1209         } else {
1210                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1211                 stt_dbus_reconnect();
1212                 result = STT_ERROR_TIMED_OUT;
1213         }
1214
1215         return result;
1216 }
1217
1218 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1219 {
1220         if (NULL == stt || NULL == callback) {
1221                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1222                 return STT_ERROR_INVALID_PARAMETER;
1223         }
1224
1225         DBusMessage* msg;
1226
1227         msg = dbus_message_new_method_call(
1228                 g_server_service_name,
1229                 g_server_service_object,
1230                 g_server_service_interface,
1231                 STT_METHOD_GET_SUPPORT_LANGS);
1232
1233         if (NULL == msg) {
1234                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1235                 return STT_ERROR_OPERATION_FAILED;
1236         } else {
1237                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1238         }
1239
1240         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1241
1242         DBusError err;
1243         dbus_error_init(&err);
1244
1245         DBusMessage* result_msg;
1246         DBusMessageIter args;
1247         int result = STT_ERROR_OPERATION_FAILED;
1248
1249         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1250         dbus_message_unref(msg);
1251         if (dbus_error_is_set(&err)) {
1252                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1253                 dbus_error_free(&err);
1254         }
1255
1256         if (NULL != result_msg) {
1257                 if (dbus_message_iter_init(result_msg, &args)) {
1258                         /* Get result */
1259                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1260                                 dbus_message_iter_get_basic(&args, &result);
1261                                 dbus_message_iter_next(&args);
1262                         }
1263
1264                         if (0 == result) {
1265                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1266
1267                                 /* Get voice size */
1268                                 int size = 0;
1269                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1270                                         dbus_message_iter_get_basic(&args, &size);
1271                                         dbus_message_iter_next(&args);
1272                                 }
1273
1274                                 if (0 >= size) {
1275                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1276                                 } else {
1277                                         int i = 0;
1278                                         char* temp_lang;
1279
1280                                         for (i = 0; i < size; i++) {
1281                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
1282                                                 dbus_message_iter_next(&args);
1283
1284                                                 if (true != callback(stt, temp_lang, user_data)) {
1285                                                         break;
1286                                                 }
1287                                         }
1288                                 }
1289                         } else {
1290                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1291                         }
1292                 }
1293                 dbus_message_unref(result_msg);
1294         } else {
1295                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1296                 stt_dbus_reconnect();
1297                 result = STT_ERROR_TIMED_OUT;
1298         }
1299
1300         return result;
1301 }
1302
1303 int stt_dbus_request_get_default_lang(int uid, char** language)
1304 {
1305         if (NULL == language) {
1306                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1307                 return STT_ERROR_INVALID_PARAMETER;
1308         }
1309
1310         DBusMessage* msg;
1311
1312         msg = dbus_message_new_method_call(
1313                 g_server_service_name,
1314                 g_server_service_object,
1315                 g_server_service_interface,
1316                 STT_METHOD_GET_CURRENT_LANG);
1317
1318         if (NULL == msg) {
1319                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1320                 return STT_ERROR_OPERATION_FAILED;
1321         } else {
1322                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
1323         }
1324
1325         dbus_message_append_args(msg,
1326                 DBUS_TYPE_INT32, &uid,
1327                 DBUS_TYPE_INVALID);
1328
1329         DBusError err;
1330         dbus_error_init(&err);
1331
1332         DBusMessage* result_msg;
1333         int result = STT_ERROR_OPERATION_FAILED;
1334         char* temp_lang = NULL;
1335
1336         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1337         dbus_message_unref(msg);
1338         if (dbus_error_is_set(&err)) {
1339                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1340                 dbus_error_free(&err);
1341         }
1342
1343         if (NULL != result_msg) {
1344                 dbus_message_get_args(result_msg, &err,
1345                         DBUS_TYPE_INT32, &result,
1346                         DBUS_TYPE_STRING, &temp_lang,
1347                         DBUS_TYPE_INVALID);
1348
1349                 if (dbus_error_is_set(&err)) {
1350                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1351                         dbus_error_free(&err);
1352                         result = STT_ERROR_OPERATION_FAILED;
1353                 }
1354                 dbus_message_unref(result_msg);
1355
1356                 if (0 == result) {
1357                         *language = strdup(temp_lang);
1358                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1359                 } else {
1360                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1361                 }
1362         } else {
1363                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1364                 stt_dbus_reconnect();
1365                 result = STT_ERROR_TIMED_OUT;
1366         }
1367
1368         return result;
1369 }
1370
1371 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1372 {
1373         if (NULL == key || NULL == data) {
1374                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1375                 return STT_ERROR_INVALID_PARAMETER;
1376         }
1377
1378         DBusMessage* msg;
1379
1380         msg = dbus_message_new_method_call(
1381                 g_server_service_name,
1382                 g_server_service_object,
1383                 g_server_service_interface,
1384                 STT_METHOD_SET_PRIVATE_DATA);
1385
1386         if (NULL == msg) {
1387                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
1388                 return STT_ERROR_OPERATION_FAILED;
1389         } else {
1390                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1391         }
1392
1393         if (true != dbus_message_append_args(msg,
1394                         DBUS_TYPE_INT32, &uid,
1395                         DBUS_TYPE_STRING, &key,
1396                         DBUS_TYPE_STRING, &data,
1397                         DBUS_TYPE_INVALID)) {
1398                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1399                 return STT_ERROR_OPERATION_FAILED;
1400         }
1401
1402         DBusError err;
1403         dbus_error_init(&err);
1404
1405         DBusMessage* result_msg;
1406         int result = STT_ERROR_OPERATION_FAILED;
1407
1408         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1409         dbus_message_unref(msg);
1410         if (dbus_error_is_set(&err)) {
1411                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1412                 dbus_error_free(&err);
1413         }
1414
1415         if (NULL != result_msg) {
1416                 dbus_message_get_args(result_msg, &err,
1417                         DBUS_TYPE_INT32, &result,
1418                         DBUS_TYPE_INVALID);
1419
1420                 if (dbus_error_is_set(&err)) {
1421                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1422                         dbus_error_free(&err);
1423                         result = STT_ERROR_OPERATION_FAILED;
1424                 }
1425                 dbus_message_unref(result_msg);
1426
1427                 if (0 == result) {
1428                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1429                 } else {
1430                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
1431                 }
1432         } else {
1433                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1434                 stt_dbus_reconnect();
1435                 result = STT_ERROR_TIMED_OUT;
1436         }
1437
1438         return result;
1439 }
1440
1441 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1442 {
1443         if (NULL == key || NULL == data) {
1444                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1445                 return STT_ERROR_INVALID_PARAMETER;
1446         }
1447
1448         DBusMessage* msg;
1449
1450         msg = dbus_message_new_method_call(
1451                 g_server_service_name,
1452                 g_server_service_object,
1453                 g_server_service_interface,
1454                 STT_METHOD_GET_PRIVATE_DATA);
1455
1456         if (NULL == msg) {
1457                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
1458                 return STT_ERROR_OPERATION_FAILED;
1459         } else {
1460                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1461         }
1462
1463         if (true != dbus_message_append_args(msg,
1464                         DBUS_TYPE_INT32, &uid,
1465                         DBUS_TYPE_STRING, &key,
1466                         DBUS_TYPE_INVALID)) {
1467                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1468                 return STT_ERROR_OPERATION_FAILED;
1469         }
1470
1471         DBusError err;
1472         dbus_error_init(&err);
1473
1474         DBusMessage* result_msg;
1475         int result = STT_ERROR_OPERATION_FAILED;
1476
1477         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1478         dbus_message_unref(msg);
1479         if (dbus_error_is_set(&err)) {
1480                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1481                 dbus_error_free(&err);
1482         }
1483
1484         char* temp = NULL;
1485         if (NULL != result_msg) {
1486                 dbus_message_get_args(result_msg, &err,
1487                         DBUS_TYPE_INT32, &result,
1488                         DBUS_TYPE_STRING, &temp,
1489                         DBUS_TYPE_INVALID);
1490
1491                 if (dbus_error_is_set(&err)) {
1492                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1493                         dbus_error_free(&err);
1494                         result = STT_ERROR_OPERATION_FAILED;
1495                 }
1496                 dbus_message_unref(result_msg);
1497
1498                 if (0 == result) {
1499                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1500                         if (NULL != temp) {
1501                                 *data = strdup(temp);
1502                         }
1503                 } else {
1504                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1505                 }
1506         } else {
1507                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1508                 stt_dbus_reconnect();
1509                 result = STT_ERROR_TIMED_OUT;
1510         }
1511
1512         return result;
1513 }
1514
1515
1516
1517 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1518 {
1519         if (NULL == support || NULL == type) {
1520                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1521                 return STT_ERROR_INVALID_PARAMETER;
1522         }
1523
1524         DBusMessage* msg;
1525
1526         msg = dbus_message_new_method_call(
1527                 g_server_service_name,
1528                 g_server_service_object,
1529                 g_server_service_interface,
1530                 STT_METHOD_IS_TYPE_SUPPORTED);
1531
1532         if (NULL == msg) {
1533                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1534                 return STT_ERROR_OPERATION_FAILED;
1535         } else {
1536                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1537         }
1538
1539         dbus_message_append_args(msg,
1540                 DBUS_TYPE_INT32, &uid,
1541                 DBUS_TYPE_STRING, &type,
1542                 DBUS_TYPE_INVALID);
1543
1544         DBusError err;
1545         dbus_error_init(&err);
1546
1547         DBusMessage* result_msg;
1548         int result = STT_ERROR_OPERATION_FAILED;
1549         int result_support = -1;
1550
1551         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1552         dbus_message_unref(msg);
1553         if (dbus_error_is_set(&err)) {
1554                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1555                 dbus_error_free(&err);
1556         }
1557
1558         if (NULL != result_msg) {
1559                 dbus_message_get_args(result_msg, &err,
1560                         DBUS_TYPE_INT32, &result,
1561                         DBUS_TYPE_INT32, &result_support,
1562                         DBUS_TYPE_INVALID);
1563
1564                 if (dbus_error_is_set(&err)) {
1565                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1566                         dbus_error_free(&err);
1567                         result = STT_ERROR_OPERATION_FAILED;
1568                 }
1569                 dbus_message_unref(result_msg);
1570
1571                 if (0 == result) {
1572                         *support = (bool)result_support;
1573                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1574                 } else {
1575                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1576                 }
1577         } else {
1578                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1579                 stt_dbus_reconnect();
1580                 result = STT_ERROR_TIMED_OUT;
1581         }
1582
1583         return result;
1584 }
1585
1586 int stt_dbus_request_set_start_sound(int uid, const char* file)
1587 {
1588         if (NULL == file) {
1589                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1590                 return STT_ERROR_INVALID_PARAMETER;
1591         }
1592
1593         DBusMessage* msg;
1594
1595         msg = dbus_message_new_method_call(
1596                 g_server_service_name,
1597                 g_server_service_object,
1598                 g_server_service_interface,
1599                 STT_METHOD_SET_START_SOUND);
1600
1601         if (NULL == msg) {
1602                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1603                 return STT_ERROR_OPERATION_FAILED;
1604         } else {
1605                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1606         }
1607
1608         dbus_message_append_args(msg,
1609                 DBUS_TYPE_INT32, &uid,
1610                 DBUS_TYPE_STRING, &file,
1611                 DBUS_TYPE_INVALID);
1612
1613         DBusError err;
1614         dbus_error_init(&err);
1615
1616         DBusMessage* result_msg;
1617         int result = STT_ERROR_OPERATION_FAILED;
1618
1619         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1620         dbus_message_unref(msg);
1621         if (dbus_error_is_set(&err)) {
1622                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1623                 dbus_error_free(&err);
1624         }
1625
1626         if (NULL != result_msg) {
1627                 dbus_message_get_args(result_msg, &err,
1628                         DBUS_TYPE_INT32, &result,
1629                         DBUS_TYPE_INVALID);
1630
1631                 if (dbus_error_is_set(&err)) {
1632                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1633                         dbus_error_free(&err);
1634                         result = STT_ERROR_OPERATION_FAILED;
1635                 }
1636                 dbus_message_unref(result_msg);
1637
1638                 if (0 == result) {
1639                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1640                 } else {
1641                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1642                 }
1643         } else {
1644                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1645                 stt_dbus_reconnect();
1646                 result = STT_ERROR_TIMED_OUT;
1647         }
1648
1649         return result;
1650 }
1651
1652 int stt_dbus_request_unset_start_sound(int uid)
1653 {
1654         DBusMessage* msg;
1655
1656         msg = dbus_message_new_method_call(
1657                 g_server_service_name,
1658                 g_server_service_object,
1659                 g_server_service_interface,
1660                 STT_METHOD_UNSET_START_SOUND);
1661
1662         if (NULL == msg) {
1663                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1664                 return STT_ERROR_OPERATION_FAILED;
1665         } else {
1666                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1667         }
1668
1669         dbus_message_append_args(msg,
1670                 DBUS_TYPE_INT32, &uid,
1671                 DBUS_TYPE_INVALID);
1672
1673         DBusError err;
1674         dbus_error_init(&err);
1675
1676         DBusMessage* result_msg;
1677         int result = STT_ERROR_OPERATION_FAILED;
1678
1679         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1680         dbus_message_unref(msg);
1681         if (dbus_error_is_set(&err)) {
1682                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1683                 dbus_error_free(&err);
1684         }
1685
1686         if (NULL != result_msg) {
1687                 dbus_message_get_args(result_msg, &err,
1688                         DBUS_TYPE_INT32, &result,
1689                         DBUS_TYPE_INVALID);
1690
1691                 if (dbus_error_is_set(&err)) {
1692                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1693                         dbus_error_free(&err);
1694                         result = STT_ERROR_OPERATION_FAILED;
1695                 }
1696                 dbus_message_unref(result_msg);
1697
1698                 if (0 == result) {
1699                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1700                 } else {
1701                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1702                 }
1703         } else {
1704                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1705                 stt_dbus_reconnect();
1706                 result = STT_ERROR_TIMED_OUT;
1707         }
1708
1709         return result;
1710 }
1711
1712 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1713 {
1714         if (NULL == file) {
1715                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1716                 return STT_ERROR_INVALID_PARAMETER;
1717         }
1718
1719         DBusMessage* msg;
1720
1721         msg = dbus_message_new_method_call(
1722                 g_server_service_name,
1723                 g_server_service_object,
1724                 g_server_service_interface,
1725                 STT_METHOD_SET_STOP_SOUND);
1726
1727         if (NULL == msg) {
1728                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1729                 return STT_ERROR_OPERATION_FAILED;
1730         } else {
1731                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1732         }
1733
1734         dbus_message_append_args(msg,
1735                 DBUS_TYPE_INT32, &uid,
1736                 DBUS_TYPE_STRING, &file,
1737                 DBUS_TYPE_INVALID);
1738
1739         DBusError err;
1740         dbus_error_init(&err);
1741
1742         DBusMessage* result_msg;
1743         int result = STT_ERROR_OPERATION_FAILED;
1744
1745         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1746         dbus_message_unref(msg);
1747         if (dbus_error_is_set(&err)) {
1748                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1749                 dbus_error_free(&err);
1750         }
1751
1752         if (NULL != result_msg) {
1753                 dbus_message_get_args(result_msg, &err,
1754                         DBUS_TYPE_INT32, &result,
1755                         DBUS_TYPE_INVALID);
1756
1757                 if (dbus_error_is_set(&err)) {
1758                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1759                         dbus_error_free(&err);
1760                         result = STT_ERROR_OPERATION_FAILED;
1761                 }
1762                 dbus_message_unref(result_msg);
1763
1764                 if (0 == result) {
1765                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1766                 } else {
1767                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1768                 }
1769         } else {
1770                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1771                 stt_dbus_reconnect();
1772                 result = STT_ERROR_TIMED_OUT;
1773         }
1774
1775         return result;
1776 }
1777
1778 int stt_dbus_request_unset_stop_sound(int uid)
1779 {
1780         DBusMessage* msg;
1781
1782         msg = dbus_message_new_method_call(
1783                 g_server_service_name,
1784                 g_server_service_object,
1785                 g_server_service_interface,
1786                 STT_METHOD_UNSET_STOP_SOUND);
1787
1788         if (NULL == msg) {
1789                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1790                 return STT_ERROR_OPERATION_FAILED;
1791         } else {
1792                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1793         }
1794
1795         dbus_message_append_args(msg,
1796                 DBUS_TYPE_INT32, &uid,
1797                 DBUS_TYPE_INVALID);
1798
1799         DBusError err;
1800         dbus_error_init(&err);
1801
1802         DBusMessage* result_msg;
1803         int result = STT_ERROR_OPERATION_FAILED;
1804
1805         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1806         dbus_message_unref(msg);
1807         if (dbus_error_is_set(&err)) {
1808                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1809                 dbus_error_free(&err);
1810         }
1811
1812         if (NULL != result_msg) {
1813                 dbus_message_get_args(result_msg, &err,
1814                         DBUS_TYPE_INT32, &result,
1815                         DBUS_TYPE_INVALID);
1816
1817                 if (dbus_error_is_set(&err)) {
1818                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1819                         dbus_error_free(&err);
1820                         result = STT_ERROR_OPERATION_FAILED;
1821                 }
1822                 dbus_message_unref(result_msg);
1823
1824                 if (0 == result) {
1825                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1826                 } else {
1827                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1828                 }
1829         } else {
1830                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1831                 stt_dbus_reconnect();
1832                 result = STT_ERROR_TIMED_OUT;
1833         }
1834
1835         return result;
1836 }
1837
1838 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1839 {
1840         if (NULL == lang || NULL == type || NULL == appid) {
1841                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1842                 return STT_ERROR_INVALID_PARAMETER;
1843         }
1844
1845         DBusMessage* msg;
1846
1847         /* create a signal & check for errors */
1848         msg = dbus_message_new_method_call(
1849                 g_server_service_name,
1850                 g_server_service_object,
1851                 g_server_service_interface,
1852                 STT_METHOD_START);
1853
1854         if (NULL == msg) {
1855                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1856                 return STT_ERROR_OPERATION_FAILED;
1857         } else {
1858                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1859         }
1860
1861         char *temp = NULL;
1862         if (NULL == credential) {
1863                 temp = strdup("NULL");
1864         } else {
1865                 temp = strdup(credential);
1866         }
1867
1868         dbus_message_append_args(msg,
1869                 DBUS_TYPE_INT32, &uid,
1870                 DBUS_TYPE_STRING, &lang,
1871                 DBUS_TYPE_STRING, &type,
1872                 DBUS_TYPE_INT32, &silence,
1873                 DBUS_TYPE_STRING, &appid,
1874                 DBUS_TYPE_STRING, &temp,
1875                 DBUS_TYPE_INVALID);
1876 #if 1
1877         if (g_conn_sender) {
1878                 dbus_message_set_no_reply(msg, TRUE);
1879
1880                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1881                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1882                         if (NULL != temp) {
1883                                         free(temp);
1884                                         temp = NULL;
1885                         }
1886                         return STT_ERROR_OUT_OF_MEMORY;
1887                 } else {
1888                         dbus_connection_flush(g_conn_sender);
1889                 }
1890
1891                 dbus_message_unref(msg);
1892
1893         } else {
1894                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1895                 if (NULL != temp) {
1896                                 free(temp);
1897                                 temp = NULL;
1898                 }
1899                 return STT_ERROR_OPERATION_FAILED;
1900         }
1901
1902         if (NULL != temp) {
1903                         free(temp);
1904                         temp = NULL;
1905         }
1906         return 0;
1907 #else
1908         DBusError err;
1909         dbus_error_init(&err);
1910
1911         DBusMessage* result_msg;
1912         int result = STT_ERROR_OPERATION_FAILED;
1913
1914         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1915         dbus_message_unref(msg);
1916         if (dbus_error_is_set(&err)) {
1917                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1918                 dbus_error_free(&err);
1919         }
1920
1921         if (NULL != result_msg) {
1922                 dbus_message_get_args(result_msg, &err,
1923                         DBUS_TYPE_INT32, &result,
1924                         DBUS_TYPE_INVALID);
1925
1926                 if (dbus_error_is_set(&err)) {
1927                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1928                         dbus_error_free(&err);
1929                         result = STT_ERROR_OPERATION_FAILED;
1930                 }
1931                 dbus_message_unref(result_msg);
1932
1933                 if (0 == result) {
1934                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1935                 } else {
1936                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1937                 }
1938         } else {
1939                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1940                 stt_dbus_reconnect();
1941                 result = STT_ERROR_TIMED_OUT;
1942         }
1943
1944         return result;
1945 #endif
1946 }
1947
1948 int stt_dbus_request_stop(int uid)
1949 {
1950         DBusMessage* msg;
1951
1952         /* create a signal & check for errors */
1953         msg = dbus_message_new_method_call(
1954                 g_server_service_name,
1955                 g_server_service_object,
1956                 g_server_service_interface,
1957                 STT_METHOD_STOP);
1958
1959         if (NULL == msg) {
1960                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1961                 return STT_ERROR_OPERATION_FAILED;
1962         } else {
1963                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1964         }
1965
1966         dbus_message_append_args(msg,
1967                 DBUS_TYPE_INT32, &uid,
1968                 DBUS_TYPE_INVALID);
1969 #if 1
1970         if (g_conn_sender) {
1971                 dbus_message_set_no_reply(msg, TRUE);
1972
1973                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1974                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1975                         return STT_ERROR_OUT_OF_MEMORY;
1976                 } else {
1977                         dbus_connection_flush(g_conn_sender);
1978                 }
1979
1980                 dbus_message_unref(msg);
1981         } else {
1982                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1983                 return STT_ERROR_OPERATION_FAILED;
1984         }
1985
1986         return 0;
1987 #else
1988         DBusError err;
1989         dbus_error_init(&err);
1990
1991         DBusMessage* result_msg;
1992         int result = STT_ERROR_OPERATION_FAILED;
1993
1994         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1995         dbus_message_unref(msg);
1996         if (dbus_error_is_set(&err)) {
1997                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1998                 dbus_error_free(&err);
1999         }
2000
2001         if (NULL != result_msg) {
2002                 dbus_message_get_args(result_msg, &err,
2003                         DBUS_TYPE_INT32, &result,
2004                         DBUS_TYPE_INVALID);
2005
2006                 if (dbus_error_is_set(&err)) {
2007                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2008                         dbus_error_free(&err);
2009                         result = STT_ERROR_OPERATION_FAILED;
2010                 }
2011                 dbus_message_unref(result_msg);
2012
2013                 if (0 == result) {
2014                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
2015                 } else {
2016                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
2017                 }
2018         } else {
2019                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2020                 stt_dbus_reconnect();
2021                 result = STT_ERROR_TIMED_OUT;
2022         }
2023
2024         return result;
2025 #endif
2026 }
2027
2028 int stt_dbus_request_cancel(int uid)
2029 {
2030         DBusMessage* msg;
2031
2032         /* create a signal & check for errors */
2033         msg = dbus_message_new_method_call(
2034                 g_server_service_name,
2035                 g_server_service_object,
2036                 g_server_service_interface,
2037                 STT_METHOD_CANCEL);
2038
2039         if (NULL == msg) {
2040                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
2041                 return STT_ERROR_OPERATION_FAILED;
2042         } else {
2043                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
2044         }
2045
2046         dbus_message_append_args(msg,
2047                 DBUS_TYPE_INT32, &uid,
2048                 DBUS_TYPE_INVALID);
2049 #if 1
2050         if (g_conn_sender) {
2051                 dbus_message_set_no_reply(msg, TRUE);
2052
2053                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
2054                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
2055                         return STT_ERROR_OUT_OF_MEMORY;
2056                 } else {
2057                         dbus_connection_flush(g_conn_sender);
2058                 }
2059
2060                 dbus_message_unref(msg);
2061         } else {
2062                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
2063                 return STT_ERROR_OPERATION_FAILED;
2064         }
2065
2066         return 0;
2067 #else
2068         DBusError err;
2069         dbus_error_init(&err);
2070
2071         DBusMessage* result_msg;
2072         int result = STT_ERROR_OPERATION_FAILED;
2073
2074         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2075         dbus_message_unref(msg);
2076         if (dbus_error_is_set(&err)) {
2077                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2078                 dbus_error_free(&err);
2079         }
2080
2081         if (NULL != result_msg) {
2082                 dbus_message_get_args(result_msg, &err,
2083                         DBUS_TYPE_INT32, &result,
2084                         DBUS_TYPE_INVALID);
2085
2086                 if (dbus_error_is_set(&err)) {
2087                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2088                         dbus_error_free(&err);
2089                         result = STT_ERROR_OPERATION_FAILED;
2090                 }
2091                 dbus_message_unref(result_msg);
2092
2093                 if (0 == result) {
2094                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2095                 } else {
2096                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2097                 }
2098         } else {
2099                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2100                 stt_dbus_reconnect();
2101                 result = STT_ERROR_TIMED_OUT;
2102         }
2103
2104         return result;
2105 #endif
2106 }