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("user");
  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("user");
 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("user");
 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                         dbus_message_get_args(result_msg, &err,
 923                                 DBUS_TYPE_INT32, &result,
 924                                 DBUS_TYPE_INT32, silence_supported,
 925                                 DBUS_TYPE_INT32, credential_needed,
 926                                 DBUS_TYPE_INVALID);
 927
 928                         if (dbus_error_is_set(&err)) {
 929                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 930                                 dbus_error_free(&err);
 931                                 result = STT_ERROR_OPERATION_FAILED;
 932                         }
 933
 934                         if (0 == result) {
 935                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt initialize : result = %d, silence(%d), credential(%d)",
 936                                         result, *silence_supported, *credential_needed);
 937                         } else {
 938                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt initialize : result = %d", result);
 939                         }
 940
 941                         dbus_message_unref(result_msg);
 942                 } else {
 943                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
 944                         stt_dbus_reconnect();
 945                         result = STT_ERROR_TIMED_OUT;
 946                 }
 947         } else {
 948                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
 949                 result = STT_ERROR_OPERATION_FAILED;
 950         }
 951
 952         return result;
 953 }
 954
 955 int stt_dbus_request_finalize(int uid)
 956 {
 957         DBusMessage* msg;
 958
 959         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);
 960
 961         msg = dbus_message_new_method_call(
 962                 g_server_service_name,
 963                 g_server_service_object,
 964                 g_server_service_interface,
 965                 STT_METHOD_FINALIZE);
 966
 967         if (NULL == msg) {
 968                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt finalize : Fail to make message");
 969                 return STT_ERROR_OPERATION_FAILED;
 970         } else {
 971                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt finalize : uid(%d)", uid);
 972         }
 973
 974         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
 975
 976         DBusError err;
 977         dbus_error_init(&err);
 978
 979         DBusMessage* result_msg;
 980         int result = STT_ERROR_OPERATION_FAILED;
 981
 982         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_short_time, &err);
 983         dbus_message_unref(msg);
 984         if (dbus_error_is_set(&err)) {
 985                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
 986                 dbus_error_free(&err);
 987         }
 988
 989         if (NULL != result_msg) {
 990                 dbus_message_get_args(result_msg, &err,
 991                                 DBUS_TYPE_INT32, &result,
 992                                 DBUS_TYPE_INVALID);
 993
 994                 if (dbus_error_is_set(&err)) {
 995                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
 996                         dbus_error_free(&err);
 997                         result = STT_ERROR_OPERATION_FAILED;
 998                 }
 999
1000                 dbus_message_unref(result_msg);
1001
1002                 if (0 == result) {
1003                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt finalize : result = %d", result);
1004                 } else {
1005                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt finalize : result = %d", result);
1006                 }
1007         } else {
1008                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1009                 stt_dbus_reconnect();
1010                 result = STT_ERROR_TIMED_OUT;
1011         }
1012
1013         return result;
1014 }
1015
1016 int stt_dbus_request_set_current_engine(int uid, const char* engine_id, bool* silence_supported, bool* credential_needed)
1017 {
1018         DBusMessage* msg;
1019
1020         msg = dbus_message_new_method_call(
1021                 g_server_service_name,
1022                 g_server_service_object,
1023                 g_server_service_interface,
1024                 STT_METHOD_SET_CURRENT_ENGINE);
1025
1026
1027         if (NULL == msg) {
1028                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set engine : Fail to make message");
1029                 return STT_ERROR_OPERATION_FAILED;
1030         } else {
1031                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set engine : uid(%d), engine_id(%s)", uid, (NULL == engine_id) ? "NULL" : engine_id);
1032         }
1033
1034         dbus_message_append_args(msg,
1035                 DBUS_TYPE_INT32, &uid,
1036                 DBUS_TYPE_STRING, &engine_id,
1037                 DBUS_TYPE_INVALID);
1038
1039         DBusError err;
1040         dbus_error_init(&err);
1041
1042         DBusMessage* result_msg;
1043         int result = STT_ERROR_OPERATION_FAILED;
1044
1045         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1046         dbus_message_unref(msg);
1047         if (dbus_error_is_set(&err)) {
1048                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1049                 dbus_error_free(&err);
1050         }
1051
1052         if (NULL != result_msg) {
1053                 dbus_message_get_args(result_msg, &err,
1054                         DBUS_TYPE_INT32, &result,
1055                         DBUS_TYPE_INT32, silence_supported,
1056                         DBUS_TYPE_INT32, credential_needed,
1057                         DBUS_TYPE_INVALID);
1058
1059                 if (dbus_error_is_set(&err)) {
1060                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1061                         dbus_error_free(&err);
1062                         result = STT_ERROR_OPERATION_FAILED;
1063                 }
1064
1065                 dbus_message_unref(result_msg);
1066
1067                 if (0 == result) {
1068                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set engine : result = %d , silence(%d), credential(%d)",
1069                                 result, *silence_supported, *credential_needed);
1070                 } else {
1071                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set engine : result = %d", result);
1072                 }
1073         } else {
1074                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1075                 stt_dbus_reconnect();
1076                 result = STT_ERROR_TIMED_OUT;
1077         }
1078
1079         return result;
1080 }
1081
1082 int stt_dbus_request_check_app_agreed(int uid, const char* appid, bool* value)
1083 {
1084         if (NULL == appid || NULL == value) {
1085                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1086                 return STT_ERROR_INVALID_PARAMETER;
1087         }
1088
1089         DBusMessage* msg;
1090
1091         msg = dbus_message_new_method_call(
1092                 g_server_service_name,
1093                 g_server_service_object,
1094                 g_server_service_interface,
1095                 STT_METHOD_CHECK_APP_AGREED);
1096
1097         if (NULL == msg) {
1098                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt check app agreed : Fail to make message");
1099                 return STT_ERROR_OPERATION_FAILED;
1100         } else {
1101                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt check app agreed : uid(%d) appid(%s)", uid, appid);
1102         }
1103
1104         dbus_message_append_args(msg,
1105                 DBUS_TYPE_INT32, &uid,
1106                 DBUS_TYPE_STRING, &appid,
1107                 DBUS_TYPE_INVALID);
1108
1109         DBusError err;
1110         dbus_error_init(&err);
1111
1112         DBusMessage* result_msg;
1113         int result = STT_ERROR_OPERATION_FAILED;
1114         int available = -1;
1115
1116         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1117         dbus_message_unref(msg);
1118         if (dbus_error_is_set(&err)) {
1119                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1120                 dbus_error_free(&err);
1121         }
1122
1123         if (NULL != result_msg) {
1124                 dbus_message_get_args(result_msg, &err,
1125                         DBUS_TYPE_INT32, &result,
1126                         DBUS_TYPE_INT32, &available,
1127                         DBUS_TYPE_INVALID);
1128
1129                 if (dbus_error_is_set(&err)) {
1130                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1131                         dbus_error_free(&err);
1132                         result = STT_ERROR_OPERATION_FAILED;
1133                 }
1134                 dbus_message_unref(result_msg);
1135
1136                 if (0 == result) {
1137                         *value = (bool)available;
1138                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt check app agreed : result = %d, available = %d", result, *value);
1139                 } else {
1140                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt check app agreed : result = %d", result);
1141                 }
1142         } else {
1143                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1144                 stt_dbus_reconnect();
1145                 result = STT_ERROR_TIMED_OUT;
1146         }
1147
1148         return result;
1149 }
1150
1151 int stt_dbus_request_get_support_langs(int uid, stt_h stt, stt_supported_language_cb callback, void* user_data)
1152 {
1153         if (NULL == stt || NULL == callback) {
1154                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1155                 return STT_ERROR_INVALID_PARAMETER;
1156         }
1157
1158         DBusMessage* msg;
1159
1160         msg = dbus_message_new_method_call(
1161                 g_server_service_name,
1162                 g_server_service_object,
1163                 g_server_service_interface,
1164                 STT_METHOD_GET_SUPPORT_LANGS);
1165
1166         if (NULL == msg) {
1167                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get supported languages : Fail to make message");
1168                 return STT_ERROR_OPERATION_FAILED;
1169         } else {
1170                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get supported languages : uid(%d)", uid);
1171         }
1172
1173         dbus_message_append_args(msg, DBUS_TYPE_INT32, &uid, DBUS_TYPE_INVALID);
1174
1175         DBusError err;
1176         dbus_error_init(&err);
1177
1178         DBusMessage* result_msg;
1179         DBusMessageIter args;
1180         int result = STT_ERROR_OPERATION_FAILED;
1181
1182         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1183         dbus_message_unref(msg);
1184         if (dbus_error_is_set(&err)) {
1185                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1186                 dbus_error_free(&err);
1187         }
1188
1189         if (NULL != result_msg) {
1190                 if (dbus_message_iter_init(result_msg, &args)) {
1191                         /* Get result */
1192                         if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1193                                 dbus_message_iter_get_basic(&args, &result);
1194                                 dbus_message_iter_next(&args);
1195                         }
1196
1197                         if (0 == result) {
1198                                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1199
1200                                 /* Get voice size */
1201                                 int size = 0;
1202                                 if (DBUS_TYPE_INT32 == dbus_message_iter_get_arg_type(&args)) {
1203                                         dbus_message_iter_get_basic(&args, &size);
1204                                         dbus_message_iter_next(&args);
1205                                 }
1206
1207                                 if (0 >= size) {
1208                                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt size of language error : size = %d", size);
1209                                 } else {
1210                                         int i = 0;
1211                                         char* temp_lang;
1212
1213                                         for (i = 0; i < size; i++) {
1214                                                 dbus_message_iter_get_basic(&args, &(temp_lang));
1215                                                 dbus_message_iter_next(&args);
1216
1217                                                 if (true != callback(stt, temp_lang, user_data)) {
1218                                                         break;
1219                                                 }
1220                                         }
1221                                 }
1222                         } else {
1223                                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result = %d", result);
1224                         }
1225                 }
1226                 dbus_message_unref(result_msg);
1227         } else {
1228                 SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get support languages : result message is NULL");
1229                 stt_dbus_reconnect();
1230                 result = STT_ERROR_TIMED_OUT;
1231         }
1232
1233         return result;
1234 }
1235
1236 int stt_dbus_request_get_default_lang(int uid, char** language)
1237 {
1238         if (NULL == language) {
1239                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1240                 return STT_ERROR_INVALID_PARAMETER;
1241         }
1242
1243         DBusMessage* msg;
1244
1245         msg = dbus_message_new_method_call(
1246                 g_server_service_name,
1247                 g_server_service_object,
1248                 g_server_service_interface,
1249                 STT_METHOD_GET_CURRENT_LANG);
1250
1251         if (NULL == msg) {
1252                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get default language : Fail to make message");
1253                 return STT_ERROR_OPERATION_FAILED;
1254         } else {
1255                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get default language  : uid(%d)", uid);
1256         }
1257
1258         dbus_message_append_args(msg,
1259                 DBUS_TYPE_INT32, &uid,
1260                 DBUS_TYPE_INVALID);
1261
1262         DBusError err;
1263         dbus_error_init(&err);
1264
1265         DBusMessage* result_msg;
1266         int result = STT_ERROR_OPERATION_FAILED;
1267         char* temp_lang = NULL;
1268
1269         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1270         dbus_message_unref(msg);
1271         if (dbus_error_is_set(&err)) {
1272                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1273                 dbus_error_free(&err);
1274         }
1275
1276         if (NULL != result_msg) {
1277                 dbus_message_get_args(result_msg, &err,
1278                         DBUS_TYPE_INT32, &result,
1279                         DBUS_TYPE_STRING, &temp_lang,
1280                         DBUS_TYPE_INVALID);
1281
1282                 if (dbus_error_is_set(&err)) {
1283                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1284                         dbus_error_free(&err);
1285                         result = STT_ERROR_OPERATION_FAILED;
1286                 }
1287                 dbus_message_unref(result_msg);
1288
1289                 if (0 == result) {
1290                         *language = strdup(temp_lang);
1291                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get default language : result = %d, language = %s", result, *language);
1292                 } else {
1293                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get default language : result = %d", result);
1294                 }
1295         } else {
1296                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1297                 stt_dbus_reconnect();
1298                 result = STT_ERROR_TIMED_OUT;
1299         }
1300
1301         return result;
1302 }
1303
1304 int stt_dbus_request_set_private_data(int uid, const char* key, const char* data)
1305 {
1306         if (NULL == key || NULL == data) {
1307                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1308                 return STT_ERROR_INVALID_PARAMETER;
1309         }
1310
1311         DBusMessage* msg;
1312
1313         msg = dbus_message_new_method_call(
1314                 g_server_service_name,
1315                 g_server_service_object,
1316                 g_server_service_interface,
1317                 STT_METHOD_SET_PRIVATE_DATA);
1318
1319         if (NULL == msg) {
1320                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set private data : Fail to make message");
1321                 return STT_ERROR_OPERATION_FAILED;
1322         } else {
1323                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set private data : uid(%d)", uid);
1324         }
1325
1326         if (true != dbus_message_append_args(msg,
1327                         DBUS_TYPE_INT32, &uid,
1328                         DBUS_TYPE_STRING, &key,
1329                         DBUS_TYPE_STRING, &data,
1330                         DBUS_TYPE_INVALID)) {
1331                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1332                 return STT_ERROR_OPERATION_FAILED;
1333         }
1334
1335         DBusError err;
1336         dbus_error_init(&err);
1337
1338         DBusMessage* result_msg;
1339         int result = STT_ERROR_OPERATION_FAILED;
1340
1341         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1342         dbus_message_unref(msg);
1343         if (dbus_error_is_set(&err)) {
1344                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1345                 dbus_error_free(&err);
1346         }
1347
1348         if (NULL != result_msg) {
1349                 dbus_message_get_args(result_msg, &err,
1350                         DBUS_TYPE_INT32, &result,
1351                         DBUS_TYPE_INVALID);
1352
1353                 if (dbus_error_is_set(&err)) {
1354                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1355                         dbus_error_free(&err);
1356                         result = STT_ERROR_OPERATION_FAILED;
1357                 }
1358                 dbus_message_unref(result_msg);
1359
1360                 if (0 == result) {
1361                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set private data : result = %d", result);
1362                 } else {
1363                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set private data : result = %d", result);
1364                 }
1365         } else {
1366                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1367                 stt_dbus_reconnect();
1368                 result = STT_ERROR_TIMED_OUT;
1369         }
1370
1371         return result;
1372 }
1373
1374 int stt_dbus_request_get_private_data(int uid, const char* key, char** data)
1375 {
1376         if (NULL == key || NULL == data) {
1377                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1378                 return STT_ERROR_INVALID_PARAMETER;
1379         }
1380
1381         DBusMessage* msg;
1382
1383         msg = dbus_message_new_method_call(
1384                 g_server_service_name,
1385                 g_server_service_object,
1386                 g_server_service_interface,
1387                 STT_METHOD_GET_PRIVATE_DATA);
1388
1389         if (NULL == msg) {
1390                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt get private data : Fail to make message");
1391                 return STT_ERROR_OPERATION_FAILED;
1392         } else {
1393                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt get private data : uid(%d)", uid);
1394         }
1395
1396         if (true != dbus_message_append_args(msg,
1397                         DBUS_TYPE_INT32, &uid,
1398                         DBUS_TYPE_STRING, &key,
1399                         DBUS_TYPE_INVALID)) {
1400                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Fail to append args");
1401                 return STT_ERROR_OPERATION_FAILED;
1402         }
1403
1404         DBusError err;
1405         dbus_error_init(&err);
1406
1407         DBusMessage* result_msg;
1408         int result = STT_ERROR_OPERATION_FAILED;
1409
1410         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1411         dbus_message_unref(msg);
1412         if (dbus_error_is_set(&err)) {
1413                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1414                 dbus_error_free(&err);
1415         }
1416
1417         char* temp = NULL;
1418         if (NULL != result_msg) {
1419                 dbus_message_get_args(result_msg, &err,
1420                         DBUS_TYPE_INT32, &result,
1421                         DBUS_TYPE_STRING, &temp,
1422                         DBUS_TYPE_INVALID);
1423
1424                 if (dbus_error_is_set(&err)) {
1425                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1426                         dbus_error_free(&err);
1427                         result = STT_ERROR_OPERATION_FAILED;
1428                 }
1429                 dbus_message_unref(result_msg);
1430
1431                 if (0 == result) {
1432                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt get private data : result = %d", result);
1433                         if (NULL != temp) {
1434                                 *data = strdup(temp);
1435                         }
1436                 } else {
1437                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt get private data : result = %d", result);
1438                 }
1439         } else {
1440                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1441                 stt_dbus_reconnect();
1442                 result = STT_ERROR_TIMED_OUT;
1443         }
1444
1445         return result;
1446 }
1447
1448
1449
1450 int stt_dbus_request_is_recognition_type_supported(int uid, const char* type, bool* support)
1451 {
1452         if (NULL == support || NULL == type) {
1453                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1454                 return STT_ERROR_INVALID_PARAMETER;
1455         }
1456
1457         DBusMessage* msg;
1458
1459         msg = dbus_message_new_method_call(
1460                 g_server_service_name,
1461                 g_server_service_object,
1462                 g_server_service_interface,
1463                 STT_METHOD_IS_TYPE_SUPPORTED);
1464
1465         if (NULL == msg) {
1466                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt is partial result supported : Fail to make message");
1467                 return STT_ERROR_OPERATION_FAILED;
1468         } else {
1469                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt is recognition type supported : uid(%d) type(%s)", uid, type);
1470         }
1471
1472         dbus_message_append_args(msg,
1473                 DBUS_TYPE_INT32, &uid,
1474                 DBUS_TYPE_STRING, &type,
1475                 DBUS_TYPE_INVALID);
1476
1477         DBusError err;
1478         dbus_error_init(&err);
1479
1480         DBusMessage* result_msg;
1481         int result = STT_ERROR_OPERATION_FAILED;
1482         int result_support = -1;
1483
1484         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1485         dbus_message_unref(msg);
1486         if (dbus_error_is_set(&err)) {
1487                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1488                 dbus_error_free(&err);
1489         }
1490
1491         if (NULL != result_msg) {
1492                 dbus_message_get_args(result_msg, &err,
1493                         DBUS_TYPE_INT32, &result,
1494                         DBUS_TYPE_INT32, &result_support,
1495                         DBUS_TYPE_INVALID);
1496
1497                 if (dbus_error_is_set(&err)) {
1498                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1499                         dbus_error_free(&err);
1500                         result = STT_ERROR_OPERATION_FAILED;
1501                 }
1502                 dbus_message_unref(result_msg);
1503
1504                 if (0 == result) {
1505                         *support = (bool)result_support;
1506                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt is recognition type supported : result = %d, support = %s", result, *support ? "true" : "false");
1507                 } else {
1508                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt is recognition type supported : result = %d", result);
1509                 }
1510         } else {
1511                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1512                 stt_dbus_reconnect();
1513                 result = STT_ERROR_TIMED_OUT;
1514         }
1515
1516         return result;
1517 }
1518
1519 int stt_dbus_request_set_start_sound(int uid, const char* file)
1520 {
1521         if (NULL == file) {
1522                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1523                 return STT_ERROR_INVALID_PARAMETER;
1524         }
1525
1526         DBusMessage* msg;
1527
1528         msg = dbus_message_new_method_call(
1529                 g_server_service_name,
1530                 g_server_service_object,
1531                 g_server_service_interface,
1532                 STT_METHOD_SET_START_SOUND);
1533
1534         if (NULL == msg) {
1535                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set start sound : Fail to make message");
1536                 return STT_ERROR_OPERATION_FAILED;
1537         } else {
1538                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set start sound : uid(%d) file(%s)", uid, file);
1539         }
1540
1541         dbus_message_append_args(msg,
1542                 DBUS_TYPE_INT32, &uid,
1543                 DBUS_TYPE_STRING, &file,
1544                 DBUS_TYPE_INVALID);
1545
1546         DBusError err;
1547         dbus_error_init(&err);
1548
1549         DBusMessage* result_msg;
1550         int result = STT_ERROR_OPERATION_FAILED;
1551
1552         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1553         dbus_message_unref(msg);
1554         if (dbus_error_is_set(&err)) {
1555                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1556                 dbus_error_free(&err);
1557         }
1558
1559         if (NULL != result_msg) {
1560                 dbus_message_get_args(result_msg, &err,
1561                         DBUS_TYPE_INT32, &result,
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                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1573                 } else {
1574                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set start sound : result = %d", result);
1575                 }
1576         } else {
1577                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1578                 stt_dbus_reconnect();
1579                 result = STT_ERROR_TIMED_OUT;
1580         }
1581
1582         return result;
1583 }
1584
1585 int stt_dbus_request_unset_start_sound(int uid)
1586 {
1587         DBusMessage* msg;
1588
1589         msg = dbus_message_new_method_call(
1590                 g_server_service_name,
1591                 g_server_service_object,
1592                 g_server_service_interface,
1593                 STT_METHOD_UNSET_START_SOUND);
1594
1595         if (NULL == msg) {
1596                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset start sound : Fail to make message");
1597                 return STT_ERROR_OPERATION_FAILED;
1598         } else {
1599                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset start sound : uid(%d)", uid);
1600         }
1601
1602         dbus_message_append_args(msg,
1603                 DBUS_TYPE_INT32, &uid,
1604                 DBUS_TYPE_INVALID);
1605
1606         DBusError err;
1607         dbus_error_init(&err);
1608
1609         DBusMessage* result_msg;
1610         int result = STT_ERROR_OPERATION_FAILED;
1611
1612         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1613         dbus_message_unref(msg);
1614         if (dbus_error_is_set(&err)) {
1615                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1616                 dbus_error_free(&err);
1617         }
1618
1619         if (NULL != result_msg) {
1620                 dbus_message_get_args(result_msg, &err,
1621                         DBUS_TYPE_INT32, &result,
1622                         DBUS_TYPE_INVALID);
1623
1624                 if (dbus_error_is_set(&err)) {
1625                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1626                         dbus_error_free(&err);
1627                         result = STT_ERROR_OPERATION_FAILED;
1628                 }
1629                 dbus_message_unref(result_msg);
1630
1631                 if (0 == result) {
1632                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1633                 } else {
1634                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset start sound : result = %d", result);
1635                 }
1636         } else {
1637                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1638                 stt_dbus_reconnect();
1639                 result = STT_ERROR_TIMED_OUT;
1640         }
1641
1642         return result;
1643 }
1644
1645 int stt_dbus_request_set_stop_sound(int uid, const char* file)
1646 {
1647         if (NULL == file) {
1648                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1649                 return STT_ERROR_INVALID_PARAMETER;
1650         }
1651
1652         DBusMessage* msg;
1653
1654         msg = dbus_message_new_method_call(
1655                 g_server_service_name,
1656                 g_server_service_object,
1657                 g_server_service_interface,
1658                 STT_METHOD_SET_STOP_SOUND);
1659
1660         if (NULL == msg) {
1661                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt set stop sound : Fail to make message");
1662                 return STT_ERROR_OPERATION_FAILED;
1663         } else {
1664                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt set stop sound : uid(%d) file(%s)", uid, file);
1665         }
1666
1667         dbus_message_append_args(msg,
1668                 DBUS_TYPE_INT32, &uid,
1669                 DBUS_TYPE_STRING, &file,
1670                 DBUS_TYPE_INVALID);
1671
1672         DBusError err;
1673         dbus_error_init(&err);
1674
1675         DBusMessage* result_msg;
1676         int result = STT_ERROR_OPERATION_FAILED;
1677
1678         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1679         dbus_message_unref(msg);
1680         if (dbus_error_is_set(&err)) {
1681                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1682                 dbus_error_free(&err);
1683         }
1684
1685         if (NULL != result_msg) {
1686                 dbus_message_get_args(result_msg, &err,
1687                         DBUS_TYPE_INT32, &result,
1688                         DBUS_TYPE_INVALID);
1689
1690                 if (dbus_error_is_set(&err)) {
1691                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1692                         dbus_error_free(&err);
1693                         result = STT_ERROR_OPERATION_FAILED;
1694                 }
1695                 dbus_message_unref(result_msg);
1696
1697                 if (0 == result) {
1698                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1699                 } else {
1700                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt set stop sound : result = %d", result);
1701                 }
1702         } else {
1703                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1704                 stt_dbus_reconnect();
1705                 result = STT_ERROR_TIMED_OUT;
1706         }
1707
1708         return result;
1709 }
1710
1711 int stt_dbus_request_unset_stop_sound(int uid)
1712 {
1713         DBusMessage* msg;
1714
1715         msg = dbus_message_new_method_call(
1716                 g_server_service_name,
1717                 g_server_service_object,
1718                 g_server_service_interface,
1719                 STT_METHOD_UNSET_STOP_SOUND);
1720
1721         if (NULL == msg) {
1722                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt unset stop sound : Fail to make message");
1723                 return STT_ERROR_OPERATION_FAILED;
1724         } else {
1725                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt unset stop sound : uid(%d)", uid);
1726         }
1727
1728         dbus_message_append_args(msg,
1729                 DBUS_TYPE_INT32, &uid,
1730                 DBUS_TYPE_INVALID);
1731
1732         DBusError err;
1733         dbus_error_init(&err);
1734
1735         DBusMessage* result_msg;
1736         int result = STT_ERROR_OPERATION_FAILED;
1737
1738         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1739         dbus_message_unref(msg);
1740         if (dbus_error_is_set(&err)) {
1741                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1742                 dbus_error_free(&err);
1743         }
1744
1745         if (NULL != result_msg) {
1746                 dbus_message_get_args(result_msg, &err,
1747                         DBUS_TYPE_INT32, &result,
1748                         DBUS_TYPE_INVALID);
1749
1750                 if (dbus_error_is_set(&err)) {
1751                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1752                         dbus_error_free(&err);
1753                         result = STT_ERROR_OPERATION_FAILED;
1754                 }
1755                 dbus_message_unref(result_msg);
1756
1757                 if (0 == result) {
1758                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1759                 } else {
1760                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt unset stop sound : result = %d", result);
1761                 }
1762         } else {
1763                 SLOG(LOG_ERROR, TAG_STTC, "<<<< Result message is NULL");
1764                 stt_dbus_reconnect();
1765                 result = STT_ERROR_TIMED_OUT;
1766         }
1767
1768         return result;
1769 }
1770
1771 int stt_dbus_request_start(int uid, const char* lang, const char* type, int silence, const char* appid, const char* credential)
1772 {
1773         if (NULL == lang || NULL == type || NULL == appid) {
1774                 SLOG(LOG_ERROR, TAG_STTC, "Input parameter is NULL");
1775                 return STT_ERROR_INVALID_PARAMETER;
1776         }
1777
1778         DBusMessage* msg;
1779
1780         /* create a signal & check for errors */
1781         msg = dbus_message_new_method_call(
1782                 g_server_service_name,
1783                 g_server_service_object,
1784                 g_server_service_interface,
1785                 STT_METHOD_START);
1786
1787         if (NULL == msg) {
1788                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt start : Fail to make message");
1789                 return STT_ERROR_OPERATION_FAILED;
1790         } else {
1791                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt start : uid(%d), language(%s), type(%s)", uid, lang, type);
1792         }
1793
1794         char *temp = NULL;
1795         if (NULL == credential) {
1796                 temp = strdup("NULL");
1797         } else {
1798                 temp = strdup(credential);
1799         }
1800
1801         dbus_message_append_args(msg,
1802                 DBUS_TYPE_INT32, &uid,
1803                 DBUS_TYPE_STRING, &lang,
1804                 DBUS_TYPE_STRING, &type,
1805                 DBUS_TYPE_INT32, &silence,
1806                 DBUS_TYPE_STRING, &appid,
1807                 DBUS_TYPE_STRING, &temp,
1808                 DBUS_TYPE_INVALID);
1809 #if 1
1810         if (g_conn_sender) {
1811                 dbus_message_set_no_reply(msg, TRUE);
1812
1813                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1814                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt start message : Out Of Memory !");
1815                         if (NULL != temp) {
1816                                         free(temp);
1817                                         temp = NULL;
1818                         }
1819                         return STT_ERROR_OUT_OF_MEMORY;
1820                 } else {
1821                         dbus_connection_flush(g_conn_sender);
1822                 }
1823
1824                 dbus_message_unref(msg);
1825
1826         } else {
1827                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1828                 if (NULL != temp) {
1829                                 free(temp);
1830                                 temp = NULL;
1831                 }
1832                 return STT_ERROR_OPERATION_FAILED;
1833         }
1834
1835         if (NULL != temp) {
1836                         free(temp);
1837                         temp = NULL;
1838         }
1839         return 0;
1840 #else
1841         DBusError err;
1842         dbus_error_init(&err);
1843
1844         DBusMessage* result_msg;
1845         int result = STT_ERROR_OPERATION_FAILED;
1846
1847         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1848         dbus_message_unref(msg);
1849         if (dbus_error_is_set(&err)) {
1850                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1851                 dbus_error_free(&err);
1852         }
1853
1854         if (NULL != result_msg) {
1855                 dbus_message_get_args(result_msg, &err,
1856                         DBUS_TYPE_INT32, &result,
1857                         DBUS_TYPE_INVALID);
1858
1859                 if (dbus_error_is_set(&err)) {
1860                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1861                         dbus_error_free(&err);
1862                         result = STT_ERROR_OPERATION_FAILED;
1863                 }
1864                 dbus_message_unref(result_msg);
1865
1866                 if (0 == result) {
1867                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt start : result = %d ", result);
1868                 } else {
1869                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt start : result = %d ", result);
1870                 }
1871         } else {
1872                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1873                 stt_dbus_reconnect();
1874                 result = STT_ERROR_TIMED_OUT;
1875         }
1876
1877         return result;
1878 #endif
1879 }
1880
1881 int stt_dbus_request_stop(int uid)
1882 {
1883         DBusMessage* msg;
1884
1885         /* create a signal & check for errors */
1886         msg = dbus_message_new_method_call(
1887                 g_server_service_name,
1888                 g_server_service_object,
1889                 g_server_service_interface,
1890                 STT_METHOD_STOP);
1891
1892         if (NULL == msg) {
1893                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt stop : Fail to make message");
1894                 return STT_ERROR_OPERATION_FAILED;
1895         } else {
1896                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt stop : uid(%d)", uid);
1897         }
1898
1899         dbus_message_append_args(msg,
1900                 DBUS_TYPE_INT32, &uid,
1901                 DBUS_TYPE_INVALID);
1902 #if 1
1903         if (g_conn_sender) {
1904                 dbus_message_set_no_reply(msg, TRUE);
1905
1906                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1907                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1908                         return STT_ERROR_OUT_OF_MEMORY;
1909                 } else {
1910                         dbus_connection_flush(g_conn_sender);
1911                 }
1912
1913                 dbus_message_unref(msg);
1914         } else {
1915                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1916                 return STT_ERROR_OPERATION_FAILED;
1917         }
1918
1919         return 0;
1920 #else
1921         DBusError err;
1922         dbus_error_init(&err);
1923
1924         DBusMessage* result_msg;
1925         int result = STT_ERROR_OPERATION_FAILED;
1926
1927         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
1928         dbus_message_unref(msg);
1929         if (dbus_error_is_set(&err)) {
1930                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
1931                 dbus_error_free(&err);
1932         }
1933
1934         if (NULL != result_msg) {
1935                 dbus_message_get_args(result_msg, &err,
1936                         DBUS_TYPE_INT32, &result,
1937                         DBUS_TYPE_INVALID);
1938
1939                 if (dbus_error_is_set(&err)) {
1940                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
1941                         dbus_error_free(&err);
1942                         result = STT_ERROR_OPERATION_FAILED;
1943                 }
1944                 dbus_message_unref(result_msg);
1945
1946                 if (0 == result) {
1947                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt stop : result = %d ", result);
1948                 } else {
1949                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt stop : result = %d ", result);
1950                 }
1951         } else {
1952                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
1953                 stt_dbus_reconnect();
1954                 result = STT_ERROR_TIMED_OUT;
1955         }
1956
1957         return result;
1958 #endif
1959 }
1960
1961 int stt_dbus_request_cancel(int uid)
1962 {
1963         DBusMessage* msg;
1964
1965         /* create a signal & check for errors */
1966         msg = dbus_message_new_method_call(
1967                 g_server_service_name,
1968                 g_server_service_object,
1969                 g_server_service_interface,
1970                 STT_METHOD_CANCEL);
1971
1972         if (NULL == msg) {
1973                 SLOG(LOG_ERROR, TAG_STTC, ">>>> stt cancel : Fail to make message");
1974                 return STT_ERROR_OPERATION_FAILED;
1975         } else {
1976                 SLOG(LOG_DEBUG, TAG_STTC, ">>>> stt cancel : uid(%d)", uid);
1977         }
1978
1979         dbus_message_append_args(msg,
1980                 DBUS_TYPE_INT32, &uid,
1981                 DBUS_TYPE_INVALID);
1982 #if 1
1983         if (g_conn_sender) {
1984                 dbus_message_set_no_reply(msg, TRUE);
1985
1986                 if (!dbus_connection_send(g_conn_sender, msg, NULL)) {
1987                         SLOG(LOG_ERROR, TAG_STTC, "[Dbus ERROR] <<<< stt stop message : Out Of Memory !");
1988                         return STT_ERROR_OUT_OF_MEMORY;
1989                 } else {
1990                         dbus_connection_flush(g_conn_sender);
1991                 }
1992
1993                 dbus_message_unref(msg);
1994         } else {
1995                 SLOG(LOG_WARN, TAG_STTC, "[WARN] dbus connection handle is null (%p)", g_conn_sender);
1996                 return STT_ERROR_OPERATION_FAILED;
1997         }
1998
1999         return 0;
2000 #else
2001         DBusError err;
2002         dbus_error_init(&err);
2003
2004         DBusMessage* result_msg;
2005         int result = STT_ERROR_OPERATION_FAILED;
2006
2007         result_msg = dbus_connection_send_with_reply_and_block(g_conn_sender, msg, g_waiting_time, &err);
2008         dbus_message_unref(msg);
2009         if (dbus_error_is_set(&err)) {
2010                 SLOG(LOG_ERROR, TAG_STTC, "[ERROR] Send Error (%s)", err.message);
2011                 dbus_error_free(&err);
2012         }
2013
2014         if (NULL != result_msg) {
2015                 dbus_message_get_args(result_msg, &err,
2016                         DBUS_TYPE_INT32, &result,
2017                         DBUS_TYPE_INVALID);
2018
2019                 if (dbus_error_is_set(&err)) {
2020                         SLOG(LOG_ERROR, TAG_STTC, "<<<< Get arguments error (%s)", err.message);
2021                         dbus_error_free(&err);
2022                         result = STT_ERROR_OPERATION_FAILED;
2023                 }
2024                 dbus_message_unref(result_msg);
2025
2026                 if (0 == result) {
2027                         SLOG(LOG_DEBUG, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2028                 } else {
2029                         SLOG(LOG_ERROR, TAG_STTC, "<<<< stt cancel : result = %d ", result);
2030                 }
2031         } else {
2032                 SLOG(LOG_DEBUG, TAG_STTC, "<<<< Result Message is NULL");
2033                 stt_dbus_reconnect();
2034                 result = STT_ERROR_TIMED_OUT;
2035         }
2036
2037         return result;
2038 #endif
2039 }