client/stt_dbus.c

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