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